starknet 7.3.0 → 7.5.0

package/dist/index.mjs

@@ -63,10 +63,10 @@ var jsonrpc_exports = {};
 
 // src/types/api/index.ts
 __reExport(api_exports, starknet_types_08_star);
-import * as RPCSPEC07 from "starknet-types-07";
-import * as RPCSPEC08 from "starknet-types-08";
-import { PAYMASTER_API } from "starknet-types-08";
-import * as starknet_types_08_star from "starknet-types-08";
+import * as RPCSPEC07 from "@starknet-io/starknet-types-07";
+import * as RPCSPEC08 from "@starknet-io/starknet-types-08";
+import { PAYMASTER_API } from "@starknet-io/starknet-types-08";
+import * as starknet_types_08_star from "@starknet-io/starknet-types-08";
 
 // src/utils/encode.ts
 var encode_exports = {};
@@ -228,14 +228,8 @@ var DEFAULT_GLOBAL_CONFIG = {
   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`],
@@ -246,7 +240,8 @@ var SYSTEM_MESSAGES = {
   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
@@ -498,7 +493,7 @@ var BlockTag = {
 };
 
 // src/provider/types/spec.type.ts
-import * as RPCSPEC082 from "starknet-types-08";
+import * as RPCSPEC082 from "@starknet-io/starknet-types-08";
 var { ETransactionVersion: ETransactionVersion2 } = RPCSPEC082;
 var { ETransactionVersion2: ETransactionVersion22 } = RPCSPEC082;
 var { ETransactionVersion3 } = RPCSPEC082;
@@ -592,7 +587,7 @@ var OutsideExecutionVersion = {
 // src/types/typedData.ts
 import {
   TypedDataRevision
-} from "starknet-types-07";
+} from "@starknet-io/starknet-types-07";
 
 // src/utils/json.ts
 var json_exports = {};
@@ -698,6 +693,15 @@ function assert(condition, message) {
     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 = {};
@@ -842,6 +846,7 @@ function isBigNumberish(input) {
 // src/utils/hash/selector.ts
 var selector_exports = {};
 __export(selector_exports, {
+  getL1MessageHash: () => getL1MessageHash,
   getL2MessageHash: () => getL2MessageHash,
   getSelector: () => getSelector,
   getSelectorFromName: () => getSelectorFromName,
@@ -892,6 +897,9 @@ function getL2MessageHash(l1FromAddress, l2ToAddress, l2Selector, l2Calldata, l1
     ...l2Calldata
   ]);
 }
+function getL1MessageHash(fromL2Address, toL1Address, payload) {
+  return solidityUint256PackedKeccak256([fromL2Address, toL1Address, payload.length, ...payload]);
+}
 
 // src/utils/shortString.ts
 var shortString_exports = {};
@@ -3045,6 +3053,7 @@ __export(hash_exports, {
   computePoseidonHashOnElements: () => computePoseidonHashOnElements,
   computeSierraContractClassHash: () => computeSierraContractClassHash,
   formatSpaces: () => formatSpaces,
+  getL1MessageHash: () => getL1MessageHash,
   getL2MessageHash: () => getL2MessageHash,
   getSelector: () => getSelector,
   getSelectorFromName: () => getSelectorFromName,
@@ -4497,6 +4506,11 @@ var RpcChannel = class {
           fee_data_availability_mode: details.feeDataAvailabilityMode
         }
       });
+      assertX(!details.maxFee, () => {
+        logger.warn(SYSTEM_MESSAGES.maxFeeInV3, {
+          type: RPCSPEC07.ETransactionType.INVOKE
+        });
+      });
     }
     return this.waitMode ? this.waitForTransaction((await promise).transaction_hash) : promise;
   }
@@ -4567,6 +4581,11 @@ var RpcChannel = class {
           fee_data_availability_mode: details.feeDataAvailabilityMode
         }
       });
+      assertX(!details.maxFee, () => {
+        logger.warn(SYSTEM_MESSAGES.maxFeeInV3, {
+          type: RPCSPEC07.ETransactionType.DECLARE
+        });
+      });
     } else {
       throw Error("declare unspotted parameters");
     }
@@ -4608,6 +4627,11 @@ var RpcChannel = class {
           fee_data_availability_mode: details.feeDataAvailabilityMode
         }
       });
+      assertX(!details.maxFee, () => {
+        logger.warn(SYSTEM_MESSAGES.maxFeeInV3, {
+          type: RPCSPEC07.ETransactionType.DEPLOY_ACCOUNT
+        });
+      });
     }
     return this.waitMode ? this.waitForTransaction((await promise).transaction_hash) : promise;
   }
@@ -4678,6 +4702,12 @@ var RpcChannel = class {
         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 {
@@ -8741,19 +8771,20 @@ function mergeAbiEvents(target, source) {
 }
 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) => {
@@ -8774,9 +8805,10 @@ function parseEvents(providerReceivedEvents, abiEvents, abiStructs, abiEnums) {
         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;
   }, []);
@@ -8810,8 +8842,19 @@ __export(outsideExecution_exports, {
   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);
@@ -8921,6 +8964,8 @@ async function supportsInterface(provider, contractAddress, interfaceId) {
 // src/utils/paymaster.ts
 var paymaster_exports = {};
 __export(paymaster_exports, {
+  assertCallsAreStrictlyEqual: () => assertCallsAreStrictlyEqual,
+  assertPaymasterTransactionSafety: () => assertPaymasterTransactionSafety,
   getDefaultPaymasterNodeUrl: () => getDefaultPaymasterNodeUrl
 });
 var getDefaultPaymasterNodeUrl = (networkName, mute = false) => {
@@ -8931,6 +8976,79 @@ var getDefaultPaymasterNodeUrl = (networkName, mute = false) => {
   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) => ({
@@ -8950,13 +9068,14 @@ var convertFEE_MODE = (feeMode) => {
   }
   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,
@@ -9369,13 +9488,6 @@ var Account = class extends RpcProvider2 {
   }
   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(ETransactionVersion2.V1, ETransactionVersion2.V3),
@@ -9452,11 +9564,7 @@ var Account = class extends RpcProvider2 {
     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": {
@@ -9494,6 +9602,17 @@ var Account = class extends RpcProvider2 {
       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 }));
   }
   /**
@@ -10084,14 +10203,7 @@ var WalletAccount = class _WalletAccount extends Account {
   /**
    * 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 {