astra-modal-test 1.0.5 → 1.0.6

package/dist/astra-sdk.es1351.js

@@ -0,0 +1,148 @@
+import { SCWKeyManager as m } from "./astra-sdk.es1410.js";
+import { standardErrors as o } from "./astra-sdk.es1264.js";
+import { ScopedLocalStorage as w } from "./astra-sdk.es1138.js";
+import { hexStringFromNumber as d, ensureIntNumber as y } from "./astra-sdk.es1267.js";
+import { importKeyFromHexString as b, encryptContent as R, exportKeyToHexString as C, decryptContent as S } from "./astra-sdk.es1411.js";
+import { fetchRPCRequest as v } from "./astra-sdk.es1268.js";
+const u = "accounts", l = "activeChain", p = "availableChains", f = "walletCapabilities";
+class O {
+  constructor(t) {
+    var e, a, s;
+    this.metadata = t.metadata, this.communicator = t.communicator, this.callback = t.callback, this.keyManager = new m(), this.storage = new w("CBWSDK", "SCWStateManager"), this.accounts = (e = this.storage.loadObject(u)) !== null && e !== void 0 ? e : [], this.chain = this.storage.loadObject(l) || {
+      id: (s = (a = t.metadata.appChainIds) === null || a === void 0 ? void 0 : a[0]) !== null && s !== void 0 ? s : 1
+    }, this.handshake = this.handshake.bind(this), this.request = this.request.bind(this), this.createRequestMessage = this.createRequestMessage.bind(this), this.decryptResponseMessage = this.decryptResponseMessage.bind(this);
+  }
+  async handshake(t) {
+    var e, a;
+    const s = await this.createRequestMessage({
+      handshake: {
+        method: t.method,
+        params: Object.assign({}, this.metadata, (e = t.params) !== null && e !== void 0 ? e : {})
+      }
+    }), n = await this.communicator.postRequestAndWaitForResponse(s);
+    if ("failure" in n.content)
+      throw n.content.failure;
+    const i = await b("public", n.sender);
+    await this.keyManager.setPeerPublicKey(i);
+    const c = (await this.decryptResponseMessage(n)).result;
+    if ("error" in c)
+      throw c.error;
+    const r = c.value;
+    this.accounts = r, this.storage.storeObject(u, r), (a = this.callback) === null || a === void 0 || a.call(this, "accountsChanged", r);
+  }
+  async request(t) {
+    var e;
+    if (this.accounts.length === 0)
+      throw o.provider.unauthorized();
+    switch (t.method) {
+      case "eth_requestAccounts":
+        return (e = this.callback) === null || e === void 0 || e.call(this, "connect", { chainId: d(this.chain.id) }), this.accounts;
+      case "eth_accounts":
+        return this.accounts;
+      case "eth_coinbase":
+        return this.accounts[0];
+      case "net_version":
+        return this.chain.id;
+      case "eth_chainId":
+        return d(this.chain.id);
+      case "wallet_getCapabilities":
+        return this.storage.loadObject(f);
+      case "wallet_switchEthereumChain":
+        return this.handleSwitchChainRequest(t);
+      case "eth_ecRecover":
+      case "personal_sign":
+      case "personal_ecRecover":
+      case "eth_signTransaction":
+      case "eth_sendTransaction":
+      case "eth_signTypedData_v1":
+      case "eth_signTypedData_v3":
+      case "eth_signTypedData_v4":
+      case "eth_signTypedData":
+      case "wallet_addEthereumChain":
+      case "wallet_watchAsset":
+      case "wallet_sendCalls":
+      case "wallet_showCallsStatus":
+      case "wallet_grantPermissions":
+        return this.sendRequestToPopup(t);
+      default:
+        if (!this.chain.rpcUrl)
+          throw o.rpc.internal("No RPC URL set for chain");
+        return v(t, this.chain.rpcUrl);
+    }
+  }
+  async sendRequestToPopup(t) {
+    var e, a;
+    await ((a = (e = this.communicator).waitForPopupLoaded) === null || a === void 0 ? void 0 : a.call(e));
+    const s = await this.sendEncryptedRequest(t), i = (await this.decryptResponseMessage(s)).result;
+    if ("error" in i)
+      throw i.error;
+    return i.value;
+  }
+  async cleanup() {
+    var t, e;
+    this.storage.clear(), await this.keyManager.clear(), this.accounts = [], this.chain = {
+      id: (e = (t = this.metadata.appChainIds) === null || t === void 0 ? void 0 : t[0]) !== null && e !== void 0 ? e : 1
+    };
+  }
+  /**
+   * @returns `null` if the request was successful.
+   * https://eips.ethereum.org/EIPS/eip-3326#wallet_switchethereumchain
+   */
+  async handleSwitchChainRequest(t) {
+    var e;
+    const a = t.params;
+    if (!a || !(!((e = a[0]) === null || e === void 0) && e.chainId))
+      throw o.rpc.invalidParams();
+    const s = y(a[0].chainId);
+    if (this.updateChain(s))
+      return null;
+    const i = await this.sendRequestToPopup(t);
+    return i === null && this.updateChain(s), i;
+  }
+  async sendEncryptedRequest(t) {
+    const e = await this.keyManager.getSharedSecret();
+    if (!e)
+      throw o.provider.unauthorized("No valid session found, try requestAccounts before other methods");
+    const a = await R({
+      action: t,
+      chainId: this.chain.id
+    }, e), s = await this.createRequestMessage({ encrypted: a });
+    return this.communicator.postRequestAndWaitForResponse(s);
+  }
+  async createRequestMessage(t) {
+    const e = await C("public", await this.keyManager.getOwnPublicKey());
+    return {
+      id: crypto.randomUUID(),
+      sender: e,
+      content: t,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+  }
+  async decryptResponseMessage(t) {
+    var e, a;
+    const s = t.content;
+    if ("failure" in s)
+      throw s.failure;
+    const n = await this.keyManager.getSharedSecret();
+    if (!n)
+      throw o.provider.unauthorized("Invalid session");
+    const i = await S(s.encrypted, n), h = (e = i.data) === null || e === void 0 ? void 0 : e.chains;
+    if (h) {
+      const r = Object.entries(h).map(([g, _]) => ({
+        id: Number(g),
+        rpcUrl: _
+      }));
+      this.storage.storeObject(p, r), this.updateChain(this.chain.id, r);
+    }
+    const c = (a = i.data) === null || a === void 0 ? void 0 : a.capabilities;
+    return c && this.storage.storeObject(f, c), i;
+  }
+  updateChain(t, e) {
+    var a;
+    const s = e ?? this.storage.loadObject(p), n = s == null ? void 0 : s.find((i) => i.id === t);
+    return n ? (n !== this.chain && (this.chain = n, this.storage.storeObject(l, n), (a = this.callback) === null || a === void 0 || a.call(this, "chainChanged", d(n.id))), !0) : !1;
+  }
+}
+export {
+  O as SCWSigner
+};

package/dist/astra-sdk.es1352.js

@@ -0,0 +1,267 @@
+import P from "./astra-sdk.es222.js";
+import m from "./astra-sdk.es1412.js";
+import { LOCAL_STORAGE_ADDRESSES_KEY as A } from "./astra-sdk.es1413.js";
+import { isErrorResponse as d } from "./astra-sdk.es1356.js";
+import { WalletLinkRelay as C } from "./astra-sdk.es1414.js";
+import { WALLETLINK_URL as v } from "./astra-sdk.es1353.js";
+import { standardErrors as i } from "./astra-sdk.es1264.js";
+import { ScopedLocalStorage as E } from "./astra-sdk.es1138.js";
+import { ensureAddressString as l, ensureIntNumber as y, hexStringFromNumber as p, ensureBigInt as _, ensureBuffer as R, encodeToHexString as g, hexStringFromBuffer as S, ensureParsedJSONObject as b } from "./astra-sdk.es1267.js";
+import { fetchRPCRequest as D } from "./astra-sdk.es1268.js";
+const I = "DefaultChainId", T = "DefaultJsonRpcUrl";
+class K {
+  constructor(e) {
+    this._relay = null, this._addresses = [], this.metadata = e.metadata, this._storage = new E("walletlink", v), this.callback = e.callback || null;
+    const s = this._storage.getItem(A);
+    if (s) {
+      const a = s.split(" ");
+      a[0] !== "" && (this._addresses = a.map((t) => l(t)));
+    }
+    this.initializeRelay();
+  }
+  getSession() {
+    const e = this.initializeRelay(), { id: s, secret: a } = e.getWalletLinkSession();
+    return { id: s, secret: a };
+  }
+  async handshake() {
+    await this._eth_requestAccounts();
+  }
+  get selectedAddress() {
+    return this._addresses[0] || void 0;
+  }
+  get jsonRpcUrl() {
+    var e;
+    return (e = this._storage.getItem(T)) !== null && e !== void 0 ? e : void 0;
+  }
+  set jsonRpcUrl(e) {
+    this._storage.setItem(T, e);
+  }
+  updateProviderInfo(e, s) {
+    var a;
+    this.jsonRpcUrl = e;
+    const t = this.getChainId();
+    this._storage.setItem(I, s.toString(10)), y(s) !== t && ((a = this.callback) === null || a === void 0 || a.call(this, "chainChanged", p(s)));
+  }
+  async watchAsset(e) {
+    const s = Array.isArray(e) ? e[0] : e;
+    if (!s.type)
+      throw i.rpc.invalidParams("Type is required");
+    if ((s == null ? void 0 : s.type) !== "ERC20")
+      throw i.rpc.invalidParams(`Asset of type '${s.type}' is not supported`);
+    if (!(s != null && s.options))
+      throw i.rpc.invalidParams("Options are required");
+    if (!(s != null && s.options.address))
+      throw i.rpc.invalidParams("Address is required");
+    const a = this.getChainId(), { address: t, symbol: r, image: n, decimals: h } = s.options, o = await this.initializeRelay().watchAsset(s.type, t, r, h, n, a == null ? void 0 : a.toString());
+    return d(o) ? !1 : !!o.result;
+  }
+  async addEthereumChain(e) {
+    var s, a;
+    const t = e[0];
+    if (((s = t.rpcUrls) === null || s === void 0 ? void 0 : s.length) === 0)
+      throw i.rpc.invalidParams("please pass in at least 1 rpcUrl");
+    if (!t.chainName || t.chainName.trim() === "")
+      throw i.rpc.invalidParams("chainName is a required field");
+    if (!t.nativeCurrency)
+      throw i.rpc.invalidParams("nativeCurrency is a required field");
+    const r = Number.parseInt(t.chainId, 16);
+    if (r === this.getChainId())
+      return !1;
+    const n = this.initializeRelay(), { rpcUrls: h = [], blockExplorerUrls: c = [], chainName: o, iconUrls: u = [], nativeCurrency: f } = t, w = await n.addEthereumChain(r.toString(), h, u, c, o, f);
+    if (d(w))
+      return !1;
+    if (((a = w.result) === null || a === void 0 ? void 0 : a.isApproved) === !0)
+      return this.updateProviderInfo(h[0], r), null;
+    throw i.rpc.internal("unable to add ethereum chain");
+  }
+  async switchEthereumChain(e) {
+    const s = e[0], a = Number.parseInt(s.chainId, 16), r = await this.initializeRelay().switchEthereumChain(a.toString(10), this.selectedAddress || void 0);
+    if (d(r))
+      throw r;
+    const n = r.result;
+    return n.isApproved && n.rpcUrl.length > 0 && this.updateProviderInfo(n.rpcUrl, a), null;
+  }
+  async cleanup() {
+    this.callback = null, this._relay && this._relay.resetAndReload(), this._storage.clear();
+  }
+  _setAddresses(e, s) {
+    var a;
+    if (!Array.isArray(e))
+      throw new Error("addresses is not an array");
+    const t = e.map((r) => l(r));
+    JSON.stringify(t) !== JSON.stringify(this._addresses) && (this._addresses = t, (a = this.callback) === null || a === void 0 || a.call(this, "accountsChanged", t), this._storage.setItem(A, t.join(" ")));
+  }
+  async request(e) {
+    const s = e.params || [];
+    switch (e.method) {
+      case "eth_accounts":
+        return [...this._addresses];
+      case "eth_coinbase":
+        return this.selectedAddress || null;
+      case "net_version":
+        return this.getChainId().toString(10);
+      case "eth_chainId":
+        return p(this.getChainId());
+      case "eth_requestAccounts":
+        return this._eth_requestAccounts();
+      case "eth_ecRecover":
+      case "personal_ecRecover":
+        return this.ecRecover(e);
+      case "personal_sign":
+        return this.personalSign(e);
+      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":
+      case "eth_signTypedData_v3":
+      case "eth_signTypedData_v4":
+      case "eth_signTypedData":
+        return this.signTypedData(e);
+      case "wallet_addEthereumChain":
+        return this.addEthereumChain(s);
+      case "wallet_switchEthereumChain":
+        return this.switchEthereumChain(s);
+      case "wallet_watchAsset":
+        return this.watchAsset(s);
+      default:
+        if (!this.jsonRpcUrl)
+          throw i.rpc.internal("No RPC URL set for chain");
+        return D(e, this.jsonRpcUrl);
+    }
+  }
+  _ensureKnownAddress(e) {
+    const s = l(e);
+    if (!this._addresses.map((t) => l(t)).includes(s))
+      throw new Error("Unknown Ethereum address");
+  }
+  _prepareTransactionParams(e) {
+    const s = e.from ? l(e.from) : this.selectedAddress;
+    if (!s)
+      throw new Error("Ethereum address is unavailable");
+    this._ensureKnownAddress(s);
+    const a = e.to ? l(e.to) : null, t = e.value != null ? _(e.value) : BigInt(0), r = e.data ? R(e.data) : P.alloc(0), n = e.nonce != null ? y(e.nonce) : null, h = e.gasPrice != null ? _(e.gasPrice) : null, c = e.maxFeePerGas != null ? _(e.maxFeePerGas) : null, o = e.maxPriorityFeePerGas != null ? _(e.maxPriorityFeePerGas) : null, u = e.gas != null ? _(e.gas) : null, f = e.chainId ? y(e.chainId) : this.getChainId();
+    return {
+      fromAddress: s,
+      toAddress: a,
+      weiValue: t,
+      data: r,
+      nonce: n,
+      gasPriceInWei: h,
+      maxFeePerGas: c,
+      maxPriorityFeePerGas: o,
+      gasLimit: u,
+      chainId: f
+    };
+  }
+  async ecRecover(e) {
+    const { method: s, params: a } = e;
+    if (!Array.isArray(a))
+      throw i.rpc.invalidParams();
+    const r = await this.initializeRelay().sendRequest({
+      method: "ethereumAddressFromSignedMessage",
+      params: {
+        message: g(a[0]),
+        signature: g(a[1]),
+        addPrefix: s === "personal_ecRecover"
+      }
+    });
+    if (d(r))
+      throw r;
+    return r.result;
+  }
+  getChainId() {
+    var e;
+    return Number.parseInt((e = this._storage.getItem(I)) !== null && e !== void 0 ? e : "1", 10);
+  }
+  async _eth_requestAccounts() {
+    var e, s;
+    if (this._addresses.length > 0)
+      return (e = this.callback) === null || e === void 0 || e.call(this, "connect", { chainId: p(this.getChainId()) }), this._addresses;
+    const t = await this.initializeRelay().requestEthereumAccounts();
+    if (d(t))
+      throw t;
+    if (!t.result)
+      throw new Error("accounts received is empty");
+    return this._setAddresses(t.result), (s = this.callback) === null || s === void 0 || s.call(this, "connect", { chainId: p(this.getChainId()) }), this._addresses;
+  }
+  async personalSign({ params: e }) {
+    if (!Array.isArray(e))
+      throw i.rpc.invalidParams();
+    const s = e[1], a = e[0];
+    this._ensureKnownAddress(s);
+    const r = await this.initializeRelay().sendRequest({
+      method: "signEthereumMessage",
+      params: {
+        address: l(s),
+        message: g(a),
+        addPrefix: !0,
+        typedDataJson: null
+      }
+    });
+    if (d(r))
+      throw r;
+    return r.result;
+  }
+  async _eth_signTransaction(e) {
+    const s = this._prepareTransactionParams(e[0] || {}), t = await this.initializeRelay().signEthereumTransaction(s);
+    if (d(t))
+      throw t;
+    return t.result;
+  }
+  async _eth_sendRawTransaction(e) {
+    const s = R(e[0]), t = await this.initializeRelay().submitEthereumTransaction(s, this.getChainId());
+    if (d(t))
+      throw t;
+    return t.result;
+  }
+  async _eth_sendTransaction(e) {
+    const s = this._prepareTransactionParams(e[0] || {}), t = await this.initializeRelay().signAndSubmitEthereumTransaction(s);
+    if (d(t))
+      throw t;
+    return t.result;
+  }
+  async signTypedData(e) {
+    const { method: s, params: a } = e;
+    if (!Array.isArray(a))
+      throw i.rpc.invalidParams();
+    const t = (o) => {
+      const u = {
+        eth_signTypedData_v1: m.hashForSignTypedDataLegacy,
+        eth_signTypedData_v3: m.hashForSignTypedData_v3,
+        eth_signTypedData_v4: m.hashForSignTypedData_v4,
+        eth_signTypedData: m.hashForSignTypedData_v4
+      };
+      return S(u[s]({
+        data: b(o)
+      }), !0);
+    }, r = a[s === "eth_signTypedData_v1" ? 1 : 0], n = a[s === "eth_signTypedData_v1" ? 0 : 1];
+    this._ensureKnownAddress(r);
+    const c = await this.initializeRelay().sendRequest({
+      method: "signEthereumMessage",
+      params: {
+        address: l(r),
+        message: t(n),
+        typedDataJson: JSON.stringify(n, null, 2),
+        addPrefix: !1
+      }
+    });
+    if (d(c))
+      throw c;
+    return c.result;
+  }
+  initializeRelay() {
+    return this._relay || (this._relay = new C({
+      linkAPIUrl: v,
+      storage: this._storage,
+      metadata: this.metadata,
+      accountsCallback: this._setAddresses.bind(this),
+      chainCallback: this.updateProviderInfo.bind(this)
+    })), this._relay;
+  }
+}
+export {
+  K as WalletLinkSigner
+};

package/dist/astra-sdk.es1353.js

@@ -0,0 +1,6 @@
+const t = "https://keys.coinbase.com/connect", o = "https://www.walletlink.org", c = "https://go.cb-w.com/walletlink";
+export {
+  c as CBW_MOBILE_DEEPLINK_URL,
+  t as CB_KEYS_URL,
+  o as WALLETLINK_URL
+};

package/dist/astra-sdk.es1354.js

@@ -0,0 +1,29 @@
+import { NAME as s, VERSION as c } from "./astra-sdk.es1137.js";
+import { getCrossOriginOpenerPolicy as p } from "./astra-sdk.es1139.js";
+import { standardErrors as d } from "./astra-sdk.es1264.js";
+const t = 420, r = 540;
+function P(o) {
+  const e = (window.innerWidth - t) / 2 + window.screenX, i = (window.innerHeight - r) / 2 + window.screenY;
+  a(o);
+  const n = window.open(o, "Smart Wallet", `width=${t}, height=${r}, left=${e}, top=${i}`);
+  if (n == null || n.focus(), !n)
+    throw d.rpc.internal("Pop up window failed to open");
+  return n;
+}
+function m(o) {
+  o && !o.closed && o.close();
+}
+function a(o) {
+  const e = {
+    sdkName: s,
+    sdkVersion: c,
+    origin: window.location.origin,
+    coop: p()
+  };
+  for (const [i, n] of Object.entries(e))
+    o.searchParams.append(i, n.toString());
+}
+export {
+  m as closePopup,
+  P as openPopup
+};

package/dist/astra-sdk.es1355.js

@@ -0,0 +1,45 @@
+import { errorValues as i, standardErrorCodes as u } from "./astra-sdk.es1263.js";
+const o = "Unspecified error message.", g = "Unspecified server error.";
+function d(e, s = o) {
+  if (e && Number.isInteger(e)) {
+    const t = e.toString();
+    if (r(i, t))
+      return i[t].message;
+    if (c(e))
+      return g;
+  }
+  return s;
+}
+function l(e) {
+  if (!Number.isInteger(e))
+    return !1;
+  const s = e.toString();
+  return !!(i[s] || c(e));
+}
+function p(e, { shouldIncludeStack: s = !1 } = {}) {
+  const t = {};
+  if (e && typeof e == "object" && !Array.isArray(e) && r(e, "code") && l(e.code)) {
+    const n = e;
+    t.code = n.code, n.message && typeof n.message == "string" ? (t.message = n.message, r(n, "data") && (t.data = n.data)) : (t.message = d(t.code), t.data = { originalError: a(e) });
+  } else
+    t.code = u.rpc.internal, t.message = f(e, "message") ? e.message : o, t.data = { originalError: a(e) };
+  return s && (t.stack = f(e, "stack") ? e.stack : void 0), t;
+}
+function c(e) {
+  return e >= -32099 && e <= -32e3;
+}
+function a(e) {
+  return e && typeof e == "object" && !Array.isArray(e) ? Object.assign({}, e) : e;
+}
+function r(e, s) {
+  return Object.prototype.hasOwnProperty.call(e, s);
+}
+function f(e, s) {
+  return typeof e == "object" && e !== null && s in e && typeof e[s] == "string";
+}
+export {
+  g as JSON_RPC_SERVER_ERROR_MESSAGE,
+  d as getMessageFromCode,
+  l as isValidCode,
+  p as serialize
+};

package/dist/astra-sdk.es1356.js

@@ -0,0 +1,6 @@
+function r(e) {
+  return e.errorMessage !== void 0;
+}
+export {
+  r as isErrorResponse
+};

package/dist/astra-sdk.es1357.js

@@ -0,0 +1,4 @@
+var r = {};
+export {
+  r as __exports
+};

package/dist/astra-sdk.es1358.js

@@ -0,0 +1,4 @@
+var o = {};
+export {
+  o as __exports
+};

package/dist/astra-sdk.es1359.js

@@ -0,0 +1,4 @@
+var a = {};
+export {
+  a as __exports
+};