@kanthakran/klip-connr/dist/klip-connr.cjs.development.js

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

'use strict';

function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }

var caverjsReactAbstractConnector = require('caverjs-react-abstract-connector');
var warning = _interopDefault(require('tiny-warning'));
var QRcode = _interopDefault(require('qrcode'));
var axios = _interopDefault(require('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 initData = function initData() {
  request_key = "";
  responseData = undefined;
};

var genQRcode = function genQRcode() {
  initData();
  var mockData = {
    bapp: {
      name: 'definix'
    },
    type: 'auth'
  }; // const modalELement = document.getElementById("modal")
  // if (modalELement != null)
  //   ReactDOM.createPortal(
  //     <div id="myModal"
  //       style={{
  //         display: "none", /* Hidden by default */
  //         position: "fixed", /* Stay in place */
  //         zIndex: 999, /* Sit on top */
  //         left: "0",
  //         top: "0",
  //         width: "100%", /* Full width */
  //         height: "100%", /* Full height */
  //         overflow: "auto", /* Enable scroll if needed */
  //         backgroundColor: "rgba(0,0,0,0.4)" /* Black w/ opacity */
  //       }}
  //     >
  //       <div style={{
  //         backgroundColor: "#fefefe",
  //         margin: "15% auto", /* 15% from the top and centered */
  //         padding: "20px",
  //         border: "1px solid #888",
  //         width: "80%"
  //       }}>
  //         <span style={{
  //           color: "#aaa",
  //           float: "right",
  //           fontSize: "28px",
  //           fontWeight: "bold"
  //         }}>&times;</span>
  //         <canvas id="qrcode" />
  //       </div>
  //     </div>
  //     , modalELement)

  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; // const url = `http://localhost:8080`

    return Promise.resolve(axios.get(url)).then(function (res) {
      console.log("request status : ", res.data.status);

      if (res.data.status != "prepared") {
        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 checkResponse = function checkResponse() {
  try {
    return Promise.resolve(new Promise(function (resolve) {
      var interCheck;

      var isReslove = function isReslove() {
        console.log("check interval");

        if (responseData != undefined) {
          clearInterval(interCheck);
          resolve(responseData);
        }
      };

      interCheck = setInterval(isReslove, 1000);
    }));
  } catch (e) {
    return Promise.reject(e);
  }
}; // export const getResult = () => {
//   axios
//     .get(`https://a2a-api.klipwallet.com/v2/a2a/result?request_key=${requestKey}`)
//     .then((res) => {
//       alert(`json result : ${res.data.result.klaytn_address}`)
//     })
//     .catch(function (error) {
//       // handle error
//       console.log('err ', error)
//     })
// }
// interface Props {
// }
// 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.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) {
    {
      console.log("Handling 'chainChanged' event with payload", chainId);
    }

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

  _proto.handleAccountsChanged = function handleAccountsChanged(accounts) {
    {
      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) {
    {
      console.log("Handling 'close' event with payload", code, reason);
    }

    this.emitDeactivate();
  };

  _proto.handleNetworkChanged = function handleNetworkChanged(networkId) {
    {
      console.log("Handling 'networkChanged' event with payload", networkId);
    }

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

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

      if (!window.klaytn) {
        throw new NoKlaytnProviderError();
      }

      if (window.klaytn.on) {
        window.klaytn.on('chainChanged', _this5.handleChainChanged);
        window.klaytn.on('accountsChanged', _this5.handleAccountsChanged);
        window.klaytn.on('close', _this5.handleClose);
        window.klaytn.on('networkChanged', _this5.handleNetworkChanged);
      } // if ((window.klaytn as any).isMetaMask) {
      //   ;(window.klaytn as any).autoRefreshOnNetworkChange = false
      // }
      // try to activate + get account via klay_requestAccounts


      var account; // try {
      //   account = await (window.klaytn.send as Send)('klay_requestAccounts').then(
      //     sendReturn => parseSendReturn(sendReturn)[0]
      //   )
      // } catch (error) {
      //   if ((error as any).code === 4001) {
      //     throw new UserRejectedRequestError()
      //   }
      //   warning(false, 'klay_requestAccounts was unsuccessful, falling back to enable')
      // }
      // if unsuccessful, try enable
      // if (!account) {
      //   // if enable is successful but doesn't return accounts, fall back to getAccount (not happy i have to do this...)
      //   // account = await window.klaytn.enable().then(sendReturn => sendReturn && parseSendReturn(sendReturn)[0])
      //   klipProvider.genQRcode()
      //   account = await klipProvider.checkResponse()
      // }

      console.log("test");
      genQRcode();
      return Promise.resolve(checkResponse()).then(function (_klipProvider$checkRe) {
        account = _klipProvider$checkRe;
        return _extends({
          provider: window.klaytn
        }, account ? {
          account: account
        } : {});
      });
    } 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() {
    try {
      var _temp7 = function _temp7() {
        function _temp3() {
          if (!chainId) {
            try {
              chainId = parseSendReturn(window.klaytn.send({
                method: 'net_version'
              }));
            } catch (_unused) {
              "development" !== "production" ? warning(false, 'net_version v2 was unsuccessful, falling back to manual matches and static properties') : void 0;
            }
          }

          if (!chainId) {
            if (window.klaytn.isDapper) {
              chainId = parseSendReturn(window.klaytn.cachedResults.net_version);
            } else {
              chainId = window.klaytn.chainId || window.klaytn.netVersion || window.klaytn.networkVersion || window.klaytn._chainId;
            }
          }

          return chainId;
        }

        var _temp2 = function () {
          if (!chainId) {
            var _temp6 = _catch(function () {
              return Promise.resolve(window.klaytn.send('net_version').then(parseSendReturn)).then(function (_window$klaytn$send$t2) {
                chainId = _window$klaytn$send$t2;
              });
            }, function () {
              "development" !== "production" ? warning(false, 'net_version was unsuccessful, falling back to net version v2') : void 0;
            });

            if (_temp6 && _temp6.then) return _temp6.then(function () {});
          }
        }();

        return _temp2 && _temp2.then ? _temp2.then(_temp3) : _temp3(_temp2);
      };

      if (!window.klaytn) {
        throw new NoKlaytnProviderError();
      }

      var chainId;

      var _temp8 = _catch(function () {
        return Promise.resolve(window.klaytn.send('klay_chainId').then(parseSendReturn)).then(function (_window$klaytn$send$t) {
          chainId = _window$klaytn$send$t;
        });
      }, function () {
        "development" !== "production" ? warning(false, 'klay_chainId was unsuccessful, falling back to net_version') : void 0;
      });

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

  _proto.getAccount = function getAccount() {
    try {
      var _temp15 = function _temp15() {
        function _temp11() {
          if (!account) {
            account = parseSendReturn(window.klaytn.send({
              method: 'klay_accounts'
            }))[0];
          }

          return account;
        }

        var _temp10 = function () {
          if (!account) {
            var _temp14 = _catch(function () {
              return Promise.resolve(window.klaytn.enable().then(function (sendReturn) {
                return parseSendReturn(sendReturn)[0];
              })).then(function (_window$klaytn$enable) {
                account = _window$klaytn$enable;
              });
            }, function () {
              "development" !== "production" ? warning(false, 'enable was unsuccessful, falling back to klay_accounts v2') : void 0;
            });

            if (_temp14 && _temp14.then) return _temp14.then(function () {});
          }
        }();

        return _temp10 && _temp10.then ? _temp10.then(_temp11) : _temp11(_temp10);
      };

      if (!window.klaytn) {
        throw new NoKlaytnProviderError();
      }

      var account;

      var _temp16 = _catch(function () {
        return Promise.resolve(window.klaytn.send('klay_accounts').then(function (sendReturn) {
          return parseSendReturn(sendReturn)[0];
        })).then(function (_window$klaytn$send$t3) {
          account = _window$klaytn$send$t3;
        });
      }, function () {
        "development" !== "production" ? warning(false, 'klay_accounts was unsuccessful, falling back to enable') : void 0;
      });

      return Promise.resolve(_temp16 && _temp16.then ? _temp16.then(_temp15) : _temp15(_temp16));
    } 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;
}(caverjsReactAbstractConnector.AbstractConnector);

exports.KlipConnector = KlipConnector;
exports.NoKlaytnProviderError = NoKlaytnProviderError;
exports.UserRejectedRequestError = UserRejectedRequestError;
//# sourceMappingURL=klip-connr.cjs.development.js.map