klip-connector/dist/klip-connector.esm.js

A simple, maximally extensible, dependency minimized framework for building modern Klaytn dApps

import { AbstractConnector } from 'caverjs-react-abstract-connector';
import QRcode from 'qrcode';
import axios from 'axios';

function _extends() {
  _extends = Object.assign || function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];

      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }

    return target;
  };

  return _extends.apply(this, arguments);
}

function _inheritsLoose(subClass, superClass) {
  subClass.prototype = Object.create(superClass.prototype);
  subClass.prototype.constructor = subClass;

  _setPrototypeOf(subClass, superClass);
}

function _getPrototypeOf(o) {
  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {
    return o.__proto__ || Object.getPrototypeOf(o);
  };
  return _getPrototypeOf(o);
}

function _setPrototypeOf(o, p) {
  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {
    o.__proto__ = p;
    return o;
  };

  return _setPrototypeOf(o, p);
}

function _isNativeReflectConstruct() {
  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
  if (Reflect.construct.sham) return false;
  if (typeof Proxy === "function") return true;

  try {
    Date.prototype.toString.call(Reflect.construct(Date, [], function () {}));
    return true;
  } catch (e) {
    return false;
  }
}

function _construct(Parent, args, Class) {
  if (_isNativeReflectConstruct()) {
    _construct = Reflect.construct;
  } else {
    _construct = function _construct(Parent, args, Class) {
      var a = [null];
      a.push.apply(a, args);
      var Constructor = Function.bind.apply(Parent, a);
      var instance = new Constructor();
      if (Class) _setPrototypeOf(instance, Class.prototype);
      return instance;
    };
  }

  return _construct.apply(null, arguments);
}

function _isNativeFunction(fn) {
  return Function.toString.call(fn).indexOf("[native code]") !== -1;
}

function _wrapNativeSuper(Class) {
  var _cache = typeof Map === "function" ? new Map() : undefined;

  _wrapNativeSuper = function _wrapNativeSuper(Class) {
    if (Class === null || !_isNativeFunction(Class)) return Class;

    if (typeof Class !== "function") {
      throw new TypeError("Super expression must either be null or a function");
    }

    if (typeof _cache !== "undefined") {
      if (_cache.has(Class)) return _cache.get(Class);

      _cache.set(Class, Wrapper);
    }

    function Wrapper() {
      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
    }

    Wrapper.prototype = Object.create(Class.prototype, {
      constructor: {
        value: Wrapper,
        enumerable: false,
        writable: true,
        configurable: true
      }
    });
    return _setPrototypeOf(Wrapper, Class);
  };

  return _wrapNativeSuper(Class);
}

function _assertThisInitialized(self) {
  if (self === void 0) {
    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
  }

  return self;
}

// A type of promise-like that resolves synchronously and supports only one observer
var _iteratorSymbol = /*#__PURE__*/typeof Symbol !== "undefined" ? Symbol.iterator || (Symbol.iterator = /*#__PURE__*/Symbol("Symbol.iterator")) : "@@iterator"; // Asynchronously iterate through an object's values
var _asyncIteratorSymbol = /*#__PURE__*/typeof Symbol !== "undefined" ? Symbol.asyncIterator || (Symbol.asyncIterator = /*#__PURE__*/Symbol("Symbol.asyncIterator")) : "@@asyncIterator"; // Asynchronously iterate on a value using it's async iterator if present, or its synchronous iterator if missing

function _catch(body, recover) {
  try {
    var result = body();
  } catch (e) {
    return recover(e);
  }

  if (result && result.then) {
    return result.then(void 0, recover);
  }

  return result;
} // Asynchronously await a promise and pass the result to a finally continuation

// import * as React from 'react'
var request_key = "";
var responseData = undefined;
var intervalCheckResult;
var account = "";

var initData = function initData() {
  request_key = "";
  responseData = undefined;
};

var genQRcode = function genQRcode() {
  initData();
  var mockData = {
    bapp: {
      name: 'definix'
    },
    type: 'auth'
  };
  axios.post('https://a2a-api.klipwallet.com/v2/a2a/prepare', mockData).then(function (response) {
    request_key = response.data.request_key;
    QRcode.toCanvas(document.getElementById('qrcode'), "https://klipwallet.com/?target=/a2a?request_key=" + response.data.request_key, function () {
      intervalCheckResult = setInterval(getResult, 1000);
    });
  });
};

var getResult = function getResult() {
  try {
    var url = "https://a2a-api.klipwallet.com/v2/a2a/result?request_key=" + request_key;
    return Promise.resolve(axios.get(url)).then(function (res) {
      if (res.data.status == "completed") {
        account = res.data.result.klaytn_address;
        responseData = res.data.result.klaytn_address; // const modalELement = document.getElementById("modal")
        // if (modalELement != null)
        // ReactDOM.createPortal( null,modalELement)

        clearInterval(intervalCheckResult);
      }
    });
  } catch (e) {
    return Promise.reject(e);
  }
};

var getAccount = function getAccount() {
  return account;
};
var checkResponse = function checkResponse() {
  try {
    return Promise.resolve(new Promise(function (resolve) {
      var interCheck = setInterval(function () {
        if (responseData != undefined) {
          clearInterval(interCheck);
          resolve(responseData);
        }
      }, 1000);
    }));
  } catch (e) {
    return Promise.reject(e);
  }
};
// }
// export const ExampleComponent = ({ }: Props) => {
//   return <div >Example Component</div>
// }
// const rootElement = document.getElementById("root");
// ReactDOM.render((<ExampleComponent />), rootElement);

function parseSendReturn(sendReturn) {
  return sendReturn.hasOwnProperty('result') ? sendReturn.result : sendReturn;
}

var NoKlaytnProviderError = /*#__PURE__*/function (_Error) {
  _inheritsLoose(NoKlaytnProviderError, _Error);

  function NoKlaytnProviderError() {
    var _this;

    _this = _Error.call(this) || this;
    _this.name = _this.constructor.name;
    _this.message = 'No Klaytn provider was found on window.klaytn.';
    return _this;
  }

  return NoKlaytnProviderError;
}( /*#__PURE__*/_wrapNativeSuper(Error));
var UserRejectedRequestError = /*#__PURE__*/function (_Error2) {
  _inheritsLoose(UserRejectedRequestError, _Error2);

  function UserRejectedRequestError() {
    var _this2;

    _this2 = _Error2.call(this) || this;
    _this2.name = _this2.constructor.name;
    _this2.message = 'The user rejected the request.';
    return _this2;
  }

  return UserRejectedRequestError;
}( /*#__PURE__*/_wrapNativeSuper(Error));
var KlipConnector = /*#__PURE__*/function (_AbstractConnector) {
  _inheritsLoose(KlipConnector, _AbstractConnector);

  function KlipConnector(kwargs) {
    var _this3;

    _this3 = _AbstractConnector.call(this, kwargs) || this;
    _this3.showModal = kwargs.showModal;
    _this3.closeModal = kwargs.closeModal;
    _this3.handleNetworkChanged = _this3.handleNetworkChanged.bind(_assertThisInitialized(_this3));
    _this3.handleChainChanged = _this3.handleChainChanged.bind(_assertThisInitialized(_this3));
    _this3.handleAccountsChanged = _this3.handleAccountsChanged.bind(_assertThisInitialized(_this3));
    _this3.handleClose = _this3.handleClose.bind(_assertThisInitialized(_this3));
    return _this3;
  }

  var _proto = KlipConnector.prototype;

  _proto.handleChainChanged = function handleChainChanged(chainId) {
    if (process.env.NODE_ENV !== "production") {
      console.log("Handling 'chainChanged' event with payload", chainId);
    }

    this.emitUpdate({
      chainId: chainId,
      provider: window.klaytn
    });
  };

  _proto.handleAccountsChanged = function handleAccountsChanged(accounts) {
    if (process.env.NODE_ENV !== "production") {
      console.log("Handling 'accountsChanged' event with payload", accounts);
    }

    if (accounts.length === 0) {
      this.emitDeactivate();
    } else {
      this.emitUpdate({
        account: accounts[0]
      });
    }
  };

  _proto.handleClose = function handleClose(code, reason) {
    if (process.env.NODE_ENV !== "production") {
      console.log("Handling 'close' event with payload", code, reason);
    }

    this.emitDeactivate();
  };

  _proto.handleNetworkChanged = function handleNetworkChanged(networkId) {
    if (process.env.NODE_ENV !== "production") {
      console.log("Handling 'networkChanged' event with payload", networkId);
    }

    this.emitUpdate({
      chainId: networkId,
      provider: window.klaytn
    });
  };

  _proto.activate = function activate() {
    try {
      var _this5 = this;

      var _temp3 = function _temp3() {
        console.log("account klip : ", account); // await window.klaytn.enable().then(sendReturn => sendReturn && parseSendReturn(sendReturn)[0])

        return _extends({
          provider: window.klaytn
        }, account ? {
          account: account
        } : {});
      };

      // if (window.klaytn.on) {
      //   window.klaytn.on('chainChanged', this.handleChainChanged)
      //   window.klaytn.on('accountsChanged', this.handleAccountsChanged)
      //   window.klaytn.on('close', this.handleClose)
      //   window.klaytn.on('networkChanged', this.handleNetworkChanged)
      // }
      var account; // console.log("test")

      console.log("klip activate 1");

      var _temp4 = function () {
        if (!account) {
          _this5.showModal();

          genQRcode();
          return Promise.resolve(checkResponse()).then(function (_klipProvider$checkRe) {
            account = _klipProvider$checkRe;

            // await (window.klaytn.send as Send)('klay_accounts').then(sendReturn => parseSendReturn(sendReturn)[0])
            _this5.closeModal();
          });
        }
      }();

      return Promise.resolve(_temp4 && _temp4.then ? _temp4.then(_temp3) : _temp3(_temp4));
    } catch (e) {
      return Promise.reject(e);
    }
  };

  _proto.getProvider = function getProvider() {
    try {
      return Promise.resolve(window.klaytn);
    } catch (e) {
      return Promise.reject(e);
    }
  };

  _proto.getChainId = function getChainId() {
    return Promise.resolve(8217);
  };

  _proto.getAccount = function getAccount$1() {
    try {
      return Promise.resolve(getAccount());
    } catch (e) {
      return Promise.reject(e);
    }
  };

  _proto.deactivate = function deactivate() {
    if (window.klaytn && window.klaytn.removeListener) {
      window.klaytn.removeListener('chainChanged', this.handleChainChanged);
      window.klaytn.removeListener('accountsChanged', this.handleAccountsChanged);
      window.klaytn.removeListener('close', this.handleClose);
      window.klaytn.removeListener('networkChanged', this.handleNetworkChanged);
    }
  };

  _proto.isAuthorized = function isAuthorized() {
    try {
      if (!window.klaytn) {
        return Promise.resolve(false);
      }

      return Promise.resolve(_catch(function () {
        return Promise.resolve(window.klaytn.send('klay_accounts').then(function (sendReturn) {
          if (parseSendReturn(sendReturn).length > 0) {
            return true;
          } else {
            return false;
          }
        }));
      }, function () {
        return false;
      }));
    } catch (e) {
      return Promise.reject(e);
    }
  };

  return KlipConnector;
}(AbstractConnector);

export { KlipConnector, NoKlaytnProviderError, UserRejectedRequestError };
//# sourceMappingURL=klip-connector.esm.js.map