starknet 7.3.0 → 7.5.0

package/dist/index.global.js

@@ -235,7 +235,7 @@ var starknet = (() => {
   // src/types/api/jsonrpc/index.ts
   var jsonrpc_exports = {};
 
-  // node_modules/starknet-types-07/dist/esm/index.js
+  // node_modules/@starknet-io/starknet-types-07/dist/esm/index.js
   var esm_exports = {};
   __export(esm_exports, {
     API: () => api_exports,
@@ -257,7 +257,7 @@ var starknet = (() => {
     WALLET_API: () => wallet_api_exports
   });
 
-  // node_modules/starknet-types-07/dist/esm/api/index.js
+  // node_modules/@starknet-io/starknet-types-07/dist/esm/api/index.js
   var api_exports = {};
   __export(api_exports, {
     EBlockTag: () => EBlockTag,
@@ -275,13 +275,13 @@ var starknet = (() => {
     SPEC: () => components_exports
   });
 
-  // node_modules/starknet-types-07/dist/esm/api/errors.js
+  // node_modules/@starknet-io/starknet-types-07/dist/esm/api/errors.js
   var errors_exports = {};
 
-  // node_modules/starknet-types-07/dist/esm/api/components.js
+  // node_modules/@starknet-io/starknet-types-07/dist/esm/api/components.js
   var components_exports = {};
 
-  // node_modules/starknet-types-07/dist/esm/api/nonspec.js
+  // node_modules/@starknet-io/starknet-types-07/dist/esm/api/nonspec.js
   var ETransactionType = {
     DECLARE: "DECLARE",
     DEPLOY: "DEPLOY",
@@ -342,25 +342,25 @@ var starknet = (() => {
     F3: "0x100000000000000000000000000000003"
   };
 
-  // node_modules/starknet-types-07/dist/esm/wallet-api/index.js
+  // node_modules/@starknet-io/starknet-types-07/dist/esm/wallet-api/index.js
   var wallet_api_exports = {};
   __export(wallet_api_exports, {
     Permission: () => Permission,
     TypedDataRevision: () => TypedDataRevision
   });
 
-  // node_modules/starknet-types-07/dist/esm/wallet-api/constants.js
+  // node_modules/@starknet-io/starknet-types-07/dist/esm/wallet-api/constants.js
   var Permission = {
     ACCOUNTS: "accounts"
   };
 
-  // node_modules/starknet-types-07/dist/esm/wallet-api/typedData.js
+  // node_modules/@starknet-io/starknet-types-07/dist/esm/wallet-api/typedData.js
   var TypedDataRevision = {
     ACTIVE: "1",
     LEGACY: "0"
   };
 
-  // node_modules/starknet-types-08/dist/esm/index.js
+  // node_modules/@starknet-io/starknet-types-08/dist/esm/index.js
   var esm_exports2 = {};
   __export(esm_exports2, {
     ABI_TYPE_CONSTRUCTOR: () => ABI_TYPE_CONSTRUCTOR,
@@ -406,7 +406,7 @@ var starknet = (() => {
     WALLET_API: () => wallet_api_exports2
   });
 
-  // node_modules/starknet-types-08/dist/esm/api/index.js
+  // node_modules/@starknet-io/starknet-types-08/dist/esm/api/index.js
   var api_exports2 = {};
   __export(api_exports2, {
     ABI_TYPE_CONSTRUCTOR: () => ABI_TYPE_CONSTRUCTOR,
@@ -447,10 +447,10 @@ var starknet = (() => {
     TXN_TYPE_L1_HANDLER: () => TXN_TYPE_L1_HANDLER
   });
 
-  // node_modules/starknet-types-08/dist/esm/api/contract.js
+  // node_modules/@starknet-io/starknet-types-08/dist/esm/api/contract.js
   var contract_exports = {};
 
-  // node_modules/starknet-types-08/dist/esm/api/constants.js
+  // node_modules/@starknet-io/starknet-types-08/dist/esm/api/constants.js
   var STATUS_ACCEPTED_ON_L2 = "ACCEPTED_ON_L2";
   var STATUS_ACCEPTED_ON_L1 = "ACCEPTED_ON_L1";
   var STATUS_SUCCEEDED = "SUCCEEDED";
@@ -560,25 +560,25 @@ var starknet = (() => {
     F3: ETransactionVersion4.F3
   };
 
-  // node_modules/starknet-types-08/dist/esm/wallet-api/index.js
+  // node_modules/@starknet-io/starknet-types-08/dist/esm/wallet-api/index.js
   var wallet_api_exports2 = {};
   __export(wallet_api_exports2, {
     Permission: () => Permission2,
     TypedDataRevision: () => TypedDataRevision2
   });
 
-  // node_modules/starknet-types-08/dist/esm/wallet-api/constants.js
+  // node_modules/@starknet-io/starknet-types-08/dist/esm/wallet-api/constants.js
   var Permission2 = {
     ACCOUNTS: "accounts"
   };
 
-  // node_modules/starknet-types-08/dist/esm/wallet-api/typedData.js
+  // node_modules/@starknet-io/starknet-types-08/dist/esm/wallet-api/typedData.js
   var TypedDataRevision2 = {
     ACTIVE: "1",
     LEGACY: "0"
   };
 
-  // node_modules/starknet-types-08/dist/esm/snip-29/index.js
+  // node_modules/@starknet-io/starknet-types-08/dist/esm/snip-29/index.js
   var snip_29_exports = {};
 
   // src/utils/encode.ts
@@ -920,14 +920,8 @@ var starknet = (() => {
     websocket: void 0
   };
   var RPC_DEFAULT_NODES = {
-    SN_MAIN: [
-      `https://starknet-mainnet.public.blastapi.io/rpc/`,
-      `https://free-rpc.nethermind.io/mainnet-juno/`
-    ],
-    SN_SEPOLIA: [
-      `https://starknet-sepolia.public.blastapi.io/rpc/`,
-      `https://free-rpc.nethermind.io/sepolia-juno/`
-    ]
+    SN_MAIN: [`https://starknet-mainnet.public.blastapi.io/rpc/`],
+    SN_SEPOLIA: [`https://starknet-sepolia.public.blastapi.io/rpc/`]
   };
   var PAYMASTER_RPC_NODES = {
     SN_MAIN: [`https://starknet.paymaster.avnu.fi`],
@@ -938,7 +932,8 @@ var starknet = (() => {
     legacyTxRPC08Message: "RPC 0.8 do not support legacy transactions",
     SWOldV3: "RPC 0.7 V3 tx (improper resource bounds) not supported in RPC 0.8",
     channelVersionMismatch: "Channel specification version is not compatible with the connected node Specification Version",
-    unsupportedSpecVersion: "The connected node specification version is not supported by this library"
+    unsupportedSpecVersion: "The connected node specification version is not supported by this library",
+    maxFeeInV3: "maxFee is not supported in V3 transactions, use resourceBounds instead"
   };
 
   // src/global/config.ts
@@ -1928,6 +1923,15 @@ ${indent}}` : "}";
       throw new Error(message || "Assertion failure");
     }
   }
+  function assertX(condition, method) {
+    if (!condition) {
+      if (method.length === 0) {
+        method();
+      } else {
+        throw new Error("AssertionX failure: message function should not require arguments");
+      }
+    }
+  }
 
   // src/utils/num.ts
   var num_exports = {};
@@ -2696,6 +2700,7 @@ ${indent}}` : "}";
   // src/utils/hash/selector.ts
   var selector_exports = {};
   __export(selector_exports, {
+    getL1MessageHash: () => getL1MessageHash,
     getL2MessageHash: () => getL2MessageHash,
     getSelector: () => getSelector,
     getSelectorFromName: () => getSelectorFromName,
@@ -4928,6 +4933,9 @@ ${indent}}` : "}";
       ...l2Calldata
     ]);
   }
+  function getL1MessageHash(fromL2Address, toL1Address, payload) {
+    return solidityUint256PackedKeccak256([fromL2Address, toL1Address, payload.length, ...payload]);
+  }
 
   // src/utils/shortString.ts
   var shortString_exports = {};
@@ -7081,6 +7089,7 @@ ${indent}}` : "}";
     computePoseidonHashOnElements: () => computePoseidonHashOnElements,
     computeSierraContractClassHash: () => computeSierraContractClassHash,
     formatSpaces: () => formatSpaces,
+    getL1MessageHash: () => getL1MessageHash,
     getL2MessageHash: () => getL2MessageHash,
     getSelector: () => getSelector,
     getSelectorFromName: () => getSelectorFromName,
@@ -12782,6 +12791,11 @@ ${indent}}` : "}";
             fee_data_availability_mode: details.feeDataAvailabilityMode
           }
         });
+        assertX(!details.maxFee, () => {
+          logger.warn(SYSTEM_MESSAGES.maxFeeInV3, {
+            type: esm_exports.ETransactionType.INVOKE
+          });
+        });
       }
       return this.waitMode ? this.waitForTransaction((await promise).transaction_hash) : promise;
     }
@@ -12852,6 +12866,11 @@ ${indent}}` : "}";
             fee_data_availability_mode: details.feeDataAvailabilityMode
           }
         });
+        assertX(!details.maxFee, () => {
+          logger.warn(SYSTEM_MESSAGES.maxFeeInV3, {
+            type: esm_exports.ETransactionType.DECLARE
+          });
+        });
       } else {
         throw Error("declare unspotted parameters");
       }
@@ -12893,6 +12912,11 @@ ${indent}}` : "}";
             fee_data_availability_mode: details.feeDataAvailabilityMode
           }
         });
+        assertX(!details.maxFee, () => {
+          logger.warn(SYSTEM_MESSAGES.maxFeeInV3, {
+            type: esm_exports.ETransactionType.DEPLOY_ACCOUNT
+          });
+        });
       }
       return this.waitMode ? this.waitForTransaction((await promise).transaction_hash) : promise;
     }
@@ -12963,6 +12987,12 @@ ${indent}}` : "}";
           fee_data_availability_mode: invocation.feeDataAvailabilityMode,
           account_deployment_data: invocation.accountDeploymentData.map((it) => toHex(it))
         };
+        assertX(!invocation.maxFee, () => {
+          logger.warn(SYSTEM_MESSAGES.maxFeeInV3, {
+            type: invocation.type,
+            versionType
+          });
+        });
       }
       if (invocation.type === TransactionType.INVOKE) {
         return {
@@ -17243,19 +17273,20 @@ ${indent}}` : "}";
   }
   function parseEvents(providerReceivedEvents, abiEvents, abiStructs, abiEnums) {
     const ret = providerReceivedEvents.flat().reduce((acc, recEvent) => {
-      let abiEvent = abiEvents[recEvent.keys.shift() ?? 0];
+      const currentEvent = JSON.parse(JSON.stringify(recEvent));
+      let abiEvent = abiEvents[currentEvent.keys.shift() ?? 0];
       if (!abiEvent) {
         return acc;
       }
       while (!abiEvent.name) {
-        const hashName = recEvent.keys.shift();
+        const hashName = currentEvent.keys.shift();
         assert(!!hashName, 'Not enough data in "keys" property of this event.');
         abiEvent = abiEvent[hashName];
       }
       const parsedEvent = {};
       parsedEvent[abiEvent.name] = {};
-      const keysIter = recEvent.keys[Symbol.iterator]();
-      const dataIter = recEvent.data[Symbol.iterator]();
+      const keysIter = currentEvent.keys[Symbol.iterator]();
+      const dataIter = currentEvent.data[Symbol.iterator]();
       const abiEventKeys = abiEvent.members?.filter((it) => it.kind === "key") || abiEvent.keys;
       const abiEventData = abiEvent.members?.filter((it) => it.kind === "data") || abiEvent.data;
       abiEventKeys.forEach((key) => {
@@ -17276,9 +17307,10 @@ ${indent}}` : "}";
           parsedEvent[abiEvent.name]
         );
       });
-      if ("block_hash" in recEvent) parsedEvent.block_hash = recEvent.block_hash;
-      if ("block_number" in recEvent) parsedEvent.block_number = recEvent.block_number;
-      if ("transaction_hash" in recEvent) parsedEvent.transaction_hash = recEvent.transaction_hash;
+      if ("block_hash" in currentEvent) parsedEvent.block_hash = currentEvent.block_hash;
+      if ("block_number" in currentEvent) parsedEvent.block_number = currentEvent.block_number;
+      if ("transaction_hash" in currentEvent)
+        parsedEvent.transaction_hash = currentEvent.transaction_hash;
       acc.push(parsedEvent);
       return acc;
     }, []);
@@ -17312,8 +17344,19 @@ ${indent}}` : "}";
     buildExecuteFromOutsideCall: () => buildExecuteFromOutsideCall,
     buildExecuteFromOutsideCallData: () => buildExecuteFromOutsideCallData,
     getOutsideCall: () => getOutsideCall,
-    getTypedData: () => getTypedData
+    getTypedData: () => getTypedData,
+    toOutsideCallV2: () => toOutsideCallV2
   });
+  function toOutsideCallV2(call) {
+    if ("calldata_len" in call) {
+      return {
+        To: call.to,
+        Selector: call.selector,
+        Calldata: call.calldata
+      };
+    }
+    return call;
+  }
   function getOutsideCall(call) {
     const callData = call.calldata ?? [];
     const callDataCompiled = Array.isArray(callData) ? callData : CallData.compile(callData);
@@ -17423,6 +17466,8 @@ ${indent}}` : "}";
   // src/utils/paymaster.ts
   var paymaster_exports = {};
   __export(paymaster_exports, {
+    assertCallsAreStrictlyEqual: () => assertCallsAreStrictlyEqual,
+    assertPaymasterTransactionSafety: () => assertPaymasterTransactionSafety,
     getDefaultPaymasterNodeUrl: () => getDefaultPaymasterNodeUrl
   });
   var getDefaultPaymasterNodeUrl = (networkName, mute = false) => {
@@ -17433,6 +17478,79 @@ ${indent}}` : "}";
     const randIdx = Math.floor(Math.random() * nodes.length);
     return nodes[randIdx];
   };
+  var assertGasFeeFromUnsafeCalls = (unsafeCalls, fees) => {
+    const unsafeCall = toOutsideCallV2(unsafeCalls[unsafeCalls.length - 1]);
+    const unsafeGasTokenCalldata = CallData.toCalldata(unsafeCall.Calldata);
+    const unsafeGasTokenValue = unsafeGasTokenCalldata[1];
+    assert(
+      BigInt(unsafeGasTokenValue) === BigInt(fees),
+      "Gas token value is not equal to the provided gas fees"
+    );
+  };
+  var assertGasTokenFromUnsafeCalls = (unsafeCalls, gasToken) => {
+    const unsafeCall = toOutsideCallV2(unsafeCalls[unsafeCalls.length - 1]);
+    assert(
+      BigInt(unsafeCall.To) === BigInt(gasToken),
+      "Gas token address is not equal to the provided gas token"
+    );
+  };
+  function assertCallsAreStrictlyEqual(originalCalls, unsafeCalls) {
+    const baseError = "Provided calls are not strictly equal to the returned calls";
+    assert(
+      unsafeCalls.length - 1 === originalCalls.length,
+      `${baseError}: Expected ${originalCalls.length + 1} calls, got ${unsafeCalls.length}`
+    );
+    for (let callIndex = 0; callIndex < originalCalls.length; callIndex += 1) {
+      const originalCall = originalCalls[callIndex];
+      const unsafeCall = toOutsideCallV2(unsafeCalls[callIndex]);
+      const normalizeAddress = (address) => {
+        return toBigInt(address).toString(16).toLowerCase();
+      };
+      const originalAddress = normalizeAddress(originalCall.contractAddress);
+      const unsafeAddress = normalizeAddress(unsafeCall.To);
+      assert(
+        originalAddress === unsafeAddress,
+        `${baseError}: Contract address mismatch at call ${callIndex}. Expected: ${originalCall.contractAddress}, Got: ${unsafeCall.To}`
+      );
+      assert(
+        getSelectorFromName(originalCall.entrypoint) === unsafeCall.Selector,
+        `${baseError}: Entrypoint mismatch at call ${callIndex}. Expected: ${originalCall.entrypoint}, Got: ${unsafeCall.Selector}`
+      );
+      const originalCalldata = CallData.toCalldata(originalCall.calldata);
+      const unsafeCalldata = CallData.toCalldata(unsafeCall.Calldata);
+      assert(
+        originalCalldata.length === unsafeCalldata.length,
+        `${baseError}: Calldata length mismatch at call ${callIndex}. Expected length: ${originalCalldata.length}, Got length: ${unsafeCalldata.length}`
+      );
+      for (let dataIndex = 0; dataIndex < originalCalldata.length; dataIndex += 1) {
+        const originalValue = BigInt(originalCalldata[dataIndex]);
+        const unsafeValue = BigInt(unsafeCalldata[dataIndex]);
+        assert(
+          originalValue === unsafeValue,
+          `${baseError}: Calldata value mismatch at call ${callIndex}, parameter ${dataIndex}. Expected: ${originalCalldata[dataIndex]}, Got: ${unsafeCalldata[dataIndex]}`
+        );
+      }
+    }
+  }
+  var assertPaymasterTransactionSafety = (preparedTransaction, calls, paymasterDetails, maxFeeInGasToken) => {
+    if (paymasterDetails.feeMode.mode !== "sponsored") {
+      if (preparedTransaction.type === "invoke" || preparedTransaction.type === "deploy_and_invoke") {
+        const unsafeCalls = "calls" in preparedTransaction.typed_data.message ? preparedTransaction.typed_data.message.calls : preparedTransaction.typed_data.message.Calls;
+        assertCallsAreStrictlyEqual(calls, unsafeCalls);
+        assertGasTokenFromUnsafeCalls(unsafeCalls, paymasterDetails.feeMode.gasToken);
+        if (maxFeeInGasToken) {
+          assert(
+            preparedTransaction.fee.suggested_max_fee_in_gas_token <= maxFeeInGasToken,
+            "Gas token price is too high"
+          );
+          assertGasFeeFromUnsafeCalls(
+            unsafeCalls,
+            preparedTransaction.fee.suggested_max_fee_in_gas_token
+          );
+        }
+      }
+    }
+  };
 
   // src/paymaster/rpc.ts
   var convertCalls = (calls) => calls.map((call) => ({
@@ -17452,13 +17570,14 @@ ${indent}}` : "}";
     }
     return { mode: "default", gasToken: feeMode.gas_token };
   };
-  var convertTimeBounds = (timeBounds) => timeBounds && timeBounds.executeAfter && timeBounds.executeBefore ? {
-    execute_after: timeBounds.executeAfter.getTime().toString(),
-    execute_before: timeBounds.executeBefore.getTime().toString()
+  var convertTimeBounds = (timeBounds) => timeBounds ? {
+    execute_after: timeBounds.executeAfter || 1,
+    // If executeAfter is not provided, set it to 1, meaning the transaction can be executed immediately
+    execute_before: timeBounds.executeBefore
   } : void 0;
-  var convertTIME_BOUNDS = (timeBounds) => timeBounds && timeBounds.execute_after && timeBounds.execute_before ? {
-    executeAfter: new Date(timeBounds.execute_after),
-    executeBefore: new Date(timeBounds.execute_before)
+  var convertTIME_BOUNDS = (timeBounds) => timeBounds ? {
+    executeAfter: timeBounds.execute_after,
+    executeBefore: timeBounds.execute_before
   } : void 0;
   var convertEXECUTION_PARAMETERS = (parameters) => ({
     version: parameters.version,
@@ -17871,13 +17990,6 @@ ${indent}}` : "}";
     }
     async execute(transactions, transactionsDetail = {}) {
       const calls = Array.isArray(transactions) ? transactions : [transactions];
-      if (transactionsDetail.paymaster) {
-        return this.executePaymasterTransaction(
-          calls,
-          transactionsDetail.paymaster,
-          transactionsDetail.maxFee
-        );
-      }
       const nonce = toBigInt(transactionsDetail.nonce ?? await this.getNonce());
       const version = toTransactionVersion(
         this.getPreferredVersion(ETransactionVersion5.V1, ETransactionVersion5.V3),
@@ -17954,11 +18066,7 @@ ${indent}}` : "}";
       const preparedTransaction = await this.buildPaymasterTransaction(calls, paymasterDetails);
       return preparedTransaction.fee;
     }
-    async executePaymasterTransaction(calls, paymasterDetails, maxFee) {
-      const preparedTransaction = await this.buildPaymasterTransaction(calls, paymasterDetails);
-      if (maxFee && preparedTransaction.fee.gas_token_price_in_strk > maxFee) {
-        throw Error("Gas token price is too high");
-      }
+    async preparePaymasterTransaction(preparedTransaction) {
       let transaction;
       switch (preparedTransaction.type) {
         case "deploy_and_invoke": {
@@ -17996,6 +18104,17 @@ ${indent}}` : "}";
         default:
           throw Error("Invalid transaction type");
       }
+      return transaction;
+    }
+    async executePaymasterTransaction(calls, paymasterDetails, maxFeeInGasToken) {
+      const preparedTransaction = await this.buildPaymasterTransaction(calls, paymasterDetails);
+      assertPaymasterTransactionSafety(
+        preparedTransaction,
+        calls,
+        paymasterDetails,
+        maxFeeInGasToken
+      );
+      const transaction = await this.preparePaymasterTransaction(preparedTransaction);
       return this.paymaster.executeTransaction(transaction, preparedTransaction.parameters).then((response) => ({ transaction_hash: response.transaction_hash }));
     }
     /**
@@ -18586,14 +18705,7 @@ ${indent}}` : "}";
     /**
      * ACCOUNT METHODS
      */
-    execute(calls, arg2, transactionsDetail = {}) {
-      const details = arg2 === void 0 || Array.isArray(arg2) ? transactionsDetail : arg2;
-      if (details.paymaster) {
-        return this.executePaymasterTransaction(
-          Array.isArray(calls) ? calls : [calls],
-          details.paymaster
-        );
-      }
+    execute(calls) {
       const txCalls = [].concat(calls).map((it) => {
         const { contractAddress, entrypoint, calldata } = it;
         return {