starknet 6.4.2 → 6.6.0

package/dist/index.global.js

@@ -12709,13 +12709,19 @@ var starknet = (() => {
     TypedDataRevision: () => TypedDataRevision,
     Uint: () => Uint,
     ValidateType: () => ValidateType,
+    WalletAccount: () => WalletAccount,
     addAddressPadding: () => addAddressPadding,
+    addDeclareTransaction: () => addDeclareTransaction,
+    addDeployAccountTransaction: () => addDeployAccountTransaction,
+    addInvokeTransaction: () => addInvokeTransaction,
+    addStarknetChain: () => addStarknetChain,
     buildUrl: () => buildUrl,
     byteArray: () => byteArray_exports,
     cairo: () => cairo_exports,
     constants: () => constants_exports,
     contractClassResponseToLegacyCompiledContract: () => contractClassResponseToLegacyCompiledContract,
     defaultProvider: () => defaultProvider,
+    deploymentData: () => deploymentData,
     ec: () => ec_exports,
     encode: () => encode_exports,
     eth: () => eth_exports,
@@ -12725,6 +12731,7 @@ var starknet = (() => {
     fixStack: () => fixStack,
     getCalldata: () => getCalldata,
     getChecksumAddress: () => getChecksumAddress,
+    getPermissions: () => getPermissions,
     hash: () => hash_exports,
     isSierra: () => isSierra,
     isUrl: () => isUrl,
@@ -12732,13 +12739,20 @@ var starknet = (() => {
     merkle: () => merkle_exports,
     num: () => num_exports,
     number: () => number2,
+    onAccountChange: () => onAccountChange,
+    onNetworkChanged: () => onNetworkChanged,
     parseUDCEvent: () => parseUDCEvent,
     provider: () => provider_exports,
+    requestAccounts: () => requestAccounts,
+    requestChainId: () => requestChainId,
     selector: () => selector_exports,
     shortString: () => shortString_exports,
+    signMessage: () => signMessage,
     splitArgsAndOptions: () => splitArgsAndOptions,
     stark: () => stark_exports,
     starknetId: () => starknetId_exports,
+    supportedSpecs: () => supportedSpecs,
+    switchStarknetChain: () => switchStarknetChain,
     transaction: () => transaction_exports,
     typedData: () => typedData_exports,
     types: () => types_exports,
@@ -12746,7 +12760,8 @@ var starknet = (() => {
     v2hash: () => v2_exports,
     v3hash: () => v3_exports,
     validateAndParseAddress: () => validateAndParseAddress,
-    validateChecksumAddress: () => validateChecksumAddress
+    validateChecksumAddress: () => validateChecksumAddress,
+    watchAsset: () => watchAsset
   });
 
   // src/constants.ts
@@ -12766,7 +12781,8 @@ var starknet = (() => {
     TRANSACTION_VERSION: () => ETransactionVersion4,
     TransactionHashPrefix: () => TransactionHashPrefix,
     UDC: () => UDC,
-    ZERO: () => ZERO
+    ZERO: () => ZERO,
+    feeMarginPercentage: () => feeMarginPercentage
   });
 
   // src/types/api/index.ts
@@ -13251,11 +13267,17 @@ var starknet = (() => {
     TransactionHashPrefix2["L1_HANDLER"] = "0x6c315f68616e646c6572";
     return TransactionHashPrefix2;
   })(TransactionHashPrefix || {});
+  var feeMarginPercentage = /* @__PURE__ */ ((feeMarginPercentage2) => {
+    feeMarginPercentage2[feeMarginPercentage2["L1_BOUND_MAX_AMOUNT"] = 50] = "L1_BOUND_MAX_AMOUNT";
+    feeMarginPercentage2[feeMarginPercentage2["L1_BOUND_MAX_PRICE_PER_UNIT"] = 50] = "L1_BOUND_MAX_PRICE_PER_UNIT";
+    feeMarginPercentage2[feeMarginPercentage2["MAX_FEE"] = 50] = "MAX_FEE";
+    return feeMarginPercentage2;
+  })(feeMarginPercentage || {});
   var UDC = {
     ADDRESS: "0x041a78e741e5af2fec34b695679bc6891742439f7afb8484ecd7766661ad02bf",
     ENTRYPOINT: "deployContract"
   };
-  var RPC_DEFAULT_VERSION = "v0_6";
+  var RPC_DEFAULT_VERSION = "v0_7";
   var RPC_NODES = {
     SN_GOERLI: [
       `https://starknet-testnet.public.blastapi.io/rpc/${RPC_DEFAULT_VERSION}`,
@@ -22997,10 +23019,10 @@ var starknet = (() => {
   function signatureToHexArray(sig) {
     return bigNumberishArrayToHexadecimalStringArray(formatSignature(sig));
   }
-  function estimatedFeeToMaxFee(estimatedFee, overhead = 0.5) {
-    return addPercent(estimatedFee, overhead * 100);
+  function estimatedFeeToMaxFee(estimatedFee, overhead = 50 /* MAX_FEE */) {
+    return addPercent(estimatedFee, overhead);
   }
-  function estimateFeeToBounds(estimate, amountOverhead = 10, priceOverhead = 50) {
+  function estimateFeeToBounds(estimate, amountOverhead = 50 /* L1_BOUND_MAX_AMOUNT */, priceOverhead = 50 /* L1_BOUND_MAX_PRICE_PER_UNIT */) {
     if (typeof estimate === "bigint") {
       return {
         l2_gas: { max_amount: "0x0", max_price_per_unit: "0x0" },
@@ -23010,7 +23032,7 @@ var starknet = (() => {
     if (typeof estimate.gas_consumed === "undefined" || typeof estimate.gas_price === "undefined") {
       throw Error("estimateFeeToBounds: estimate is undefined");
     }
-    const maxUnits = toHex(addPercent(estimate.gas_consumed, amountOverhead));
+    const maxUnits = estimate.data_gas_consumed !== void 0 && estimate.data_gas_price !== void 0 ? toHex(addPercent(BigInt(estimate.overall_fee) / BigInt(estimate.gas_price), amountOverhead)) : toHex(addPercent(estimate.gas_consumed, amountOverhead));
     const maxUnitPrice = toHex(addPercent(estimate.gas_price, priceOverhead));
     return {
       l2_gas: { max_amount: "0x0", max_price_per_unit: "0x0" },
@@ -23395,6 +23417,7 @@ var starknet = (() => {
   // src/utils/transaction.ts
   var transaction_exports = {};
   __export(transaction_exports, {
+    buildUDCCall: () => buildUDCCall,
     fromCallsToExecuteCalldata: () => fromCallsToExecuteCalldata,
     fromCallsToExecuteCalldataWithNonce: () => fromCallsToExecuteCalldataWithNonce,
     fromCallsToExecuteCalldata_cairo1: () => fromCallsToExecuteCalldata_cairo1,
@@ -23452,6 +23475,41 @@ var starknet = (() => {
     }
     return fromCallsToExecuteCalldata(calls);
   };
+  function buildUDCCall(payload, address) {
+    const params = [].concat(payload).map((it) => {
+      const {
+        classHash,
+        salt,
+        unique: unique2 = true,
+        constructorCalldata = []
+      } = it;
+      const compiledConstructorCallData = CallData.compile(constructorCalldata);
+      const deploySalt = salt ?? randomAddress();
+      return {
+        call: {
+          contractAddress: UDC.ADDRESS,
+          entrypoint: UDC.ENTRYPOINT,
+          calldata: [
+            classHash,
+            deploySalt,
+            toCairoBool(unique2),
+            compiledConstructorCallData.length,
+            ...compiledConstructorCallData
+          ]
+        },
+        address: calculateContractAddressFromHash(
+          unique2 ? esm_exports.pedersen(address, deploySalt) : deploySalt,
+          classHash,
+          compiledConstructorCallData,
+          unique2 ? UDC.ADDRESS : 0
+        )
+      };
+    });
+    return {
+      calls: params.map((it) => it.call),
+      addresses: params.map((it) => it.address)
+    };
+  }
   function getVersionsByType(versionType) {
     return versionType === "fee" ? {
       v1: "0x100000000000000000000000000000001" /* F1 */,
@@ -23493,6 +23551,9 @@ var starknet = (() => {
       this.waitMode = waitMode || false;
       this.requestId = 0;
     }
+    setChainId(chainId) {
+      this.chainId = chainId;
+    }
     fetch(method, params, id = 0) {
       const rpcRequestBody = {
         id,
@@ -24023,6 +24084,9 @@ var starknet = (() => {
       this.waitMode = waitMode || false;
       this.requestId = 0;
     }
+    setChainId(chainId) {
+      this.chainId = chainId;
+    }
     fetch(method, params, id = 0) {
       const rpcRequestBody = {
         id,
@@ -24523,6 +24587,20 @@ var starknet = (() => {
 
   // src/utils/responseParser/rpc.ts
   var RPCResponseParser = class {
+    margin;
+    constructor(margin) {
+      this.margin = margin;
+    }
+    estimatedFeeToMaxFee(estimatedFee) {
+      return estimatedFeeToMaxFee(estimatedFee, this.margin?.maxFee);
+    }
+    estimateFeeToBounds(estimate) {
+      return estimateFeeToBounds(
+        estimate,
+        this.margin?.l1BoundMaxAmount,
+        this.margin?.l1BoundMaxPricePerUnit
+      );
+    }
     parseGetBlockResponse(res) {
       return { status: "PENDING", ...res };
     }
@@ -24545,8 +24623,8 @@ var starknet = (() => {
         gas_consumed: toBigInt(val.gas_consumed),
         gas_price: toBigInt(val.gas_price),
         unit: val.unit,
-        suggestedMaxFee: estimatedFeeToMaxFee(val.overall_fee),
-        resourceBounds: estimateFeeToBounds(val)
+        suggestedMaxFee: this.estimatedFeeToMaxFee(val.overall_fee),
+        resourceBounds: this.estimateFeeToBounds(val)
       };
     }
     parseFeeEstimateBulkResponse(res) {
@@ -24555,16 +24633,16 @@ var starknet = (() => {
         gas_consumed: toBigInt(val.gas_consumed),
         gas_price: toBigInt(val.gas_price),
         unit: val.unit,
-        suggestedMaxFee: estimatedFeeToMaxFee(val.overall_fee),
-        resourceBounds: estimateFeeToBounds(val)
+        suggestedMaxFee: this.estimatedFeeToMaxFee(val.overall_fee),
+        resourceBounds: this.estimateFeeToBounds(val)
       }));
     }
     parseSimulateTransactionResponse(res) {
       return res.map((it) => {
         return {
           ...it,
-          suggestedMaxFee: estimatedFeeToMaxFee(BigInt(it.fee_estimation.overall_fee)),
-          resourceBounds: estimateFeeToBounds(it.fee_estimation)
+          suggestedMaxFee: this.estimatedFeeToMaxFee(it.fee_estimation.overall_fee),
+          resourceBounds: this.estimateFeeToBounds(it.fee_estimation)
         };
       });
     }
@@ -24578,13 +24656,15 @@ var starknet = (() => {
 
   // src/provider/rpc.ts
   var RpcProvider = class {
-    responseParser = new RPCResponseParser();
+    responseParser;
     channel;
     constructor(optionsOrProvider) {
       if (optionsOrProvider && "channel" in optionsOrProvider) {
         this.channel = optionsOrProvider.channel;
+        this.responseParser = optionsOrProvider.responseParser;
       } else {
         this.channel = new RpcChannel2({ ...optionsOrProvider, waitMode: false });
+        this.responseParser = new RPCResponseParser(optionsOrProvider?.feeMarginPercentage);
       }
     }
     fetch(method, params, id = 0) {
@@ -24677,7 +24757,7 @@ var starknet = (() => {
      * - skipFeeCharge (default true)<br/>
      */
     async getSimulateTransaction(invocations, options) {
-      return this.channel.simulateTransaction(invocations, options).then(this.responseParser.parseSimulateTransactionResponse);
+      return this.channel.simulateTransaction(invocations, options).then((r) => this.responseParser.parseSimulateTransactionResponse(r));
     }
     async waitForTransaction(txHash, options) {
       return this.channel.waitForTransaction(txHash, options);
@@ -24734,7 +24814,7 @@ var starknet = (() => {
           }
         ],
         { blockIdentifier, skipValidate }
-      ).then(this.responseParser.parseFeeEstimateResponse);
+      ).then((r) => this.responseParser.parseFeeEstimateResponse(r));
     }
     async getDeclareEstimateFee(invocation, details, blockIdentifier, skipValidate) {
       return this.channel.getEstimateFee(
@@ -24746,7 +24826,7 @@ var starknet = (() => {
           }
         ],
         { blockIdentifier, skipValidate }
-      ).then(this.responseParser.parseFeeEstimateResponse);
+      ).then((r) => this.responseParser.parseFeeEstimateResponse(r));
     }
     async getDeployAccountEstimateFee(invocation, details, blockIdentifier, skipValidate) {
       return this.channel.getEstimateFee(
@@ -24758,10 +24838,10 @@ var starknet = (() => {
           }
         ],
         { blockIdentifier, skipValidate }
-      ).then(this.responseParser.parseFeeEstimateResponse);
+      ).then((r) => this.responseParser.parseFeeEstimateResponse(r));
     }
     async getEstimateFeeBulk(invocations, options) {
-      return this.channel.getEstimateFee(invocations, options).then(this.responseParser.parseFeeEstimateBulkResponse);
+      return this.channel.getEstimateFee(invocations, options).then((r) => this.responseParser.parseFeeEstimateBulkResponse(r));
     }
     async invokeFunction(functionInvocation, details) {
       return this.channel.invoke(functionInvocation, details);
@@ -26399,37 +26479,7 @@ var starknet = (() => {
       return this.declareContract(declareContractTransaction, declareDetails);
     }
     async deploy(payload, details = {}) {
-      const params = [].concat(payload).map((it) => {
-        const {
-          classHash,
-          salt,
-          unique: unique2 = true,
-          constructorCalldata = []
-        } = it;
-        const compiledConstructorCallData = CallData.compile(constructorCalldata);
-        const deploySalt = salt ?? randomAddress();
-        return {
-          call: {
-            contractAddress: UDC.ADDRESS,
-            entrypoint: UDC.ENTRYPOINT,
-            calldata: [
-              classHash,
-              deploySalt,
-              toCairoBool(unique2),
-              compiledConstructorCallData.length,
-              ...compiledConstructorCallData
-            ]
-          },
-          address: calculateContractAddressFromHash(
-            unique2 ? esm_exports.pedersen(this.address, deploySalt) : deploySalt,
-            classHash,
-            compiledConstructorCallData,
-            unique2 ? UDC.ADDRESS : 0
-          )
-        };
-      });
-      const calls = params.map((it) => it.call);
-      const addresses = params.map((it) => it.address);
+      const { calls, addresses } = buildUDCCall(payload, this.address);
       const invokeResponse = await this.execute(calls, void 0, details);
       return {
         ...invokeResponse,
@@ -26744,6 +26794,186 @@ var starknet = (() => {
   var AccountInterface = class extends ProviderInterface {
   };
 
+  // src/wallet/connect.ts
+  function requestAccounts(swo, silentMode = false) {
+    return swo.request({
+      type: "wallet_requestAccounts",
+      params: {
+        silentMode
+      }
+    });
+  }
+  function getPermissions(swo) {
+    return swo.request({ type: "wallet_getPermissions" });
+  }
+  function watchAsset(swo, asset) {
+    return swo.request({
+      type: "wallet_watchAsset",
+      params: asset
+    });
+  }
+  function addStarknetChain(swo, chain2) {
+    return swo.request({
+      type: "wallet_addStarknetChain",
+      params: chain2
+    });
+  }
+  function switchStarknetChain(swo, chainId) {
+    return swo.request({
+      type: "wallet_switchStarknetChain",
+      params: {
+        chainId
+      }
+    });
+  }
+  function requestChainId(swo) {
+    return swo.request({ type: "wallet_requestChainId" });
+  }
+  function deploymentData(swo) {
+    return swo.request({ type: "wallet_deploymentData" });
+  }
+  function addInvokeTransaction(swo, params) {
+    return swo.request({
+      type: "starknet_addInvokeTransaction",
+      params
+    });
+  }
+  function addDeclareTransaction(swo, params) {
+    return swo.request({
+      type: "starknet_addDeclareTransaction",
+      params
+    });
+  }
+  function addDeployAccountTransaction(swo, params) {
+    return swo.request({
+      type: "starknet_addDeployAccountTransaction",
+      params
+    });
+  }
+  function signMessage(swo, typedData) {
+    return swo.request({
+      type: "starknet_signTypedData",
+      params: typedData
+    });
+  }
+  function supportedSpecs(swo) {
+    return swo.request({ type: "starknet_supportedSpecs" });
+  }
+  function onAccountChange(swo, callback) {
+    swo.on("accountsChanged", callback);
+  }
+  function onNetworkChanged(swo, callback) {
+    swo.on("networkChanged", callback);
+  }
+
+  // src/wallet/account.ts
+  var WalletAccount = class extends Account {
+    address = "";
+    walletProvider;
+    constructor(providerOrOptions, walletProvider, cairoVersion) {
+      super(providerOrOptions, "", "", cairoVersion);
+      this.walletProvider = walletProvider;
+      this.walletProvider.on("accountsChanged", (res) => {
+        if (!res)
+          return;
+        this.address = res[0].toLowerCase();
+      });
+      this.walletProvider.on("networkChanged", (res) => {
+        if (!res)
+          return;
+        this.channel.setChainId(res);
+      });
+      walletProvider.request({
+        type: "wallet_requestAccounts",
+        params: {
+          silentMode: false
+        }
+      }).then((res) => {
+        this.address = res[0].toLowerCase();
+      });
+    }
+    /**
+     * WALLET EVENTS
+     */
+    onAccountChange(callback) {
+      onAccountChange(this.walletProvider, callback);
+    }
+    onNetworkChanged(callback) {
+      onNetworkChanged(this.walletProvider, callback);
+    }
+    /**
+     * WALLET SPECIFIC METHODS
+     */
+    requestAccounts(silentMode = false) {
+      return requestAccounts(this.walletProvider, silentMode);
+    }
+    getPermissions() {
+      return getPermissions(this.walletProvider);
+    }
+    switchStarknetChain(chainId) {
+      return switchStarknetChain(this.walletProvider, chainId);
+    }
+    watchAsset(asset) {
+      return watchAsset(this.walletProvider, asset);
+    }
+    addStarknetChain(chain2) {
+      return addStarknetChain(this.walletProvider, chain2);
+    }
+    /**
+     * ACCOUNT METHODS
+     */
+    execute(calls) {
+      const txCalls = [].concat(calls).map((it) => {
+        const { contractAddress, entrypoint, calldata } = it;
+        return {
+          contract_address: contractAddress,
+          entrypoint,
+          calldata
+        };
+      });
+      const params = {
+        calls: txCalls
+      };
+      return addInvokeTransaction(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 addDeclareTransaction(this.walletProvider, params);
+    }
+    async deploy(payload) {
+      const { calls, addresses } = buildUDCCall(payload, this.address);
+      const invokeResponse = await this.execute(calls);
+      return {
+        ...invokeResponse,
+        contract_address: addresses
+      };
+    }
+    deployAccount(payload) {
+      const params = {
+        contract_address_salt: payload.addressSalt?.toString() || "0",
+        constructor_calldata: payload.constructorCalldata ? CallData.compile(payload.constructorCalldata) : [],
+        class_hash: payload.classHash
+      };
+      return addDeployAccountTransaction(this.walletProvider, params);
+    }
+    signMessage(typedData) {
+      return signMessage(this.walletProvider, typedData);
+    }
+    // TODO: MISSING ESTIMATES
+  };
+
   // src/utils/events/index.ts
   var events_exports = {};
   __export(events_exports, {