starknet 10.7.1 → 10.7.3

package/dist/index.js

@@ -11517,9 +11517,12 @@ var getDefaultPaymasterNodeUrl = (networkName, mute = false) => {
 var assertGasFeeFromUnsafeCalls = (unsafeCalls, fees) => {
   const unsafeCall = toOutsideCallV2(unsafeCalls[unsafeCalls.length - 1]);
   const unsafeGasTokenCalldata = CallData.toCalldata(unsafeCall.Calldata);
-  const unsafeGasTokenValue = unsafeGasTokenCalldata[1];
+  const unsafeGasTokenValue = uint256ToBN({
+    low: unsafeGasTokenCalldata[1],
+    high: unsafeGasTokenCalldata[2]
+  });
   assert(
-    BigInt(unsafeGasTokenValue) === BigInt(fees),
+    unsafeGasTokenValue === BigInt(fees),
     "Gas token value is not equal to the provided gas fees"
   );
 };
@@ -11529,12 +11532,21 @@ var assertGasTokenFromUnsafeCalls = (unsafeCalls, gasToken) => {
     BigInt(unsafeCall.To) === BigInt(gasToken),
     "Gas token address is not equal to the provided gas token"
   );
+  assert(
+    unsafeCall.Selector === getSelectorFromName("transfer"),
+    "Gas token call selector is not a transfer"
+  );
+  assert(
+    CallData.toCalldata(unsafeCall.Calldata).length === 3,
+    "Gas token transfer calldata does not match the expected recipient/amount shape"
+  );
 };
-function assertCallsAreStrictlyEqual(originalCalls, unsafeCalls) {
+function assertCallsAreStrictlyEqual(originalCalls, unsafeCalls, isSponsored = false) {
   const baseError = "Provided calls are not strictly equal to the returned calls";
+  const expectedExtraCalls = isSponsored ? 0 : 1;
   assert(
-    unsafeCalls.length - 1 === originalCalls.length,
-    `${baseError}: Expected ${originalCalls.length + 1} calls, got ${unsafeCalls.length}`
+    unsafeCalls.length - expectedExtraCalls === originalCalls.length,
+    `${baseError}: Expected ${originalCalls.length + expectedExtraCalls} calls, got ${unsafeCalls.length}`
   );
   for (let callIndex = 0; callIndex < originalCalls.length; callIndex += 1) {
     const originalCall = originalCalls[callIndex];
@@ -11568,21 +11580,42 @@ function assertCallsAreStrictlyEqual(originalCalls, unsafeCalls) {
     }
   }
 }
-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);
+var domainFieldToFelt = (value) => {
+  try {
+    return toBigInt(value);
+  } catch {
+    return toBigInt(encodeShortString(String(value)));
+  }
+};
+var assertChainIdFromTypedData = (typedData, chainId) => {
+  assert(
+    typedData.domain.chainId !== void 0 && domainFieldToFelt(typedData.domain.chainId) === BigInt(chainId),
+    "Paymaster typed data domain chainId does not match the account's provider chain"
+  );
+};
+var assertPaymasterTransactionSafety = (preparedTransaction, calls, paymasterDetails, chainId, maxFeeInGasToken) => {
+  if (preparedTransaction.type === "invoke" || preparedTransaction.type === "deploy_and_invoke") {
+    assertChainIdFromTypedData(preparedTransaction.typed_data, chainId);
+    const { message } = preparedTransaction.typed_data;
+    const hasV1Calls = "calls" in message;
+    const hasV2Calls = "Calls" in message;
+    assert(
+      hasV1Calls !== hasV2Calls,
+      'Paymaster typed data must declare exactly one of "calls" (SNIP-9 V1) or "Calls" (SNIP-9 V2)'
+    );
+    const unsafeCalls = hasV1Calls ? message.calls : message.Calls;
+    assertCallsAreStrictlyEqual(calls, unsafeCalls, paymasterDetails.feeMode.mode === "sponsored");
+    if (paymasterDetails.feeMode.mode !== "sponsored") {
       assertGasTokenFromUnsafeCalls(unsafeCalls, paymasterDetails.feeMode.gasToken);
+      assertGasFeeFromUnsafeCalls(
+        unsafeCalls,
+        preparedTransaction.fee.suggested_max_fee_in_gas_token
+      );
       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
-        );
       }
     }
   }
@@ -11836,9 +11869,10 @@ var Deployer = class {
       const compiledConstructorCallData = getCompiledCalldata(constructorCalldata, () => {
         if (abi) {
           const calldataClass = new CallData(abi);
-          const rawArgs = Object.values(constructorCalldata);
-          calldataClass.validate(ValidateType.DEPLOY, "constructor", rawArgs);
-          return calldataClass.compile("constructor", rawArgs);
+          if (Array.isArray(constructorCalldata)) {
+            calldataClass.validate(ValidateType.DEPLOY, "constructor", constructorCalldata);
+          }
+          return calldataClass.compile("constructor", constructorCalldata);
         }
         return CallData.compile(constructorCalldata);
       });
@@ -12707,6 +12741,7 @@ var Account = class {
       preparedTransaction,
       calls,
       paymasterDetails,
+      await this.provider.getChainId(),
       maxFeeInGasToken
     );
     const transaction = await this.preparePaymasterTransaction(preparedTransaction);