@aptos-labs/wallet-adapter-core 3.5.0 → 3.7.0

package/dist/index.js

@@ -26,11 +26,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
+  ChainIdToAnsSupportedNetworkMap: () => ChainIdToAnsSupportedNetworkMap,
   NetworkName: () => NetworkName,
-  TxnBuilderTypes: () => import_aptos3.TxnBuilderTypes,
-  Types: () => import_aptos3.Types,
+  TxnBuilderTypes: () => import_aptos4.TxnBuilderTypes,
+  Types: () => import_aptos4.Types,
   WalletCore: () => WalletCore,
   WalletReadyState: () => WalletReadyState,
+  WalletStandardCore: () => WalletStandardCore,
   areBCSArguments: () => areBCSArguments,
   generalizedErrorMessage: () => generalizedErrorMessage,
   getLocalStorage: () => getLocalStorage,
@@ -44,11 +46,9 @@ __export(src_exports, {
 module.exports = __toCommonJS(src_exports);
 
 // src/WalletCore.ts
-var import_aptos2 = require("aptos");
-var import_ts_sdk3 = require("@aptos-labs/ts-sdk");
+var import_aptos3 = require("aptos");
+var import_ts_sdk5 = require("@aptos-labs/ts-sdk");
 var import_eventemitter32 = __toESM(require("eventemitter3"));
-var import_tweetnacl = __toESM(require("tweetnacl"));
-var import_buffer = require("buffer");
 
 // src/constants.ts
 var WalletReadyState = /* @__PURE__ */ ((WalletReadyState2) => {
@@ -64,6 +64,10 @@ var NetworkName = /* @__PURE__ */ ((NetworkName2) => {
   NetworkName2["Devnet"] = "devnet";
   return NetworkName2;
 })(NetworkName || {});
+var ChainIdToAnsSupportedNetworkMap = {
+  "1": "mainnet",
+  "2": "testnet"
+};
 
 // src/error/index.ts
 var WalletError = class extends Error {
@@ -231,27 +235,7 @@ var areBCSArguments = (args) => {
   );
 };
 
-// src/ans.ts
-var ChainIdToAnsContractAddressMap = {
-  "1": "mainnet",
-  "2": "testnet"
-};
-var getNameByAddress = async (chainId, address) => {
-  try {
-    if (!ChainIdToAnsContractAddressMap[chainId])
-      return null;
-    const response = await fetch(
-      `https://www.aptosnames.com/api/${ChainIdToAnsContractAddressMap[chainId]}/v1/name/${address}`
-    );
-    const data = await response.json();
-    return data.name;
-  } catch (e) {
-    console.log("error", e);
-    return null;
-  }
-};
-
-// src/conversion.ts
+// src/LegacyWalletPlugins/conversion.ts
 var import_ts_sdk2 = require("@aptos-labs/ts-sdk");
 var import_aptos = require("aptos");
 function convertNetwork(networkInfo) {
@@ -293,9 +277,39 @@ function convertV2PayloadToV1JSONPayload(payload) {
   }
 }
 
-// src/WalletCoreV1.ts
+// src/LegacyWalletPlugins/WalletCoreV1.ts
+var import_aptos2 = require("aptos");
 var import_eventemitter3 = __toESM(require("eventemitter3"));
+var import_buffer = require("buffer");
+var import_ts_sdk3 = require("@aptos-labs/ts-sdk");
+var import_tweetnacl = __toESM(require("tweetnacl"));
 var WalletCoreV1 = class extends import_eventemitter3.default {
+  async resolveSignAndSubmitTransaction(payloadData, network, wallet, transactionInput) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    if (areBCSArguments(payloadData.functionArguments)) {
+      const aptosConfig = new import_ts_sdk3.AptosConfig({
+        network: convertNetwork(network)
+      });
+      const newPayload = await (0, import_ts_sdk3.generateTransactionPayload)({
+        ...payloadData,
+        aptosConfig
+      });
+      const oldTransactionPayload2 = convertV2TransactionPayloadToV1BCSPayload(newPayload);
+      return await this.signAndSubmitBCSTransaction(
+        oldTransactionPayload2,
+        wallet,
+        {
+          max_gas_amount: ((_a = transactionInput.options) == null ? void 0 : _a.maxGasAmount) ? BigInt((_b = transactionInput.options) == null ? void 0 : _b.maxGasAmount) : void 0,
+          gas_unit_price: ((_c = transactionInput.options) == null ? void 0 : _c.gasUnitPrice) ? BigInt((_d = transactionInput.options) == null ? void 0 : _d.gasUnitPrice) : void 0
+        }
+      );
+    }
+    const oldTransactionPayload = convertV2PayloadToV1JSONPayload(payloadData);
+    return await this.signAndSubmitTransaction(oldTransactionPayload, wallet, {
+      max_gas_amount: ((_e = transactionInput.options) == null ? void 0 : _e.maxGasAmount) ? BigInt((_f = transactionInput.options) == null ? void 0 : _f.maxGasAmount) : void 0,
+      gas_unit_price: ((_g = transactionInput.options) == null ? void 0 : _g.gasUnitPrice) ? BigInt((_h = transactionInput.options) == null ? void 0 : _h.gasUnitPrice) : void 0
+    });
+  }
   async signAndSubmitTransaction(transaction, wallet, options) {
     try {
       const response = await wallet.signAndSubmitTransaction(
@@ -337,6 +351,156 @@ var WalletCoreV1 = class extends import_eventemitter3.default {
       throw new WalletSignTransactionError(errMsg).message;
     }
   }
+  async signMessageAndVerify(message, wallet, account) {
+    try {
+      const response = await wallet.signMessage(message);
+      if (!response)
+        throw new WalletSignMessageAndVerifyError("Failed to sign a message").message;
+      console.log("signMessageAndVerify signMessage response", response);
+      let verified = false;
+      if (Array.isArray(response.signature)) {
+        const { fullMessage, signature, bitmap } = response;
+        if (bitmap) {
+          const minKeysRequired = account.minKeysRequired;
+          if (signature.length < minKeysRequired) {
+            verified = false;
+          } else {
+            const bits = Array.from(bitmap).flatMap(
+              (n) => Array.from({ length: 8 }).map((_, i) => n >> i & 1)
+            );
+            const index = bits.map((_, i) => i).filter((i) => bits[i]);
+            const publicKeys = account.publicKey;
+            const matchedPublicKeys = publicKeys.filter(
+              (_, i) => index.includes(i)
+            );
+            verified = true;
+            for (let i = 0; i < signature.length; i++) {
+              const isSigVerified = import_tweetnacl.default.sign.detached.verify(
+                import_buffer.Buffer.from(fullMessage),
+                import_buffer.Buffer.from(signature[i], "hex"),
+                import_buffer.Buffer.from(matchedPublicKeys[i], "hex")
+              );
+              if (!isSigVerified) {
+                verified = false;
+                break;
+              }
+            }
+          }
+        } else {
+          throw new WalletSignMessageAndVerifyError("Failed to get a bitmap").message;
+        }
+      } else {
+        const currentAccountPublicKey = new import_aptos2.HexString(
+          account.publicKey
+        );
+        const signature = new import_aptos2.HexString(
+          response.signature
+        );
+        verified = import_tweetnacl.default.sign.detached.verify(
+          import_buffer.Buffer.from(response.fullMessage),
+          import_buffer.Buffer.from(signature.noPrefix(), "hex"),
+          import_buffer.Buffer.from(currentAccountPublicKey.noPrefix(), "hex")
+        );
+      }
+      return verified;
+    } catch (error) {
+      const errMsg = generalizedErrorMessage(error);
+      throw new WalletSignMessageAndVerifyError(errMsg).message;
+    }
+  }
+};
+
+// src/WalletCore.ts
+var import_wallet_standard2 = require("@aptos-labs/wallet-standard");
+
+// src/AIP62StandardWallets/WalletStandard.ts
+var import_wallet_standard = require("@aptos-labs/wallet-standard");
+var import_ts_sdk4 = require("@aptos-labs/ts-sdk");
+var WalletStandardCore = class {
+  async signAndSubmitTransaction(transactionInput, aptos, account, wallet) {
+    try {
+      const transaction = await aptos.transaction.build.simple({
+        sender: account.address.toString(),
+        data: transactionInput.data,
+        options: transactionInput.options
+      });
+      const response = await wallet.signAndSubmitTransaction(
+        transaction
+      );
+      if (response.status === import_wallet_standard.UserResponseStatus.REJECTED) {
+        throw new WalletConnectionError("User has rejected the request").message;
+      }
+      return response.args;
+    } catch (error) {
+      const errMsg = generalizedErrorMessage(error);
+      throw new WalletSignAndSubmitMessageError(errMsg).message;
+    }
+  }
+  async signTransaction(transaction, wallet, asFeePayer) {
+    const response = await wallet.signTransaction(
+      transaction,
+      asFeePayer
+    );
+    if (response.status === import_wallet_standard.UserResponseStatus.REJECTED) {
+      throw new WalletConnectionError("User has rejected the request").message;
+    }
+    return response.args;
+  }
+  async signMessage(message, wallet) {
+    try {
+      const response = await wallet.signMessage(
+        message
+      );
+      if (response.status === import_wallet_standard.UserResponseStatus.REJECTED) {
+        throw new WalletConnectionError("User has rejected the request").message;
+      }
+      return response.args;
+    } catch (error) {
+      const errMsg = generalizedErrorMessage(error);
+      throw new WalletSignMessageError(errMsg).message;
+    }
+  }
+  async signMessageAndVerify(message, wallet) {
+    try {
+      const response = await wallet.signMessage(
+        message
+      );
+      const account = await wallet.account();
+      if (response.status === import_wallet_standard.UserResponseStatus.REJECTED) {
+        throw new WalletConnectionError("Failed to sign a message").message;
+      }
+      let verified = false;
+      if (response.args.signature instanceof import_ts_sdk4.MultiEd25519Signature) {
+        if (!(account.publicKey instanceof import_ts_sdk4.MultiEd25519PublicKey)) {
+          throw new WalletSignMessageAndVerifyError(
+            "Public key and Signature type mismatch"
+          ).message;
+        }
+        const { fullMessage, signature } = response.args;
+        const bitmap = signature.bitmap;
+        if (bitmap) {
+          const minKeysRequired = account.publicKey.threshold;
+          if (signature.signatures.length < minKeysRequired) {
+            verified = false;
+          } else {
+            verified = account.publicKey.verifySignature({
+              message: new TextEncoder().encode(fullMessage),
+              signature
+            });
+          }
+        }
+      } else {
+        verified = account.publicKey.verifySignature({
+          message: new TextEncoder().encode(response.args.fullMessage),
+          signature: response.args.signature
+        });
+      }
+      return verified;
+    } catch (error) {
+      const errMsg = generalizedErrorMessage(error);
+      throw new WalletSignMessageAndVerifyError(errMsg).message;
+    }
+  }
 };
 
 // src/WalletCore.ts
@@ -344,18 +508,49 @@ var WalletCore = class extends import_eventemitter32.default {
   constructor(plugins) {
     super();
     this._wallets = [];
+    this._standard_wallets = [];
+    this._all_wallets = [];
     this._wallet = null;
     this._account = null;
     this._network = null;
-    this.waletCoreV1 = new WalletCoreV1();
+    this.walletCoreV1 = new WalletCoreV1();
+    this.walletStandardCore = new WalletStandardCore();
     this._connecting = false;
     this._connected = false;
+    this.standardizeStandardWalletToPluginWalletType = (standardWallet) => {
+      var _a, _b;
+      let standardWalletConvertedToWallet = {
+        name: standardWallet.name,
+        url: standardWallet.url,
+        icon: standardWallet.icon,
+        provider: standardWallet,
+        connect: standardWallet.features["aptos:connect"].connect,
+        disconnect: standardWallet.features["aptos:disconnect"].disconnect,
+        network: standardWallet.features["aptos:network"].network,
+        account: standardWallet.features["aptos:account"].account,
+        signAndSubmitTransaction: (_a = standardWallet.features["aptos:signAndSubmitTransaction"]) == null ? void 0 : _a.signAndSubmitTransaction,
+        signMessage: standardWallet.features["aptos:signMessage"].signMessage,
+        onAccountChange: standardWallet.features["aptos:onAccountChange"].onAccountChange,
+        onNetworkChange: standardWallet.features["aptos:onNetworkChange"].onNetworkChange,
+        signTransaction: standardWallet.features["aptos:signTransaction"].signTransaction,
+        openInMobileApp: (_b = standardWallet.features["aptos:openInMobileApp"]) == null ? void 0 : _b.openInMobileApp,
+        readyState: "Installed" /* Installed */,
+        isAIP62Standard: true
+      };
+      this._all_wallets = this._all_wallets.filter(
+        (item) => item.name !== standardWalletConvertedToWallet.name
+      );
+      this._all_wallets.push(standardWalletConvertedToWallet);
+      this.emit("standardWalletsAdded", standardWalletConvertedToWallet);
+    };
     this._wallets = plugins;
     this.scopePollingDetectionStrategy();
+    this.fetchAptosWallets();
   }
   scopePollingDetectionStrategy() {
     var _a;
     (_a = this._wallets) == null ? void 0 : _a.forEach((wallet) => {
+      this._all_wallets.push(wallet);
       if (!wallet.readyState) {
         wallet.readyState = typeof window === "undefined" || typeof document === "undefined" ? "Unsupported" /* Unsupported */ : "NotDetected" /* NotDetected */;
       }
@@ -373,6 +568,43 @@ var WalletCore = class extends import_eventemitter32.default {
       }
     });
   }
+  fetchAptosWallets() {
+    let { aptosWallets, on } = (0, import_wallet_standard2.getAptosWallets)();
+    this.setWallets(aptosWallets);
+    if (typeof window === "undefined")
+      return;
+    const that = this;
+    const removeRegisterListener = on("register", function() {
+      let { aptosWallets: aptosWallets2 } = (0, import_wallet_standard2.getAptosWallets)();
+      that.setWallets(aptosWallets2);
+    });
+    const removeUnregisterListener = on("unregister", function() {
+      let { aptosWallets: aptosWallets2 } = (0, import_wallet_standard2.getAptosWallets)();
+      that.setWallets(aptosWallets2);
+    });
+  }
+  setWallets(wallets) {
+    const aptosStandardWallets = [];
+    wallets.map((wallet) => {
+      const standardWallet = wallet;
+      standardWallet.readyState = "Installed" /* Installed */;
+      aptosStandardWallets.push(wallet);
+      this.standardizeStandardWalletToPluginWalletType(standardWallet);
+    });
+    this._standard_wallets = aptosStandardWallets;
+  }
+  ensureWalletExists(wallet) {
+    if (!wallet) {
+      throw new WalletNotConnectedError().name;
+    }
+    if (!(wallet.readyState === "Loadable" /* Loadable */ || wallet.readyState === "Installed" /* Installed */))
+      throw new WalletNotReadyError("Wallet is not set").name;
+  }
+  ensureAccountExists(account) {
+    if (!account) {
+      throw new WalletAccountError("Account is not set").name;
+    }
+  }
   doesWalletExist() {
     if (!this._connected || this._connecting || !this._wallet)
       throw new WalletNotConnectedError().name;
@@ -390,10 +622,17 @@ var WalletCore = class extends import_eventemitter32.default {
   async setAnsName() {
     var _a;
     if (((_a = this._network) == null ? void 0 : _a.chainId) && this._account) {
-      const name = await getNameByAddress(
-        this._network.chainId,
-        this._account.address
-      );
+      if (!ChainIdToAnsSupportedNetworkMap[this._network.chainId]) {
+        this._account.ansName = void 0;
+        return;
+      }
+      const aptosConfig = new import_ts_sdk5.AptosConfig({
+        network: convertNetwork(this._network)
+      });
+      const aptos = new import_ts_sdk5.Aptos(aptosConfig);
+      const name = await aptos.ans.getPrimaryName({
+        address: this._account.address
+      });
       this._account.ansName = name;
     }
   }
@@ -401,17 +640,66 @@ var WalletCore = class extends import_eventemitter32.default {
     this._wallet = wallet;
   }
   setAccount(account) {
-    this._account = account;
+    var _a;
+    if (account === null) {
+      this._account = null;
+      return;
+    }
+    if ((_a = this._wallet) == null ? void 0 : _a.isAIP62Standard) {
+      if ("status" in account) {
+        const connectStandardAccount = account;
+        if (connectStandardAccount.status === import_wallet_standard2.UserResponseStatus.REJECTED) {
+          this._connecting = false;
+          throw new WalletConnectionError("User has rejected the request").message;
+        }
+        this._account = {
+          address: connectStandardAccount.args.address.toString(),
+          publicKey: connectStandardAccount.args.publicKey.toString(),
+          ansName: connectStandardAccount.args.ansName
+        };
+        return;
+      } else {
+        const standardAccount = account;
+        this._account = {
+          address: standardAccount.address.toString(),
+          publicKey: standardAccount.publicKey.toString(),
+          ansName: standardAccount.ansName
+        };
+        return;
+      }
+    }
+    this._account = { ...account };
+    return;
   }
   setNetwork(network) {
-    this._network = network;
+    var _a;
+    if (network === null) {
+      this._network = null;
+      return;
+    }
+    if ((_a = this._wallet) == null ? void 0 : _a.isAIP62Standard) {
+      const standardizeNetwork = network;
+      this._network = {
+        name: standardizeNetwork.name,
+        chainId: standardizeNetwork.chainId.toString(),
+        url: standardizeNetwork.url
+      };
+      return;
+    }
+    this._network = { ...network };
   }
   isConnected() {
     return this._connected;
   }
   get wallets() {
+    return this._all_wallets;
+  }
+  get pluginWallets() {
     return this._wallets;
   }
+  get standardWallets() {
+    return this._standard_wallets;
+  }
   get wallet() {
     try {
       if (!this._wallet)
@@ -440,24 +728,29 @@ var WalletCore = class extends import_eventemitter32.default {
     }
   }
   async connect(walletName) {
-    var _a, _b;
-    const selectedWallet = (_a = this._wallets) == null ? void 0 : _a.find(
+    var _a;
+    const selectedWallet = this._all_wallets.find(
       (wallet) => wallet.name === walletName
     );
     if (!selectedWallet)
       return;
     if (this._connected) {
-      if (((_b = this._wallet) == null ? void 0 : _b.name) === walletName)
+      if (((_a = this._wallet) == null ? void 0 : _a.name) === walletName)
         throw new WalletConnectionError(
           `${walletName} wallet is already connected`
         ).message;
     }
     if (isRedirectable()) {
+      if (selectedWallet.isAIP62Standard && selectedWallet.openInMobileApp) {
+        selectedWallet.openInMobileApp();
+        return;
+      }
       if (selectedWallet.deeplinkProvider) {
         const url = encodeURIComponent(window.location.href);
         const location = selectedWallet.deeplinkProvider({ url });
         window.location.href = location;
       }
+      return;
     }
     if (selectedWallet.readyState !== "Installed" /* Installed */ && selectedWallet.readyState !== "Loadable" /* Loadable */) {
       return;
@@ -469,9 +762,9 @@ var WalletCore = class extends import_eventemitter32.default {
       this._connecting = true;
       this.setWallet(selectedWallet);
       const account = await selectedWallet.connect();
-      this.setAccount({ ...account });
+      this.setAccount(account);
       const network = await selectedWallet.network();
-      this.setNetwork({ ...network });
+      this.setNetwork(network);
       await this.setAnsName();
       setLocalStorage(selectedWallet.name);
       this._connected = true;
@@ -485,10 +778,9 @@ var WalletCore = class extends import_eventemitter32.default {
     }
   }
   async disconnect() {
-    var _a;
     try {
-      this.doesWalletExist();
-      await ((_a = this._wallet) == null ? void 0 : _a.disconnect());
+      this.ensureWalletExists(this._wallet);
+      await this._wallet.disconnect();
       this.clearData();
       this.emit("disconnect");
     } catch (error) {
@@ -497,95 +789,102 @@ var WalletCore = class extends import_eventemitter32.default {
     }
   }
   async signAndSubmitTransaction(transactionInput) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
     try {
-      this.doesWalletExist();
-      if (((_a = this._wallet) == null ? void 0 : _a.version) === "v2") {
-        const response2 = await this._wallet.signAndSubmitTransaction({
-          ...transactionInput,
-          sender: (_b = transactionInput.sender) != null ? _b : this._account.address
-        });
-        return response2;
-      }
+      this.ensureWalletExists(this._wallet);
+      this.ensureAccountExists(this._account);
       const payloadData = transactionInput.data;
-      if (areBCSArguments(payloadData.functionArguments)) {
-        const aptosConfig = new import_ts_sdk3.AptosConfig({
-          network: convertNetwork(this._network)
-        });
-        const newPayload = await (0, import_ts_sdk3.generateTransactionPayload)({
-          ...payloadData,
-          aptosConfig
-        });
-        const oldTransactionPayload2 = convertV2TransactionPayloadToV1BCSPayload(newPayload);
-        const response2 = await this.waletCoreV1.signAndSubmitBCSTransaction(
-          oldTransactionPayload2,
-          this._wallet,
-          {
-            max_gas_amount: ((_c = transactionInput.options) == null ? void 0 : _c.maxGasAmount) ? BigInt((_d = transactionInput.options) == null ? void 0 : _d.maxGasAmount) : void 0,
-            gas_unit_price: ((_e = transactionInput.options) == null ? void 0 : _e.gasUnitPrice) ? BigInt((_f = transactionInput.options) == null ? void 0 : _f.gasUnitPrice) : void 0
-          }
-        );
-        const { hash: hash2, ...output2 } = response2;
-        return { hash: hash2, output: output2 };
-      }
-      const oldTransactionPayload = convertV2PayloadToV1JSONPayload(payloadData);
-      const response = await this.waletCoreV1.signAndSubmitTransaction(
-        oldTransactionPayload,
-        this._wallet,
-        {
-          max_gas_amount: ((_g = transactionInput.options) == null ? void 0 : _g.maxGasAmount) ? BigInt((_h = transactionInput.options) == null ? void 0 : _h.maxGasAmount) : void 0,
-          gas_unit_price: ((_i = transactionInput.options) == null ? void 0 : _i.gasUnitPrice) ? BigInt((_j = transactionInput.options) == null ? void 0 : _j.gasUnitPrice) : void 0
+      const aptosConfig = new import_ts_sdk5.AptosConfig({
+        network: convertNetwork(this._network)
+      });
+      const aptos = new import_ts_sdk5.Aptos(aptosConfig);
+      if (this._wallet.signAndSubmitTransaction) {
+        if (this._wallet.isAIP62Standard) {
+          const { hash, ...output } = await this.walletStandardCore.signAndSubmitTransaction(
+            transactionInput,
+            aptos,
+            this._account,
+            this._wallet
+          );
+          return { hash, output };
+        } else {
+          const { hash, ...output } = await this.walletCoreV1.resolveSignAndSubmitTransaction(
+            payloadData,
+            this._network,
+            this._wallet,
+            transactionInput
+          );
+          return { hash, output };
         }
-      );
-      const { hash, ...output } = response;
-      return { hash, output };
+      }
+      const transaction = await aptos.transaction.build.simple({
+        sender: this._account.address,
+        data: transactionInput.data,
+        options: transactionInput.options
+      });
+      const senderAuthenticator = await this.signTransaction(transaction);
+      const response = await this.submitTransaction({
+        transaction,
+        senderAuthenticator
+      });
+      return response;
     } catch (error) {
       const errMsg = generalizedErrorMessage(error);
       throw new WalletSignAndSubmitMessageError(errMsg).message;
     }
   }
   async signTransaction(transactionOrPayload, asFeePayer, options) {
-    var _a, _b, _c;
+    var _a, _b;
     try {
-      this.doesWalletExist();
-      if ("rawTransaction" in transactionOrPayload) {
-        if (((_a = this._wallet) == null ? void 0 : _a.version) !== "v2") {
-          throw new WalletNotSupportedMethod(
-            `Sign Transaction V2 is not supported by ${(_b = this.wallet) == null ? void 0 : _b.name}`
-          ).message;
+      this.ensureWalletExists(this._wallet);
+      this.ensureAccountExists(this._account);
+      if (this._wallet.signTransaction) {
+        if (this._wallet.isAIP62Standard) {
+          if ("rawTransaction" in transactionOrPayload) {
+            return await this.walletStandardCore.signTransaction(
+              transactionOrPayload,
+              this._wallet,
+              asFeePayer
+            );
+          } else {
+            throw new WalletNotSupportedMethod(
+              `Invalid transaction input data was provided, ${(_a = this.wallet) == null ? void 0 : _a.name} expects AnyRawTransaction type. 
+              Please upgrade to the latest Aptos TS SDK https://github.com/aptos-labs/aptos-ts-sdk`
+            ).message;
+          }
         }
-        const accountAuthenticator2 = this._wallet.signTransaction(
-          transactionOrPayload,
-          asFeePayer
-        );
-        return accountAuthenticator2;
-      }
-      if (this._wallet && !("signTransaction" in this._wallet)) {
-        throw new WalletNotSupportedMethod(
-          `Sign Transaction is not supported by ${(_c = this.wallet) == null ? void 0 : _c.name}`
-        ).message;
-      }
-      const response = await this.waletCoreV1.signTransaction(
-        transactionOrPayload,
-        this._wallet,
-        {
-          max_gas_amount: (options == null ? void 0 : options.maxGasAmount) ? BigInt(options == null ? void 0 : options.maxGasAmount) : void 0,
-          gas_unit_price: (options == null ? void 0 : options.gasUnitPrice) ? BigInt(options == null ? void 0 : options.gasUnitPrice) : void 0
+        if ("rawTransaction" in transactionOrPayload) {
+          const accountAuthenticator = await this._wallet.signTransaction(
+            transactionOrPayload,
+            asFeePayer
+          );
+          return accountAuthenticator;
+        } else {
+          const response = await this.walletCoreV1.signTransaction(
+            transactionOrPayload,
+            this._wallet,
+            {
+              max_gas_amount: (options == null ? void 0 : options.maxGasAmount) ? BigInt(options == null ? void 0 : options.maxGasAmount) : void 0,
+              gas_unit_price: (options == null ? void 0 : options.gasUnitPrice) ? BigInt(options == null ? void 0 : options.gasUnitPrice) : void 0
+            }
+          );
+          if (!response) {
+            throw new Error("error");
+          }
+          const deserializer1 = new import_aptos3.BCS.Deserializer(response);
+          const deserializedSignature = import_aptos3.TxnBuilderTypes.SignedTransaction.deserialize(deserializer1);
+          const transactionAuthenticator = deserializedSignature.authenticator;
+          const publicKey = transactionAuthenticator.public_key.value;
+          const signature = transactionAuthenticator.signature.value;
+          const accountAuthenticator = new import_ts_sdk5.AccountAuthenticatorEd25519(
+            new import_ts_sdk5.Ed25519PublicKey(publicKey),
+            new import_ts_sdk5.Ed25519Signature(signature)
+          );
+          return accountAuthenticator;
         }
-      );
-      if (!response) {
-        throw new Error("error");
       }
-      const deserializer1 = new import_aptos2.BCS.Deserializer(response);
-      const deserializedSignature = import_aptos2.TxnBuilderTypes.SignedTransaction.deserialize(deserializer1);
-      const transactionAuthenticator = deserializedSignature.authenticator;
-      const publicKey = transactionAuthenticator.public_key.value;
-      const signature = transactionAuthenticator.signature.value;
-      const accountAuthenticator = new import_ts_sdk3.AccountAuthenticatorEd25519(
-        new import_ts_sdk3.Ed25519PublicKey(publicKey),
-        new import_ts_sdk3.Ed25519Signature(signature)
-      );
-      return accountAuthenticator;
+      throw new WalletNotSupportedMethod(
+        `Sign Transaction is not supported by ${(_b = this.wallet) == null ? void 0 : _b.name}`
+      ).message;
     } catch (error) {
       const errMsg = generalizedErrorMessage(error);
       throw new WalletSignTransactionError(errMsg).message;
@@ -593,8 +892,12 @@ var WalletCore = class extends import_eventemitter32.default {
   }
   async signMessage(message) {
     try {
-      this.doesWalletExist();
+      this.ensureWalletExists(this._wallet);
+      if (this._wallet.isAIP62Standard) {
+        return await this.walletStandardCore.signMessage(message, this._wallet);
+      }
       const response = await this._wallet.signMessage(message);
+      console.log("signMessage response", response);
       return response;
     } catch (error) {
       const errMsg = generalizedErrorMessage(error);
@@ -602,104 +905,76 @@ var WalletCore = class extends import_eventemitter32.default {
     }
   }
   async submitTransaction(transaction) {
-    var _a;
-    if (this._wallet && !("submitTransaction" in this._wallet)) {
-      throw new WalletNotSupportedMethod(
-        `Submit Transaction is not supported by ${(_a = this.wallet) == null ? void 0 : _a.name}`
-      ).message;
-    }
     try {
-      this.doesWalletExist();
-      const pendingTransaction = this._wallet.submitTransaction(
-        transaction
-      );
-      return pendingTransaction;
+      this.ensureWalletExists(this._wallet);
+      if (this._wallet.submitTransaction) {
+        const pendingTransaction = await this._wallet.submitTransaction(transaction);
+        return pendingTransaction;
+      }
+      const { additionalSignersAuthenticators } = transaction;
+      const aptosConfig = new import_ts_sdk5.AptosConfig({
+        network: convertNetwork(this.network)
+      });
+      const aptos = new import_ts_sdk5.Aptos(aptosConfig);
+      if (additionalSignersAuthenticators !== void 0) {
+        const multiAgentTxn = {
+          ...transaction,
+          additionalSignersAuthenticators
+        };
+        return aptos.transaction.submit.multiAgent(multiAgentTxn);
+      } else {
+        return aptos.transaction.submit.simple(transaction);
+      }
     } catch (error) {
       const errMsg = generalizedErrorMessage(error);
       throw new WalletSignTransactionError(errMsg).message;
     }
   }
   async onAccountChange() {
-    var _a;
     try {
-      this.doesWalletExist();
-      await ((_a = this._wallet) == null ? void 0 : _a.onAccountChange(async (data) => {
-        this.setAccount({ ...data });
-        await this.setAnsName();
-        this.emit("accountChange", this._account);
-      }));
+      this.ensureWalletExists(this._wallet);
+      await this._wallet.onAccountChange(
+        async (data) => {
+          this.setAccount(data);
+          await this.setAnsName();
+          this.emit("accountChange", this._account);
+        }
+      );
     } catch (error) {
       const errMsg = generalizedErrorMessage(error);
       throw new WalletAccountChangeError(errMsg).message;
     }
   }
   async onNetworkChange() {
-    var _a;
     try {
-      this.doesWalletExist();
-      await ((_a = this._wallet) == null ? void 0 : _a.onNetworkChange(async (data) => {
-        this.setNetwork({ ...data });
-        await this.setAnsName();
-        this.emit("networkChange", this._network);
-      }));
+      this.ensureWalletExists(this._wallet);
+      await this._wallet.onNetworkChange(
+        async (data) => {
+          this.setNetwork(data);
+          await this.setAnsName();
+          this.emit("networkChange", this._network);
+        }
+      );
     } catch (error) {
       const errMsg = generalizedErrorMessage(error);
       throw new WalletNetworkChangeError(errMsg).message;
     }
   }
   async signMessageAndVerify(message) {
-    var _a;
     try {
-      this.doesWalletExist();
-      if (!this._account)
-        throw new Error("No account found!");
-      const response = await ((_a = this._wallet) == null ? void 0 : _a.signMessage(message));
-      if (!response)
-        throw new WalletSignMessageAndVerifyError("Failed to sign a message").message;
-      let verified = false;
-      if (Array.isArray(response.signature)) {
-        const { fullMessage, signature, bitmap } = response;
-        if (bitmap) {
-          const minKeysRequired = this._account.minKeysRequired;
-          if (signature.length < minKeysRequired) {
-            verified = false;
-          } else {
-            const bits = Array.from(bitmap).flatMap(
-              (n) => Array.from({ length: 8 }).map((_, i) => n >> i & 1)
-            );
-            const index = bits.map((_, i) => i).filter((i) => bits[i]);
-            const publicKeys = this._account.publicKey;
-            const matchedPublicKeys = publicKeys.filter(
-              (_, i) => index.includes(i)
-            );
-            verified = true;
-            for (let i = 0; i < signature.length; i++) {
-              const isSigVerified = import_tweetnacl.default.sign.detached.verify(
-                import_buffer.Buffer.from(fullMessage),
-                import_buffer.Buffer.from(signature[i], "hex"),
-                import_buffer.Buffer.from(matchedPublicKeys[i], "hex")
-              );
-              if (!isSigVerified) {
-                verified = false;
-                break;
-              }
-            }
-          }
-        } else {
-          throw new WalletSignMessageAndVerifyError("Failed to get a bitmap").message;
-        }
-      } else {
-        const currentAccountPublicKey = new import_aptos2.HexString(
-          this._account.publicKey
-        );
-        const signature = new import_aptos2.HexString(response.signature);
-        verified = import_tweetnacl.default.sign.detached.verify(
-          import_buffer.Buffer.from(response.fullMessage),
-          import_buffer.Buffer.from(signature.noPrefix(), "hex"),
-          import_buffer.Buffer.from(currentAccountPublicKey.noPrefix(), "hex")
+      this.ensureWalletExists(this._wallet);
+      this.ensureAccountExists(this._account);
+      if (this._wallet.isAIP62Standard) {
+        return this.walletStandardCore.signMessageAndVerify(
+          message,
+          this._wallet
         );
       }
-      return verified;
+      return await this.walletCoreV1.signMessageAndVerify(
+        message,
+        this._wallet,
+        this._account
+      );
     } catch (error) {
       const errMsg = generalizedErrorMessage(error);
       throw new WalletSignMessageAndVerifyError(errMsg).message;
@@ -707,15 +982,17 @@ var WalletCore = class extends import_eventemitter32.default {
   }
 };
 
-// src/types.ts
-var import_aptos3 = require("aptos");
+// src/LegacyWalletPlugins/types.ts
+var import_aptos4 = require("aptos");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  ChainIdToAnsSupportedNetworkMap,
   NetworkName,
   TxnBuilderTypes,
   Types,
   WalletCore,
   WalletReadyState,
+  WalletStandardCore,
   areBCSArguments,
   generalizedErrorMessage,
   getLocalStorage,