starknet 9.0.0 → 9.1.0

package/dist/index.js

@@ -123,6 +123,7 @@ __export(index_exports, {
   Uint: () => Uint,
   ValidateType: () => ValidateType,
   WalletAccount: () => WalletAccount,
+  WalletAccountV5: () => WalletAccountV5,
   WebSocketChannel: () => WebSocketChannel,
   WebSocketNotConnectedError: () => WebSocketNotConnectedError,
   addAddressPadding: () => addAddressPadding,
@@ -188,7 +189,8 @@ __export(index_exports, {
   validateAndParseAddress: () => validateAndParseAddress,
   validateChecksumAddress: () => validateChecksumAddress,
   verifyMessageInStarknet: () => verifyMessageInStarknet,
-  wallet: () => connect_exports
+  wallet: () => connect_exports,
+  walletV5: () => connectV5_exports
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -12126,6 +12128,188 @@ var WalletAccount = class _WalletAccount extends Account {
   // TODO: MISSING ESTIMATES
 };
 
+// src/wallet/connectV5.ts
+var connectV5_exports = {};
+__export(connectV5_exports, {
+  addDeclareTransaction: () => addDeclareTransaction2,
+  addInvokeTransaction: () => addInvokeTransaction2,
+  addStarknetChain: () => addStarknetChain2,
+  deploymentData: () => deploymentData2,
+  getPermissions: () => getPermissions2,
+  requestAccounts: () => requestAccounts2,
+  requestChainId: () => requestChainId2,
+  signMessage: () => signMessage2,
+  subscribeWalletEvent: () => subscribeWalletEvent,
+  supportedSpecs: () => supportedSpecs2,
+  switchStarknetChain: () => switchStarknetChain2,
+  watchAsset: () => watchAsset2
+});
+function requestAccounts2(walletWSF, silent_mode = false) {
+  return walletWSF.features["starknet:walletApi"].request({
+    type: "wallet_requestAccounts",
+    params: { silent_mode }
+  });
+}
+function getPermissions2(walletWSF) {
+  return walletWSF.features["starknet:walletApi"].request({ type: "wallet_getPermissions" });
+}
+function watchAsset2(walletWSF, asset) {
+  return walletWSF.features["starknet:walletApi"].request({
+    type: "wallet_watchAsset",
+    params: asset
+  });
+}
+function addStarknetChain2(walletWSF, chain) {
+  return walletWSF.features["starknet:walletApi"].request({
+    type: "wallet_addStarknetChain",
+    params: chain
+  });
+}
+function switchStarknetChain2(walletWSF, chainId) {
+  return walletWSF.features["starknet:walletApi"].request({
+    type: "wallet_switchStarknetChain",
+    params: { chainId }
+  });
+}
+function requestChainId2(walletWSF) {
+  return walletWSF.features["starknet:walletApi"].request({ type: "wallet_requestChainId" });
+}
+function deploymentData2(walletWSF) {
+  return walletWSF.features["starknet:walletApi"].request({ type: "wallet_deploymentData" });
+}
+function addInvokeTransaction2(walletWSF, params) {
+  return walletWSF.features["starknet:walletApi"].request({
+    type: "wallet_addInvokeTransaction",
+    params
+  });
+}
+function addDeclareTransaction2(walletWSF, params) {
+  return walletWSF.features["starknet:walletApi"].request({
+    type: "wallet_addDeclareTransaction",
+    params
+  });
+}
+function signMessage2(walletWSF, typedData) {
+  return walletWSF.features["starknet:walletApi"].request({
+    type: "wallet_signTypedData",
+    params: typedData
+  });
+}
+function supportedSpecs2(walletWSF) {
+  return walletWSF.features["starknet:walletApi"].request({ type: "wallet_supportedSpecs" });
+}
+function subscribeWalletEvent(walletWSF, callback) {
+  return walletWSF.features["standard:events"].on("change", callback);
+}
+
+// src/wallet/accountV5.ts
+var WalletAccountV5 = class _WalletAccountV5 extends Account {
+  walletProvider;
+  /**
+   * The function to use to unsubscribe from the wallet events.
+   * To call before the instance is deleted.
+   */
+  unsubscribe;
+  constructor(options) {
+    super({ ...options, signer: "" });
+    this.walletProvider = options.walletProvider;
+    this.unsubscribe = this.walletProvider.features["standard:events"].on(
+      "change",
+      (change) => {
+        if (!change.accounts?.length) return;
+        if (change.accounts[0].address) this.address = change.accounts[0].address;
+        if (change.accounts[0].chains)
+          this.channel.setChainId(change.accounts[0].chains[0].slice(9));
+      }
+    );
+  }
+  /**
+   * WALLET EVENTS
+   */
+  onChange(callback) {
+    subscribeWalletEvent(this.walletProvider, callback);
+  }
+  unsubscribeChange() {
+    this.unsubscribe();
+  }
+  /**
+   * WALLET SPECIFIC METHODS
+   */
+  requestAccounts(silentMode = false) {
+    return requestAccounts2(this.walletProvider, silentMode);
+  }
+  getPermissions() {
+    return getPermissions2(this.walletProvider);
+  }
+  switchStarknetChain(chainId) {
+    return switchStarknetChain2(this.walletProvider, chainId);
+  }
+  watchAsset(asset) {
+    return watchAsset2(this.walletProvider, asset);
+  }
+  addStarknetChain(chain) {
+    return addStarknetChain2(this.walletProvider, chain);
+  }
+  /**
+   * ACCOUNT METHODS
+   */
+  execute(calls) {
+    const txCalls = [].concat(calls).map((it) => {
+      const { contractAddress, entrypoint, calldata } = it;
+      return {
+        contract_address: contractAddress,
+        entry_point: entrypoint,
+        calldata
+      };
+    });
+    const params = {
+      calls: txCalls
+    };
+    return addInvokeTransaction2(this.walletProvider, params);
+  }
+  declare(payload) {
+    const declareContractPayload = extractContractHashes(payload);
+    const pContract = payload.contract;
+    const cairo1Contract = {
+      ...pContract,
+      abi: stringify2(pContract.abi)
+    };
+    if (!declareContractPayload.compiledClassHash) {
+      throw Error("compiledClassHash is required");
+    }
+    const params = {
+      compiled_class_hash: declareContractPayload.compiledClassHash,
+      contract_class: cairo1Contract
+    };
+    return addDeclareTransaction2(this.walletProvider, params);
+  }
+  async deploy(payload) {
+    const { calls, addresses } = defaultDeployer.buildDeployerCall(payload, this.address);
+    const invokeResponse = await this.execute(calls);
+    return {
+      ...invokeResponse,
+      contract_address: addresses
+    };
+  }
+  signMessage(typedData) {
+    return signMessage2(this.walletProvider, typedData);
+  }
+  static async connect(provider, walletProvider, cairoVersion, paymaster, silentMode = false) {
+    const [accountAddress] = await requestAccounts2(walletProvider, silentMode);
+    return new _WalletAccountV5({
+      provider,
+      walletProvider,
+      address: accountAddress,
+      cairoVersion,
+      paymaster
+    });
+  }
+  static async connectSilent(provider, walletProvider, cairoVersion, paymaster) {
+    return _WalletAccountV5.connect(provider, walletProvider, cairoVersion, paymaster, true);
+  }
+  // TODO: MISSING ESTIMATES
+};
+
 // src/utils/events/index.ts
 var events_exports = {};
 __export(events_exports, {
@@ -12814,6 +12998,7 @@ function units(amount, simbol = "fri") {
   Uint,
   ValidateType,
   WalletAccount,
+  WalletAccountV5,
   WebSocketChannel,
   WebSocketNotConnectedError,
   addAddressPadding,
@@ -12879,6 +13064,7 @@ function units(amount, simbol = "fri") {
   validateAndParseAddress,
   validateChecksumAddress,
   verifyMessageInStarknet,
-  wallet
+  wallet,
+  walletV5
 });
 //# sourceMappingURL=index.js.map