starknet 10.3.3 → 10.4.0

package/dist/index.global.js

@@ -146,6 +146,7 @@ var starknet = (() => {
     ValidateType: () => ValidateType,
     WalletAccount: () => WalletAccount,
     WalletAccountV5: () => WalletAccountV5,
+    WalletAccountV6: () => WalletAccountV6,
     WebSocketChannel: () => WebSocketChannel,
     WebSocketNotConnectedError: () => WebSocketNotConnectedError,
     addAddressPadding: () => addAddressPadding,
@@ -215,7 +216,8 @@ var starknet = (() => {
     validateChecksumAddress: () => validateChecksumAddress,
     verifyMessageInStarknet: () => verifyMessageInStarknet,
     wallet: () => connect_exports,
-    walletV5: () => connectV5_exports
+    walletV5: () => connectV5_exports,
+    walletV6: () => connectV6_exports
   });
 
   // src/global/constants.ts
@@ -17585,6 +17587,7 @@ ${indent}}` : "}";
     requestChainId: () => requestChainId,
     signMessage: () => signMessage,
     supportedSpecs: () => supportedSpecs,
+    supportedWalletApi: () => supportedWalletApi,
     switchStarknetChain: () => switchStarknetChain,
     watchAsset: () => watchAsset
   });
@@ -17627,6 +17630,9 @@ ${indent}}` : "}";
   function supportedSpecs(swo) {
     return swo.request({ type: "wallet_supportedSpecs" });
   }
+  function supportedWalletApi(swo) {
+    return swo.request({ type: "wallet_supportedWalletApi" });
+  }
   function onAccountChange(swo, callback) {
     swo.on("accountsChanged", callback);
   }
@@ -17750,11 +17756,16 @@ ${indent}}` : "}";
     requestAccounts: () => requestAccounts2,
     requestChainId: () => requestChainId2,
     signMessage: () => signMessage2,
+    standardConnect: () => standardConnect,
     subscribeWalletEvent: () => subscribeWalletEvent,
     supportedSpecs: () => supportedSpecs2,
+    supportedWalletApi: () => supportedWalletApi2,
     switchStarknetChain: () => switchStarknetChain2,
     watchAsset: () => watchAsset2
   });
+  function standardConnect(walletWSF, silent_mode = false) {
+    return walletWSF.features["standard:connect"].connect({ silent: silent_mode });
+  }
   function requestAccounts2(walletWSF, silent_mode = false) {
     return walletWSF.features["starknet:walletApi"].request({
       type: "wallet_requestAccounts",
@@ -17809,6 +17820,9 @@ ${indent}}` : "}";
   function supportedSpecs2(walletWSF) {
     return walletWSF.features["starknet:walletApi"].request({ type: "wallet_supportedSpecs" });
   }
+  function supportedWalletApi2(walletWSF) {
+    return walletWSF.features["starknet:walletApi"].request({ type: "wallet_supportedWalletApi" });
+  }
   function subscribeWalletEvent(walletWSF, callback) {
     return walletWSF.features["standard:events"].on("change", callback);
   }
@@ -17821,6 +17835,11 @@ ${indent}}` : "}";
      * To call before the instance is deleted.
      */
     unsubscribe;
+    /**
+     * Unsubscribe functions for the callbacks registered through {@link onChange}.
+     * Released by {@link unsubscribeChange}.
+     */
+    changeSubscriptions = [];
     constructor(options) {
       super({ ...options, signer: "" });
       this.walletProvider = options.walletProvider;
@@ -17839,11 +17858,24 @@ ${indent}}` : "}";
     /**
      * WALLET EVENTS
      */
+    /**
+     * Subscribe a callback to wallet account/network changes.
+     * @param {(change: StandardEventsChangeProperties) => void} callback called on each change.
+     * @returns {() => void} a function to unsubscribe this specific callback.
+     */
     onChange(callback) {
-      subscribeWalletEvent(this.walletProvider, callback);
+      const unsubscribe = subscribeWalletEvent(this.walletProvider, callback);
+      this.changeSubscriptions.push(unsubscribe);
+      return unsubscribe;
     }
+    /**
+     * Unsubscribe from all wallet events, including the callbacks registered through {@link onChange}.
+     * To call before the instance is deleted.
+     */
     unsubscribeChange() {
       this.unsubscribe();
+      this.changeSubscriptions.forEach((unsubscribe) => unsubscribe());
+      this.changeSubscriptions = [];
     }
     /**
      * WALLET SPECIFIC METHODS
@@ -17908,7 +17940,8 @@ ${indent}}` : "}";
       return signMessage2(this.walletProvider, typedData);
     }
     static async connect(provider, walletProvider, cairoVersion, paymaster, silentMode = false) {
-      const [accountAddress] = await requestAccounts2(walletProvider, silentMode);
+      const { accounts } = await standardConnect(walletProvider, silentMode);
+      const accountAddress = accounts[0]?.address;
       return new _WalletAccountV5({
         provider,
         walletProvider,
@@ -17923,6 +17956,154 @@ ${indent}}` : "}";
     // TODO: MISSING ESTIMATES
   };
 
+  // src/wallet/connectV6.ts
+  var connectV6_exports = {};
+  __export(connectV6_exports, {
+    addDeclareTransaction: () => addDeclareTransaction3,
+    addInvokeTransaction: () => addInvokeTransaction3,
+    addStarknetChain: () => addStarknetChain3,
+    deploymentData: () => deploymentData3,
+    getPermissions: () => getPermissions3,
+    requestAccounts: () => requestAccounts3,
+    requestChainId: () => requestChainId3,
+    signMessage: () => signMessage3,
+    standardConnect: () => standardConnect2,
+    strk20Balances: () => strk20Balances,
+    strk20InvokeTransaction: () => strk20InvokeTransaction,
+    strk20PrepareInvoke: () => strk20PrepareInvoke,
+    subscribeWalletEvent: () => subscribeWalletEvent2,
+    supportedSpecs: () => supportedSpecs3,
+    supportedWalletApi: () => supportedWalletApi3,
+    switchStarknetChain: () => switchStarknetChain3,
+    watchAsset: () => watchAsset3
+  });
+  function standardConnect2(walletWSF, silent_mode = false) {
+    return walletWSF.features["standard:connect"].connect({ silent: silent_mode });
+  }
+  function requestAccounts3(walletWSF, silent_mode = false) {
+    return walletWSF.features["starknet:walletApi"].request({
+      type: "wallet_requestAccounts",
+      params: { silent_mode }
+    });
+  }
+  function getPermissions3(walletWSF) {
+    return walletWSF.features["starknet:walletApi"].request({ type: "wallet_getPermissions" });
+  }
+  function watchAsset3(walletWSF, asset) {
+    return walletWSF.features["starknet:walletApi"].request({
+      type: "wallet_watchAsset",
+      params: asset
+    });
+  }
+  function addStarknetChain3(walletWSF, chain2) {
+    return walletWSF.features["starknet:walletApi"].request({
+      type: "wallet_addStarknetChain",
+      params: chain2
+    });
+  }
+  function switchStarknetChain3(walletWSF, chainId, silent_mode = false) {
+    return walletWSF.features["starknet:walletApi"].request({
+      type: "wallet_switchStarknetChain",
+      params: { chainId, silent_mode }
+    });
+  }
+  function requestChainId3(walletWSF) {
+    return walletWSF.features["starknet:walletApi"].request({ type: "wallet_requestChainId" });
+  }
+  function deploymentData3(walletWSF) {
+    return walletWSF.features["starknet:walletApi"].request({ type: "wallet_deploymentData" });
+  }
+  function addInvokeTransaction3(walletWSF, params) {
+    return walletWSF.features["starknet:walletApi"].request({
+      type: "wallet_addInvokeTransaction",
+      params
+    });
+  }
+  function addDeclareTransaction3(walletWSF, params) {
+    return walletWSF.features["starknet:walletApi"].request({
+      type: "wallet_addDeclareTransaction",
+      params
+    });
+  }
+  function signMessage3(walletWSF, typedData) {
+    return walletWSF.features["starknet:walletApi"].request({
+      type: "wallet_signTypedData",
+      params: typedData
+    });
+  }
+  function supportedSpecs3(walletWSF) {
+    return walletWSF.features["starknet:walletApi"].request({ type: "wallet_supportedSpecs" });
+  }
+  function supportedWalletApi3(walletWSF) {
+    return walletWSF.features["starknet:walletApi"].request({ type: "wallet_supportedWalletApi" });
+  }
+  function subscribeWalletEvent2(walletWSF, callback) {
+    return walletWSF.features["standard:events"].on("change", callback);
+  }
+  function strk20Balances(walletWSF, tokens) {
+    return walletWSF.features["starknet:walletApi"].request({
+      type: "wallet_strk20Balances",
+      params: { tokens }
+    });
+  }
+  function strk20PrepareInvoke(walletWSF, actions, simulate) {
+    return walletWSF.features["starknet:walletApi"].request({
+      type: "wallet_strk20PrepareInvoke",
+      params: { actions, simulate }
+    });
+  }
+  function strk20InvokeTransaction(walletWSF, actions) {
+    return walletWSF.features["starknet:walletApi"].request({
+      type: "wallet_strk20InvokeTransaction",
+      params: { actions }
+    });
+  }
+
+  // src/wallet/accountV6.ts
+  var WalletAccountV6 = class _WalletAccountV6 extends WalletAccountV5 {
+    constructor(options) {
+      super({ ...options, walletProvider: options.walletProvider });
+      this.walletProvider = options.walletProvider;
+    }
+    get v6Provider() {
+      return this.walletProvider;
+    }
+    switchStarknetChain(chainId, silent_mode = false) {
+      return switchStarknetChain3(this.v6Provider, chainId, silent_mode);
+    }
+    executeWithProof(calls, proof) {
+      const txCalls = [].concat(calls).map((it) => ({
+        contract_address: it.contractAddress,
+        entry_point: it.entrypoint,
+        calldata: it.calldata
+      }));
+      return addInvokeTransaction3(this.v6Provider, { calls: txCalls, proof });
+    }
+    strk20Balances(tokens) {
+      return strk20Balances(this.v6Provider, tokens);
+    }
+    strk20PrepareInvoke(actions, simulate) {
+      return strk20PrepareInvoke(this.v6Provider, actions, simulate);
+    }
+    strk20InvokeTransaction(actions) {
+      return strk20InvokeTransaction(this.v6Provider, actions);
+    }
+    static async connect(provider, walletProvider, cairoVersion, paymaster, silentMode = false) {
+      const { accounts } = await standardConnect2(walletProvider, silentMode);
+      const accountAddress = accounts[0]?.address;
+      return new _WalletAccountV6({
+        provider,
+        walletProvider,
+        address: accountAddress,
+        cairoVersion,
+        paymaster
+      });
+    }
+    static async connectSilent(provider, walletProvider, cairoVersion, paymaster) {
+      return _WalletAccountV6.connect(provider, walletProvider, cairoVersion, paymaster, true);
+    }
+  };
+
   // src/utils/events/index.ts
   var events_exports = {};
   __export(events_exports, {