System.register(["__unresolved_0", "cc", "__unresolved_1", "__unresolved_2"], function (_export, _context) {
  "use strict";

  var _reporterNs, _cclegacy, EventBus, web3, NoEthereumProviderError, TBG, _crd;

  function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }

  function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }

  // import { SendReturnResult, SendReturn, Send, SendOld } from "./types";
  // const web3 = new Web3(Web3.givenProvider);
  // const myContract = new web3.eth.Contract(ercAbi, ETH_CONTRACT);
  function parseSendReturn(sendReturn) {
    return sendReturn.hasOwnProperty("result") ? sendReturn.result : sendReturn;
  }

  function _reportPossibleCrUseOfEventBus(extras) {
    _reporterNs.report("EventBus", "./eventBus", _context.meta, extras);
  }

  function _reportPossibleCrUseOfweb(extras) {
    _reporterNs.report("web3", "./web3", _context.meta, extras);
  }

  _export({
    NoEthereumProviderError: void 0,
    TBG: void 0
  });

  return {
    setters: [function (_unresolved_) {
      _reporterNs = _unresolved_;
    }, function (_cc) {
      _cclegacy = _cc.cclegacy;
    }, function (_unresolved_2) {
      EventBus = _unresolved_2.default;
    }, function (_unresolved_3) {
      web3 = _unresolved_3.web3;
    }],
    execute: function () {
      _crd = true;

      _cclegacy._RF.push({}, "e3aeaE7l21OioLmOiYtZ4CG", "tbg", undefined);

      _export("NoEthereumProviderError", NoEthereumProviderError = class NoEthereumProviderError extends Error {
        constructor() {
          super();
          this.name = this.constructor.name;
          this.message = "No Ethereum provider was found on window.ethereum.";
        }

      });

      _export("TBG", TBG = class TBG extends (_crd && EventBus === void 0 ? (_reportPossibleCrUseOfEventBus({
        error: Error()
      }), EventBus) : EventBus) {
        constructor(params) {
          super();
          this.handleAddListener();
        }

        handleAddListener() {
          if (window.ethereum.on) {
            window.ethereum.on("chainChanged", this.handleChainChanged.bind(this));
            window.ethereum.on("accountsChanged", this.handleAccountsChanged.bind(this));
            window.ethereum.on("close", this.handleClose.bind(this));
            window.ethereum.on("networkChanged", this.handleNetworkChanged.bind(this));
          }
        }

        login() {
          return _asyncToGenerator(function* () {
            if (!window.ethereum) {
              throw new NoEthereumProviderError();
            }

            if (window.ethereum.isMetaMask) {
              window.ethereum.autoRefreshOnNetworkChange = false;
            }

            var account;

            try {
              account = yield window.ethereum.request({
                method: "eth_requestAccounts"
              }).then(sendReturn => parseSendReturn(sendReturn)[0]);
              console.log(account);
              return account;
            } catch (error) {
              if (error.code === 4001) {//   throw new UserRejectedRequestError()
              }

              console.warn(false, "eth_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 = yield window.ethereum.enable().then(sendReturn => sendReturn && parseSendReturn(sendReturn)[0]);
              return account;
            }
          })();
        }

        logout() {
          if (window.ethereum && window.ethereum.removeListener) {
            window.ethereum.removeListener("chainChanged", this.handleChainChanged);
            window.ethereum.removeListener("accountsChanged", this.handleAccountsChanged);
            window.ethereum.removeListener("close", this.handleClose);
            window.ethereum.removeListener("networkChanged", this.handleNetworkChanged);
          }
        }

        sign(_ref) {
          return _asyncToGenerator(function* () {
            var {
              hash
            } = _ref;
            // const res: any = await getData({});
            // const data = '1234';
            // const res = "123";
            var rawData = (_crd && web3 === void 0 ? (_reportPossibleCrUseOfweb({
              error: Error()
            }), web3) : web3).utils.fromUtf8(hash);
            var {
              result
            } = yield window.ethereum.send("personal_sign", [rawData, window.ethereum.selectedAddress.toLowerCase()]);
            return {
              raw: hash,
              sign: result
            };
          })();
        }

        bigNumber(num) {
          return _asyncToGenerator(function* () {
            console.log(num); // const number = await web3.bigNumber(num);

            var number = yield (_crd && web3 === void 0 ? (_reportPossibleCrUseOfweb({
              error: Error()
            }), web3) : web3).toWei(num, "ether");
            return number;
          })();
        }

        createNft(_ref2) {
          return _asyncToGenerator(function* () {
            var {
              abi,
              contract,
              toAddress
            } = _ref2;
            var nftContract = new (_crd && web3 === void 0 ? (_reportPossibleCrUseOfweb({
              error: Error()
            }), web3) : web3).eth.Contract(abi, contract);
            return yield nftContract.methods.Mint(toAddress).send({
              from: toAddress
            });
          })();
        }

        sendTransaction(_ref3) {
          return _asyncToGenerator(function* () {
            var {
              from,
              to,
              value
            } = _ref3;
            yield (_crd && web3 === void 0 ? (_reportPossibleCrUseOfweb({
              error: Error()
            }), web3) : web3).eth.sendTransaction({
              from,
              to,
              value
            });
          })();
        }

        handleNetworkChanged() {
          console.log("handleNetworkChanged");
        }

        handleChainChanged() {
          console.log("handleChainChanged");
        }

        handleAccountsChanged(accounts) {
          console.log(accounts);

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

          this.emit("accountChange");
        }

        handleClose() {
          console.log("handleClose");
        }

        update(deltaTime) {}

      });

      _export("default", TBG);

      _cclegacy._RF.pop();

      _crd = false;
    }
  };
});
//# sourceMappingURL=9f3c1ca7b2b67d5c30ee24cdc47e9cc233c26732.js.map