astra-modal-test 1.0.4 → 1.0.6

package/dist/astra-sdk.es1032.js

@@ -0,0 +1,680 @@
+import T from "./astra-sdk.es222.js";
+import { __exports as l } from "./astra-sdk.es1126.js";
+import { __require as j } from "./astra-sdk.es1127.js";
+import { __require as M } from "./astra-sdk.es1104.js";
+import { __require as F } from "./astra-sdk.es1128.js";
+import { __require as N } from "./astra-sdk.es1118.js";
+import { __require as z } from "./astra-sdk.es1120.js";
+import { __require as D } from "./astra-sdk.es1129.js";
+import { __require as U } from "./astra-sdk.es1130.js";
+import { __require as O } from "./astra-sdk.es1131.js";
+import { __require as B } from "./astra-sdk.es1132.js";
+import { __require as L } from "./astra-sdk.es1133.js";
+import { __require as W } from "./astra-sdk.es1134.js";
+import { __require as k } from "./astra-sdk.es1135.js";
+var b;
+function ie() {
+  if (b) return l;
+  b = 1;
+  var w = l.__importDefault || function(p) {
+    return p && p.__esModule ? p : { default: p };
+  };
+  Object.defineProperty(l, "__esModule", { value: !0 }), l.CoinbaseWalletProvider = void 0;
+  const v = w(j()), C = M(), d = /* @__PURE__ */ F(), n = /* @__PURE__ */ N(), S = /* @__PURE__ */ z(), E = /* @__PURE__ */ D(), y = /* @__PURE__ */ U(), u = /* @__PURE__ */ O(), m = w(/* @__PURE__ */ B()), _ = /* @__PURE__ */ L(), I = /* @__PURE__ */ W(), P = /* @__PURE__ */ k(), A = "DefaultChainId", R = "DefaultJsonRpcUrl";
+  let q = class extends C.EventEmitter {
+    constructor(e) {
+      var r, s;
+      super(), this._filterPolyfill = new I.FilterPolyfill(this), this._subscriptionManager = new P.SubscriptionManager(this), this._relay = null, this._addresses = [], this.hasMadeFirstChainChangedEmission = !1, this.setProviderInfo = this.setProviderInfo.bind(this), this.updateProviderInfo = this.updateProviderInfo.bind(this), this.getChainId = this.getChainId.bind(this), this.setAppInfo = this.setAppInfo.bind(this), this.enable = this.enable.bind(this), this.close = this.close.bind(this), this.send = this.send.bind(this), this.sendAsync = this.sendAsync.bind(this), this.request = this.request.bind(this), this._setAddresses = this._setAddresses.bind(this), this.scanQRCode = this.scanQRCode.bind(this), this.genericRequest = this.genericRequest.bind(this), this._chainIdFromOpts = e.chainId, this._jsonRpcUrlFromOpts = e.jsonRpcUrl, this._overrideIsMetaMask = e.overrideIsMetaMask, this._relayProvider = e.relayProvider, this._storage = e.storage, this._relayEventManager = e.relayEventManager, this.diagnostic = e.diagnosticLogger, this.reloadOnDisconnect = !0, this.isCoinbaseWallet = (r = e.overrideIsCoinbaseWallet) !== null && r !== void 0 ? r : !0, this.isCoinbaseBrowser = (s = e.overrideIsCoinbaseBrowser) !== null && s !== void 0 ? s : !1, this.qrUrl = e.qrUrl;
+      const t = this.getChainId(), i = (0, n.prepend0x)(t.toString(16));
+      this.emit("connect", { chainIdStr: i });
+      const a = this._storage.getItem(E.LOCAL_STORAGE_ADDRESSES_KEY);
+      if (a) {
+        const o = a.split(" ");
+        o[0] !== "" && (this._addresses = o.map((h) => (0, n.ensureAddressString)(h)), this.emit("accountsChanged", o));
+      }
+      this._subscriptionManager.events.on("notification", (o) => {
+        this.emit("message", {
+          type: o.method,
+          data: o.params
+        });
+      }), this._isAuthorized() && this.initializeRelay(), window.addEventListener("message", (o) => {
+        var h;
+        if (!(o.origin !== location.origin || o.source !== window) && o.data.type === "walletLinkMessage" && o.data.data.action === "dappChainSwitched") {
+          const c = o.data.data.chainId, g = (h = o.data.data.jsonRpcUrl) !== null && h !== void 0 ? h : this.jsonRpcUrl;
+          this.updateProviderInfo(g, Number(c));
+        }
+      });
+    }
+    /** @deprecated Use `.request({ method: 'eth_accounts' })` instead. */
+    get selectedAddress() {
+      return this._addresses[0] || void 0;
+    }
+    /** @deprecated Use the chain ID. If you still need the network ID, use `.request({ method: 'net_version' })`. */
+    get networkVersion() {
+      return this.getChainId().toString(10);
+    }
+    /** @deprecated Use `.request({ method: 'eth_chainId' })` instead. */
+    get chainId() {
+      return (0, n.prepend0x)(this.getChainId().toString(16));
+    }
+    get isWalletLink() {
+      return !0;
+    }
+    /**
+     * Some DApps (i.e. Alpha Homora) seem to require the window.ethereum object return
+     * true for this method.
+     */
+    get isMetaMask() {
+      return this._overrideIsMetaMask;
+    }
+    get host() {
+      return this.jsonRpcUrl;
+    }
+    get connected() {
+      return !0;
+    }
+    isConnected() {
+      return !0;
+    }
+    get jsonRpcUrl() {
+      var e;
+      return (e = this._storage.getItem(R)) !== null && e !== void 0 ? e : this._jsonRpcUrlFromOpts;
+    }
+    set jsonRpcUrl(e) {
+      this._storage.setItem(R, e);
+    }
+    disableReloadOnDisconnect() {
+      this.reloadOnDisconnect = !1;
+    }
+    setProviderInfo(e, r) {
+      this.isCoinbaseBrowser || (this._chainIdFromOpts = r, this._jsonRpcUrlFromOpts = e), this.updateProviderInfo(this.jsonRpcUrl, this.getChainId());
+    }
+    updateProviderInfo(e, r) {
+      this.jsonRpcUrl = e;
+      const s = this.getChainId();
+      this._storage.setItem(A, r.toString(10)), ((0, n.ensureIntNumber)(r) !== s || !this.hasMadeFirstChainChangedEmission) && (this.emit("chainChanged", this.getChainId()), this.hasMadeFirstChainChangedEmission = !0);
+    }
+    async watchAsset(e, r, s, t, i, a) {
+      const h = await (await this.initializeRelay()).watchAsset(e, r, s, t, i, a == null ? void 0 : a.toString()).promise;
+      return (0, u.isErrorResponse)(h) ? !1 : !!h.result;
+    }
+    async addEthereumChain(e, r, s, t, i, a) {
+      var o, h;
+      if ((0, n.ensureIntNumber)(e) === this.getChainId())
+        return !1;
+      const c = await this.initializeRelay(), g = c.inlineAddEthereumChain(e.toString());
+      !this._isAuthorized() && !g && await c.requestEthereumAccounts().promise;
+      const f = await c.addEthereumChain(e.toString(), r, i, s, t, a).promise;
+      return (0, u.isErrorResponse)(f) ? !1 : (((o = f.result) === null || o === void 0 ? void 0 : o.isApproved) === !0 && this.updateProviderInfo(r[0], e), ((h = f.result) === null || h === void 0 ? void 0 : h.isApproved) === !0);
+    }
+    async switchEthereumChain(e) {
+      const s = await (await this.initializeRelay()).switchEthereumChain(e.toString(10), this.selectedAddress || void 0).promise;
+      if ((0, u.isErrorResponse)(s)) {
+        if (!s.errorCode)
+          return;
+        throw s.errorCode === d.standardErrorCodes.provider.unsupportedChain ? d.standardErrors.provider.unsupportedChain() : d.standardErrors.provider.custom({
+          message: s.errorMessage,
+          code: s.errorCode
+        });
+      }
+      const t = s.result;
+      t.isApproved && t.rpcUrl.length > 0 && this.updateProviderInfo(t.rpcUrl, e);
+    }
+    setAppInfo(e, r) {
+      this.initializeRelay().then((s) => s.setAppInfo(e, r));
+    }
+    /** @deprecated Use `.request({ method: 'eth_requestAccounts' })` instead. */
+    async enable() {
+      var e;
+      return (e = this.diagnostic) === null || e === void 0 || e.log(_.EVENTS.ETH_ACCOUNTS_STATE, {
+        method: "provider::enable",
+        addresses_length: this._addresses.length,
+        sessionIdHash: this._relay ? y.Session.hash(this._relay.session.id) : void 0
+      }), this._isAuthorized() ? [...this._addresses] : await this.send("eth_requestAccounts");
+    }
+    async close() {
+      (await this.initializeRelay()).resetAndReload();
+    }
+    send(e, r) {
+      try {
+        const s = this._send(e, r);
+        if (s instanceof Promise)
+          return s.catch((t) => {
+            throw (0, d.serializeError)(t, e);
+          });
+      } catch (s) {
+        throw (0, d.serializeError)(s, e);
+      }
+    }
+    _send(e, r) {
+      if (typeof e == "string") {
+        const t = e, i = Array.isArray(r) ? r : r !== void 0 ? [r] : [], a = {
+          jsonrpc: "2.0",
+          id: 0,
+          method: t,
+          params: i
+        };
+        return this._sendRequestAsync(a).then((o) => o.result);
+      }
+      if (typeof r == "function") {
+        const t = e, i = r;
+        return this._sendAsync(t, i);
+      }
+      if (Array.isArray(e))
+        return e.map((i) => this._sendRequest(i));
+      const s = e;
+      return this._sendRequest(s);
+    }
+    async sendAsync(e, r) {
+      try {
+        return this._sendAsync(e, r).catch((s) => {
+          throw (0, d.serializeError)(s, e);
+        });
+      } catch (s) {
+        return Promise.reject((0, d.serializeError)(s, e));
+      }
+    }
+    async _sendAsync(e, r) {
+      if (typeof r != "function")
+        throw new Error("callback is required");
+      if (Array.isArray(e)) {
+        const t = r;
+        this._sendMultipleRequestsAsync(e).then((i) => t(null, i)).catch((i) => t(i, null));
+        return;
+      }
+      const s = r;
+      return this._sendRequestAsync(e).then((t) => s(null, t)).catch((t) => s(t, null));
+    }
+    async request(e) {
+      try {
+        return this._request(e).catch((r) => {
+          throw (0, d.serializeError)(r, e.method);
+        });
+      } catch (r) {
+        return Promise.reject((0, d.serializeError)(r, e.method));
+      }
+    }
+    async _request(e) {
+      if (!e || typeof e != "object" || Array.isArray(e))
+        throw d.standardErrors.rpc.invalidRequest({
+          message: "Expected a single, non-array, object argument.",
+          data: e
+        });
+      const { method: r, params: s } = e;
+      if (typeof r != "string" || r.length === 0)
+        throw d.standardErrors.rpc.invalidRequest({
+          message: "'args.method' must be a non-empty string.",
+          data: e
+        });
+      if (s !== void 0 && !Array.isArray(s) && (typeof s != "object" || s === null))
+        throw d.standardErrors.rpc.invalidRequest({
+          message: "'args.params' must be an object or array if provided.",
+          data: e
+        });
+      const t = s === void 0 ? [] : s, i = this._relayEventManager.makeRequestId();
+      return (await this._sendRequestAsync({
+        method: r,
+        params: t,
+        jsonrpc: "2.0",
+        id: i
+      })).result;
+    }
+    async scanQRCode(e) {
+      const s = await (await this.initializeRelay()).scanQRCode((0, n.ensureRegExpString)(e)).promise;
+      if ((0, u.isErrorResponse)(s))
+        throw (0, d.serializeError)(s.errorMessage, "scanQRCode");
+      if (typeof s.result != "string")
+        throw (0, d.serializeError)("result was not a string", "scanQRCode");
+      return s.result;
+    }
+    async genericRequest(e, r) {
+      const t = await (await this.initializeRelay()).genericRequest(e, r).promise;
+      if ((0, u.isErrorResponse)(t))
+        throw (0, d.serializeError)(t.errorMessage, "generic");
+      if (typeof t.result != "string")
+        throw (0, d.serializeError)("result was not a string", "generic");
+      return t.result;
+    }
+    /**
+     * @beta
+     * This method is currently in beta. While it is available for use, please note that it is still under testing and may undergo significant changes.
+     *
+     * @remarks
+     * IMPORTANT: Signature validation is not performed by this method. Users of this method are advised to perform their own signature validation.
+     * Common web3 frontend libraries such as ethers.js and viem provide the `verifyMessage` utility function that can be used for signature validation.
+     *
+     * It combines `eth_requestAccounts` and "Sign-In with Ethereum" (EIP-4361) into a single call.
+     * The returned account and signed message can be used to authenticate the user.
+     *
+     * @param {Object} params - An object with the following properties:
+     * - `nonce` {string}: A unique string to prevent replay attacks.
+     * - `statement` {string}: An optional human-readable ASCII assertion that the user will sign.
+     * - `resources` {string[]}: An optional list of information the user wishes to have resolved as part of authentication by the relying party.
+     *
+     * @returns {Promise<ConnectAndSignInResponse>} A promise that resolves to an object with the following properties:
+     * - `accounts` {string[]}: The Ethereum accounts of the user.
+     * - `message` {string}: The overall message that the user signed. Hex encoded.
+     * - `signature` {string}: The signature of the message, signed with the user's private key. Hex encoded.
+     */
+    async connectAndSignIn(e) {
+      var r;
+      (r = this.diagnostic) === null || r === void 0 || r.log(_.EVENTS.ETH_ACCOUNTS_STATE, {
+        method: "provider::connectAndSignIn",
+        sessionIdHash: this._relay ? y.Session.hash(this._relay.session.id) : void 0
+      });
+      let s;
+      try {
+        const i = await this.initializeRelay();
+        if (!(i instanceof S.MobileRelay))
+          throw new Error("connectAndSignIn is only supported on mobile");
+        if (s = await i.connectAndSignIn(e).promise, (0, u.isErrorResponse)(s))
+          throw new Error(s.errorMessage);
+      } catch (i) {
+        throw typeof i.message == "string" && i.message.match(/(denied|rejected)/i) ? d.standardErrors.provider.userRejectedRequest("User denied account authorization") : i;
+      }
+      if (!s.result)
+        throw new Error("accounts received is empty");
+      const { accounts: t } = s.result;
+      return this._setAddresses(t), this.isCoinbaseBrowser || await this.switchEthereumChain(this.getChainId()), s.result;
+    }
+    async selectProvider(e) {
+      const s = await (await this.initializeRelay()).selectProvider(e).promise;
+      if ((0, u.isErrorResponse)(s))
+        throw (0, d.serializeError)(s.errorMessage, "selectProvider");
+      if (typeof s.result != "string")
+        throw (0, d.serializeError)("result was not a string", "selectProvider");
+      return s.result;
+    }
+    supportsSubscriptions() {
+      return !1;
+    }
+    subscribe() {
+      throw new Error("Subscriptions are not supported");
+    }
+    unsubscribe() {
+      throw new Error("Subscriptions are not supported");
+    }
+    disconnect() {
+      return !0;
+    }
+    _sendRequest(e) {
+      const r = {
+        jsonrpc: "2.0",
+        id: e.id
+      }, { method: s } = e;
+      if (r.result = this._handleSynchronousMethods(e), r.result === void 0)
+        throw new Error(`Coinbase Wallet does not support calling ${s} synchronously without a callback. Please provide a callback parameter to call ${s} asynchronously.`);
+      return r;
+    }
+    _setAddresses(e, r) {
+      if (!Array.isArray(e))
+        throw new Error("addresses is not an array");
+      const s = e.map((t) => (0, n.ensureAddressString)(t));
+      JSON.stringify(s) !== JSON.stringify(this._addresses) && (this._addresses = s, this.emit("accountsChanged", this._addresses), this._storage.setItem(E.LOCAL_STORAGE_ADDRESSES_KEY, s.join(" ")));
+    }
+    _sendRequestAsync(e) {
+      return new Promise((r, s) => {
+        try {
+          const t = this._handleSynchronousMethods(e);
+          if (t !== void 0)
+            return r({
+              jsonrpc: "2.0",
+              id: e.id,
+              result: t
+            });
+          const i = this._handleAsynchronousFilterMethods(e);
+          if (i !== void 0) {
+            i.then((o) => r(Object.assign(Object.assign({}, o), { id: e.id }))).catch((o) => s(o));
+            return;
+          }
+          const a = this._handleSubscriptionMethods(e);
+          if (a !== void 0) {
+            a.then((o) => r({
+              jsonrpc: "2.0",
+              id: e.id,
+              result: o.result
+            })).catch((o) => s(o));
+            return;
+          }
+        } catch (t) {
+          return s(t);
+        }
+        this._handleAsynchronousMethods(e).then((t) => t && r(Object.assign(Object.assign({}, t), { id: e.id }))).catch((t) => s(t));
+      });
+    }
+    _sendMultipleRequestsAsync(e) {
+      return Promise.all(e.map((r) => this._sendRequestAsync(r)));
+    }
+    _handleSynchronousMethods(e) {
+      const { method: r } = e, s = e.params || [];
+      switch (r) {
+        case "eth_accounts":
+          return this._eth_accounts();
+        case "eth_coinbase":
+          return this._eth_coinbase();
+        case "eth_uninstallFilter":
+          return this._eth_uninstallFilter(s);
+        case "net_version":
+          return this._net_version();
+        case "eth_chainId":
+          return this._eth_chainId();
+        default:
+          return;
+      }
+    }
+    async _handleAsynchronousMethods(e) {
+      const { method: r } = e, s = e.params || [];
+      switch (r) {
+        case "eth_requestAccounts":
+          return this._eth_requestAccounts();
+        case "eth_sign":
+          return this._eth_sign(s);
+        case "eth_ecRecover":
+          return this._eth_ecRecover(s);
+        case "personal_sign":
+          return this._personal_sign(s);
+        case "personal_ecRecover":
+          return this._personal_ecRecover(s);
+        case "eth_signTransaction":
+          return this._eth_signTransaction(s);
+        case "eth_sendRawTransaction":
+          return this._eth_sendRawTransaction(s);
+        case "eth_sendTransaction":
+          return this._eth_sendTransaction(s);
+        case "eth_signTypedData_v1":
+          return this._eth_signTypedData_v1(s);
+        case "eth_signTypedData_v2":
+          return this._throwUnsupportedMethodError();
+        case "eth_signTypedData_v3":
+          return this._eth_signTypedData_v3(s);
+        case "eth_signTypedData_v4":
+        case "eth_signTypedData":
+          return this._eth_signTypedData_v4(s);
+        case "cbWallet_arbitrary":
+          return this._cbwallet_arbitrary(s);
+        case "wallet_addEthereumChain":
+          return this._wallet_addEthereumChain(s);
+        case "wallet_switchEthereumChain":
+          return this._wallet_switchEthereumChain(s);
+        case "wallet_watchAsset":
+          return this._wallet_watchAsset(s);
+      }
+      return (await this.initializeRelay()).makeEthereumJSONRPCRequest(e, this.jsonRpcUrl).catch((i) => {
+        var a;
+        throw (i.code === d.standardErrorCodes.rpc.methodNotFound || i.code === d.standardErrorCodes.rpc.methodNotSupported) && ((a = this.diagnostic) === null || a === void 0 || a.log(_.EVENTS.METHOD_NOT_IMPLEMENTED, {
+          method: e.method,
+          sessionIdHash: this._relay ? y.Session.hash(this._relay.session.id) : void 0
+        })), i;
+      });
+    }
+    _handleAsynchronousFilterMethods(e) {
+      const { method: r } = e, s = e.params || [];
+      switch (r) {
+        case "eth_newFilter":
+          return this._eth_newFilter(s);
+        case "eth_newBlockFilter":
+          return this._eth_newBlockFilter();
+        case "eth_newPendingTransactionFilter":
+          return this._eth_newPendingTransactionFilter();
+        case "eth_getFilterChanges":
+          return this._eth_getFilterChanges(s);
+        case "eth_getFilterLogs":
+          return this._eth_getFilterLogs(s);
+      }
+    }
+    _handleSubscriptionMethods(e) {
+      switch (e.method) {
+        case "eth_subscribe":
+        case "eth_unsubscribe":
+          return this._subscriptionManager.handleRequest(e);
+      }
+    }
+    _isKnownAddress(e) {
+      try {
+        const r = (0, n.ensureAddressString)(e);
+        return this._addresses.map((t) => (0, n.ensureAddressString)(t)).includes(r);
+      } catch {
+      }
+      return !1;
+    }
+    _ensureKnownAddress(e) {
+      var r;
+      if (!this._isKnownAddress(e))
+        throw (r = this.diagnostic) === null || r === void 0 || r.log(_.EVENTS.UNKNOWN_ADDRESS_ENCOUNTERED), new Error("Unknown Ethereum address");
+    }
+    _prepareTransactionParams(e) {
+      const r = e.from ? (0, n.ensureAddressString)(e.from) : this.selectedAddress;
+      if (!r)
+        throw new Error("Ethereum address is unavailable");
+      this._ensureKnownAddress(r);
+      const s = e.to ? (0, n.ensureAddressString)(e.to) : null, t = e.value != null ? (0, n.ensureBN)(e.value) : new v.default(0), i = e.data ? (0, n.ensureBuffer)(e.data) : T.alloc(0), a = e.nonce != null ? (0, n.ensureIntNumber)(e.nonce) : null, o = e.gasPrice != null ? (0, n.ensureBN)(e.gasPrice) : null, h = e.maxFeePerGas != null ? (0, n.ensureBN)(e.maxFeePerGas) : null, c = e.maxPriorityFeePerGas != null ? (0, n.ensureBN)(e.maxPriorityFeePerGas) : null, g = e.gas != null ? (0, n.ensureBN)(e.gas) : null, f = e.chainId ? (0, n.ensureIntNumber)(e.chainId) : this.getChainId();
+      return {
+        fromAddress: r,
+        toAddress: s,
+        weiValue: t,
+        data: i,
+        nonce: a,
+        gasPriceInWei: o,
+        maxFeePerGas: h,
+        maxPriorityFeePerGas: c,
+        gasLimit: g,
+        chainId: f
+      };
+    }
+    _isAuthorized() {
+      return this._addresses.length > 0;
+    }
+    _requireAuthorization() {
+      if (!this._isAuthorized())
+        throw d.standardErrors.provider.unauthorized({});
+    }
+    _throwUnsupportedMethodError() {
+      throw d.standardErrors.provider.unsupportedMethod({});
+    }
+    async _signEthereumMessage(e, r, s, t) {
+      this._ensureKnownAddress(r);
+      try {
+        const a = await (await this.initializeRelay()).signEthereumMessage(e, r, s, t).promise;
+        if ((0, u.isErrorResponse)(a))
+          throw new Error(a.errorMessage);
+        return { jsonrpc: "2.0", id: 0, result: a.result };
+      } catch (i) {
+        throw typeof i.message == "string" && i.message.match(/(denied|rejected)/i) ? d.standardErrors.provider.userRejectedRequest("User denied message signature") : i;
+      }
+    }
+    async _ethereumAddressFromSignedMessage(e, r, s) {
+      const i = await (await this.initializeRelay()).ethereumAddressFromSignedMessage(e, r, s).promise;
+      if ((0, u.isErrorResponse)(i))
+        throw new Error(i.errorMessage);
+      return { jsonrpc: "2.0", id: 0, result: i.result };
+    }
+    _eth_accounts() {
+      return [...this._addresses];
+    }
+    _eth_coinbase() {
+      return this.selectedAddress || null;
+    }
+    _net_version() {
+      return this.getChainId().toString(10);
+    }
+    _eth_chainId() {
+      return (0, n.hexStringFromIntNumber)(this.getChainId());
+    }
+    getChainId() {
+      const e = this._storage.getItem(A);
+      if (!e)
+        return (0, n.ensureIntNumber)(this._chainIdFromOpts);
+      const r = parseInt(e, 10);
+      return (0, n.ensureIntNumber)(r);
+    }
+    async _eth_requestAccounts() {
+      var e;
+      if ((e = this.diagnostic) === null || e === void 0 || e.log(_.EVENTS.ETH_ACCOUNTS_STATE, {
+        method: "provider::_eth_requestAccounts",
+        addresses_length: this._addresses.length,
+        sessionIdHash: this._relay ? y.Session.hash(this._relay.session.id) : void 0
+      }), this._isAuthorized())
+        return Promise.resolve({
+          jsonrpc: "2.0",
+          id: 0,
+          result: this._addresses
+        });
+      let r;
+      try {
+        if (r = await (await this.initializeRelay()).requestEthereumAccounts().promise, (0, u.isErrorResponse)(r))
+          throw new Error(r.errorMessage);
+      } catch (s) {
+        throw typeof s.message == "string" && s.message.match(/(denied|rejected)/i) ? d.standardErrors.provider.userRejectedRequest("User denied account authorization") : s;
+      }
+      if (!r.result)
+        throw new Error("accounts received is empty");
+      return this._setAddresses(r.result), this.isCoinbaseBrowser || await this.switchEthereumChain(this.getChainId()), { jsonrpc: "2.0", id: 0, result: this._addresses };
+    }
+    _eth_sign(e) {
+      this._requireAuthorization();
+      const r = (0, n.ensureAddressString)(e[0]), s = (0, n.ensureBuffer)(e[1]);
+      return this._signEthereumMessage(s, r, !1);
+    }
+    _eth_ecRecover(e) {
+      const r = (0, n.ensureBuffer)(e[0]), s = (0, n.ensureBuffer)(e[1]);
+      return this._ethereumAddressFromSignedMessage(r, s, !1);
+    }
+    _personal_sign(e) {
+      this._requireAuthorization();
+      const r = (0, n.ensureBuffer)(e[0]), s = (0, n.ensureAddressString)(e[1]);
+      return this._signEthereumMessage(r, s, !0);
+    }
+    _personal_ecRecover(e) {
+      const r = (0, n.ensureBuffer)(e[0]), s = (0, n.ensureBuffer)(e[1]);
+      return this._ethereumAddressFromSignedMessage(r, s, !0);
+    }
+    async _eth_signTransaction(e) {
+      this._requireAuthorization();
+      const r = this._prepareTransactionParams(e[0] || {});
+      try {
+        const t = await (await this.initializeRelay()).signEthereumTransaction(r).promise;
+        if ((0, u.isErrorResponse)(t))
+          throw new Error(t.errorMessage);
+        return { jsonrpc: "2.0", id: 0, result: t.result };
+      } catch (s) {
+        throw typeof s.message == "string" && s.message.match(/(denied|rejected)/i) ? d.standardErrors.provider.userRejectedRequest("User denied transaction signature") : s;
+      }
+    }
+    async _eth_sendRawTransaction(e) {
+      const r = (0, n.ensureBuffer)(e[0]), t = await (await this.initializeRelay()).submitEthereumTransaction(r, this.getChainId()).promise;
+      if ((0, u.isErrorResponse)(t))
+        throw new Error(t.errorMessage);
+      return { jsonrpc: "2.0", id: 0, result: t.result };
+    }
+    async _eth_sendTransaction(e) {
+      this._requireAuthorization();
+      const r = this._prepareTransactionParams(e[0] || {});
+      try {
+        const t = await (await this.initializeRelay()).signAndSubmitEthereumTransaction(r).promise;
+        if ((0, u.isErrorResponse)(t))
+          throw new Error(t.errorMessage);
+        return { jsonrpc: "2.0", id: 0, result: t.result };
+      } catch (s) {
+        throw typeof s.message == "string" && s.message.match(/(denied|rejected)/i) ? d.standardErrors.provider.userRejectedRequest("User denied transaction signature") : s;
+      }
+    }
+    async _eth_signTypedData_v1(e) {
+      this._requireAuthorization();
+      const r = (0, n.ensureParsedJSONObject)(e[0]), s = (0, n.ensureAddressString)(e[1]);
+      this._ensureKnownAddress(s);
+      const t = m.default.hashForSignTypedDataLegacy({ data: r }), i = JSON.stringify(r, null, 2);
+      return this._signEthereumMessage(t, s, !1, i);
+    }
+    async _eth_signTypedData_v3(e) {
+      this._requireAuthorization();
+      const r = (0, n.ensureAddressString)(e[0]), s = (0, n.ensureParsedJSONObject)(e[1]);
+      this._ensureKnownAddress(r);
+      const t = m.default.hashForSignTypedData_v3({ data: s }), i = JSON.stringify(s, null, 2);
+      return this._signEthereumMessage(t, r, !1, i);
+    }
+    async _eth_signTypedData_v4(e) {
+      this._requireAuthorization();
+      const r = (0, n.ensureAddressString)(e[0]), s = (0, n.ensureParsedJSONObject)(e[1]);
+      this._ensureKnownAddress(r);
+      const t = m.default.hashForSignTypedData_v4({ data: s }), i = JSON.stringify(s, null, 2);
+      return this._signEthereumMessage(t, r, !1, i);
+    }
+    /** @deprecated */
+    async _cbwallet_arbitrary(e) {
+      const r = e[0], s = e[1];
+      if (typeof s != "string")
+        throw new Error("parameter must be a string");
+      if (typeof r != "object" || r === null)
+        throw new Error("parameter must be an object");
+      return { jsonrpc: "2.0", id: 0, result: await this.genericRequest(r, s) };
+    }
+    async _wallet_addEthereumChain(e) {
+      var r, s, t, i;
+      const a = e[0];
+      if (((r = a.rpcUrls) === null || r === void 0 ? void 0 : r.length) === 0)
+        return {
+          jsonrpc: "2.0",
+          id: 0,
+          error: { code: 2, message: "please pass in at least 1 rpcUrl" }
+        };
+      if (!a.chainName || a.chainName.trim() === "")
+        throw d.standardErrors.rpc.invalidParams("chainName is a required field");
+      if (!a.nativeCurrency)
+        throw d.standardErrors.rpc.invalidParams("nativeCurrency is a required field");
+      const o = parseInt(a.chainId, 16);
+      return await this.addEthereumChain(o, (s = a.rpcUrls) !== null && s !== void 0 ? s : [], (t = a.blockExplorerUrls) !== null && t !== void 0 ? t : [], a.chainName, (i = a.iconUrls) !== null && i !== void 0 ? i : [], a.nativeCurrency) ? { jsonrpc: "2.0", id: 0, result: null } : {
+        jsonrpc: "2.0",
+        id: 0,
+        error: { code: 2, message: "unable to add ethereum chain" }
+      };
+    }
+    async _wallet_switchEthereumChain(e) {
+      const r = e[0];
+      return await this.switchEthereumChain(parseInt(r.chainId, 16)), { jsonrpc: "2.0", id: 0, result: null };
+    }
+    async _wallet_watchAsset(e) {
+      const r = Array.isArray(e) ? e[0] : e;
+      if (!r.type)
+        throw d.standardErrors.rpc.invalidParams("Type is required");
+      if ((r == null ? void 0 : r.type) !== "ERC20")
+        throw d.standardErrors.rpc.invalidParams(`Asset of type '${r.type}' is not supported`);
+      if (!(r != null && r.options))
+        throw d.standardErrors.rpc.invalidParams("Options are required");
+      if (!(r != null && r.options.address))
+        throw d.standardErrors.rpc.invalidParams("Address is required");
+      const s = this.getChainId(), { address: t, symbol: i, image: a, decimals: o } = r.options;
+      return { jsonrpc: "2.0", id: 0, result: await this.watchAsset(r.type, t, i, o, a, s) };
+    }
+    _eth_uninstallFilter(e) {
+      const r = (0, n.ensureHexString)(e[0]);
+      return this._filterPolyfill.uninstallFilter(r);
+    }
+    async _eth_newFilter(e) {
+      const r = e[0];
+      return { jsonrpc: "2.0", id: 0, result: await this._filterPolyfill.newFilter(r) };
+    }
+    async _eth_newBlockFilter() {
+      return { jsonrpc: "2.0", id: 0, result: await this._filterPolyfill.newBlockFilter() };
+    }
+    async _eth_newPendingTransactionFilter() {
+      return { jsonrpc: "2.0", id: 0, result: await this._filterPolyfill.newPendingTransactionFilter() };
+    }
+    _eth_getFilterChanges(e) {
+      const r = (0, n.ensureHexString)(e[0]);
+      return this._filterPolyfill.getFilterChanges(r);
+    }
+    _eth_getFilterLogs(e) {
+      const r = (0, n.ensureHexString)(e[0]);
+      return this._filterPolyfill.getFilterLogs(r);
+    }
+    initializeRelay() {
+      return this._relay ? Promise.resolve(this._relay) : this._relayProvider().then((e) => (e.setAccountsCallback((r, s) => this._setAddresses(r, s)), e.setChainCallback((r, s) => {
+        this.updateProviderInfo(s, parseInt(r, 10));
+      }), e.setDappDefaultChainCallback(this._chainIdFromOpts), this._relay = e, e));
+    }
+  };
+  return l.CoinbaseWalletProvider = q, l;
+}
+export {
+  ie as __require
+};

package/dist/astra-sdk.es1033.js

@@ -0,0 +1,7 @@
+import { getDefaultExportFromCjs as r } from "./astra-sdk.es474.js";
+import { __require as o } from "./astra-sdk.es1144.js";
+var e = o();
+const a = /* @__PURE__ */ r(e);
+export {
+  a as default
+};