starknet 7.2.0 → 7.4.0

package/dist/index.global.js

@@ -60,6 +60,8 @@ var starknet = (() => {
     OutsideExecutionTypesV1: () => OutsideExecutionTypesV1,
     OutsideExecutionTypesV2: () => OutsideExecutionTypesV2,
     OutsideExecutionVersion: () => OutsideExecutionVersion,
+    PaymasterInterface: () => PaymasterInterface,
+    PaymasterRpc: () => PaymasterRpc,
     Provider: () => RpcProvider2,
     ProviderInterface: () => ProviderInterface,
     RPC: () => api_exports3,
@@ -98,6 +100,7 @@ var starknet = (() => {
     config: () => config,
     constants: () => constants_exports,
     contractClassResponseToLegacyCompiledContract: () => contractClassResponseToLegacyCompiledContract,
+    defaultPaymaster: () => defaultPaymaster,
     defaultProvider: () => defaultProvider,
     ec: () => ec_exports,
     encode: () => encode_exports,
@@ -127,6 +130,7 @@ var starknet = (() => {
     num: () => num_exports,
     outsideExecution: () => outsideExecution_exports,
     parseCalldataField: () => parseCalldataField,
+    paymaster: () => paymaster_exports,
     provider: () => provider_exports,
     selector: () => selector_exports,
     shortString: () => shortString_exports,
@@ -161,6 +165,7 @@ var starknet = (() => {
     MAX_STORAGE_ITEM_SIZE: () => MAX_STORAGE_ITEM_SIZE,
     NetworkName: () => _NetworkName,
     OutsideExecutionCallerAny: () => OutsideExecutionCallerAny,
+    PAYMASTER_RPC_NODES: () => PAYMASTER_RPC_NODES,
     PRIME: () => PRIME,
     RANGE_FELT: () => RANGE_FELT,
     RANGE_I128: () => RANGE_I128,
@@ -202,6 +207,7 @@ var starknet = (() => {
     EVENT_ABI_TYPE: () => EVENT_ABI_TYPE,
     JRPC: () => jsonrpc_exports,
     L1_DA_MODE: () => L1_DA_MODE,
+    PAYMASTER_API: () => snip_29_exports,
     PRICE_UNIT_FRI: () => PRICE_UNIT_FRI,
     PRICE_UNIT_WEI: () => PRICE_UNIT_WEI,
     Permission: () => Permission2,
@@ -377,6 +383,7 @@ var starknet = (() => {
     ETransactionVersion3: () => ETransactionVersion32,
     EVENT_ABI_TYPE: () => EVENT_ABI_TYPE,
     L1_DA_MODE: () => L1_DA_MODE,
+    PAYMASTER_API: () => snip_29_exports,
     PRICE_UNIT_FRI: () => PRICE_UNIT_FRI,
     PRICE_UNIT_WEI: () => PRICE_UNIT_WEI,
     Permission: () => Permission2,
@@ -571,6 +578,9 @@ var starknet = (() => {
     LEGACY: "0"
   };
 
+  // node_modules/starknet-types-08/dist/esm/snip-29/index.js
+  var snip_29_exports = {};
+
   // src/utils/encode.ts
   var encode_exports = {};
   __export(encode_exports, {
@@ -910,21 +920,20 @@ 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`],
+    SN_SEPOLIA: [`https://sepolia.paymaster.avnu.fi`]
   };
   var SYSTEM_MESSAGES = {
     legacyTxWarningMessage: "You are using a deprecated transaction version (V0,V1,V2)!\nUpdate to the latest V3 transactions!",
     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
@@ -1914,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 = {};
@@ -2682,6 +2700,7 @@ ${indent}}` : "}";
   // src/utils/hash/selector.ts
   var selector_exports = {};
   __export(selector_exports, {
+    getL1MessageHash: () => getL1MessageHash,
     getL2MessageHash: () => getL2MessageHash,
     getSelector: () => getSelector,
     getSelectorFromName: () => getSelectorFromName,
@@ -4914,6 +4933,9 @@ ${indent}}` : "}";
       ...l2Calldata
     ]);
   }
+  function getL1MessageHash(fromL2Address, toL1Address, payload) {
+    return solidityUint256PackedKeccak256([fromL2Address, toL1Address, payload.length, ...payload]);
+  }
 
   // src/utils/shortString.ts
   var shortString_exports = {};
@@ -7067,6 +7089,7 @@ ${indent}}` : "}";
     computePoseidonHashOnElements: () => computePoseidonHashOnElements,
     computeSierraContractClassHash: () => computeSierraContractClassHash,
     formatSpaces: () => formatSpaces,
+    getL1MessageHash: () => getL1MessageHash,
     getL2MessageHash: () => getL2MessageHash,
     getSelector: () => getSelector,
     getSelectorFromName: () => getSelectorFromName,
@@ -11962,7 +11985,18 @@ ${indent}}` : "}";
     INVALID_SUBSCRIPTION_ID: 66,
     TOO_MANY_ADDRESSES_IN_FILTER: 67,
     TOO_MANY_BLOCKS_BACK: 68,
-    COMPILATION_ERROR: 100
+    COMPILATION_ERROR: 100,
+    INVALID_ADDRESS: 150,
+    TOKEN_NOT_SUPPORTED: 151,
+    INVALID_SIGNATURE: 153,
+    MAX_AMOUNT_TOO_LOW: 154,
+    CLASS_HASH_NOT_SUPPORTED: 155,
+    PAYMASTER_TRANSACTION_EXECUTION_ERROR: 156,
+    INVALID_TIME_BOUNDS: 157,
+    INVALID_DEPLOYMENT_DATA: 158,
+    INVALID_CLASS_HASH: 159,
+    INVALID_ID: 160,
+    UNKNOWN_ERROR: 163
   };
   var rpc_default = errorCodes;
 
@@ -12757,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;
     }
@@ -12827,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");
       }
@@ -12868,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;
     }
@@ -12938,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 {
@@ -17218,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) => {
@@ -17251,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;
     }, []);
@@ -17287,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);
@@ -17395,13 +17463,332 @@ ${indent}}` : "}";
     }
   }
 
+  // src/utils/paymaster.ts
+  var paymaster_exports = {};
+  __export(paymaster_exports, {
+    assertCallsAreStrictlyEqual: () => assertCallsAreStrictlyEqual,
+    assertPaymasterTransactionSafety: () => assertPaymasterTransactionSafety,
+    getDefaultPaymasterNodeUrl: () => getDefaultPaymasterNodeUrl
+  });
+  var getDefaultPaymasterNodeUrl = (networkName, mute = false) => {
+    if (!mute) {
+      logger.info("Using default public node url, please provide nodeUrl in provider options!");
+    }
+    const nodes = PAYMASTER_RPC_NODES[networkName ?? _NetworkName.SN_SEPOLIA];
+    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) => ({
+    to: call.contractAddress,
+    selector: getSelectorFromName(call.entrypoint),
+    calldata: CallData.toHex(call.calldata)
+  }));
+  var convertFeeMode = (feeMode) => {
+    if (feeMode.mode === "sponsored") {
+      return { mode: "sponsored" };
+    }
+    return { mode: "default", gas_token: feeMode.gasToken };
+  };
+  var convertFEE_MODE = (feeMode) => {
+    if (feeMode.mode === "sponsored") {
+      return { mode: "sponsored" };
+    }
+    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()
+  } : 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)
+  } : void 0;
+  var convertEXECUTION_PARAMETERS = (parameters) => ({
+    version: parameters.version,
+    feeMode: convertFEE_MODE(parameters.fee_mode),
+    timeBounds: convertTIME_BOUNDS(parameters.time_bounds)
+  });
+  var defaultOptions3 = {
+    headers: { "Content-Type": "application/json" }
+  };
+  var PaymasterRpc = class _PaymasterRpc {
+    nodeUrl;
+    headers;
+    baseFetch;
+    requestId;
+    constructor(options) {
+      if (options instanceof _PaymasterRpc) {
+        this.nodeUrl = options.nodeUrl;
+        this.headers = { ...defaultOptions3.headers, ...options.headers };
+        this.baseFetch = options.baseFetch;
+        this.requestId = options.requestId;
+        return;
+      }
+      if (options && "nodeUrl" in options && "headers" in options && "baseFetch" in options) {
+        this.nodeUrl = options.nodeUrl ?? getDefaultPaymasterNodeUrl(void 0);
+        this.headers = { ...defaultOptions3.headers, ...options.headers };
+        this.baseFetch = options.baseFetch ?? fetch_default;
+        this.requestId = 0;
+        return;
+      }
+      const { nodeUrl, headers, baseFetch } = options || {};
+      if (nodeUrl && Object.values(_NetworkName).includes(nodeUrl)) {
+        this.nodeUrl = getDefaultPaymasterNodeUrl(nodeUrl, options?.default);
+      } else if (nodeUrl) {
+        this.nodeUrl = nodeUrl;
+      } else {
+        this.nodeUrl = getDefaultPaymasterNodeUrl(void 0, options?.default);
+      }
+      this.baseFetch = baseFetch ?? fetch_default;
+      this.headers = { ...defaultOptions3.headers, ...headers };
+      this.requestId = 0;
+    }
+    fetch(method, params, id = 0) {
+      const rpcRequestBody = {
+        id,
+        jsonrpc: "2.0",
+        method,
+        ...params && { params }
+      };
+      return this.baseFetch(this.nodeUrl, {
+        method: "POST",
+        body: stringify2(rpcRequestBody),
+        headers: this.headers
+      });
+    }
+    errorHandler(method, params, rpcError, otherError) {
+      if (rpcError) {
+        throw new RpcError(rpcError, method, params);
+      }
+      if (otherError instanceof LibraryError) {
+        throw otherError;
+      }
+      if (otherError) {
+        throw Error(otherError.message);
+      }
+    }
+    async fetchEndpoint(method, params) {
+      try {
+        this.requestId += 1;
+        const rawResult = await this.fetch(method, params, this.requestId);
+        const { error, result } = await rawResult.json();
+        this.errorHandler(method, params, error);
+        return result;
+      } catch (error) {
+        this.errorHandler(method, params, error?.response?.data, error);
+        throw error;
+      }
+    }
+    async isAvailable() {
+      return this.fetchEndpoint("paymaster_isAvailable");
+    }
+    async buildTransaction(transaction, parameters) {
+      let userTransaction;
+      switch (transaction.type) {
+        case "invoke":
+          userTransaction = {
+            ...transaction,
+            invoke: {
+              user_address: transaction.invoke.userAddress,
+              calls: convertCalls(transaction.invoke.calls)
+            }
+          };
+          break;
+        case "deploy_and_invoke":
+          userTransaction = {
+            ...transaction,
+            invoke: {
+              user_address: transaction.invoke.userAddress,
+              calls: convertCalls(transaction.invoke.calls)
+            }
+          };
+          break;
+        case "deploy":
+        default:
+          userTransaction = transaction;
+          break;
+      }
+      const executionParameters = {
+        version: parameters.version,
+        fee_mode: convertFeeMode(parameters.feeMode),
+        time_bounds: convertTimeBounds(parameters.timeBounds)
+      };
+      const response = await this.fetchEndpoint("paymaster_buildTransaction", {
+        transaction: userTransaction,
+        parameters: executionParameters
+      });
+      const fee = {
+        gas_token_price_in_strk: BigInt(response.fee.gas_token_price_in_strk),
+        estimated_fee_in_strk: BigInt(response.fee.estimated_fee_in_strk),
+        estimated_fee_in_gas_token: BigInt(response.fee.estimated_fee_in_gas_token),
+        suggested_max_fee_in_strk: BigInt(response.fee.suggested_max_fee_in_strk),
+        suggested_max_fee_in_gas_token: BigInt(response.fee.suggested_max_fee_in_gas_token)
+      };
+      switch (response.type) {
+        case "invoke":
+          return {
+            type: "invoke",
+            typed_data: response.typed_data,
+            parameters: convertEXECUTION_PARAMETERS(response.parameters),
+            fee
+          };
+        case "deploy_and_invoke":
+          return {
+            type: "deploy_and_invoke",
+            deployment: response.deployment,
+            typed_data: response.typed_data,
+            parameters: convertEXECUTION_PARAMETERS(response.parameters),
+            fee
+          };
+        case "deploy":
+        default:
+          return {
+            type: "deploy",
+            deployment: response.deployment,
+            parameters: convertEXECUTION_PARAMETERS(response.parameters),
+            fee
+          };
+      }
+    }
+    async executeTransaction(transaction, parameters) {
+      let user_transaction;
+      switch (transaction.type) {
+        case "invoke":
+          user_transaction = {
+            ...transaction,
+            invoke: {
+              user_address: transaction.invoke.userAddress,
+              typed_data: transaction.invoke.typedData,
+              signature: signatureToHexArray(transaction.invoke.signature)
+            }
+          };
+          break;
+        case "deploy_and_invoke":
+          user_transaction = {
+            ...transaction,
+            invoke: {
+              user_address: transaction.invoke.userAddress,
+              typed_data: transaction.invoke.typedData,
+              signature: signatureToHexArray(transaction.invoke.signature)
+            }
+          };
+          break;
+        case "deploy":
+        default:
+          user_transaction = transaction;
+          break;
+      }
+      const executionParameters = {
+        version: parameters.version,
+        fee_mode: convertFeeMode(parameters.feeMode),
+        time_bounds: convertTimeBounds(parameters.timeBounds)
+      };
+      return this.fetchEndpoint("paymaster_executeTransaction", {
+        transaction: user_transaction,
+        parameters: executionParameters
+      });
+    }
+    async getSupportedTokens() {
+      return this.fetchEndpoint("paymaster_getSupportedTokens").then(
+        (tokens) => tokens.map((token) => ({
+          token_address: token.token_address,
+          decimals: token.decimals,
+          priceInStrk: BigInt(token.price_in_strk)
+        }))
+      );
+    }
+  };
+
+  // src/paymaster/interface.ts
+  var PaymasterInterface = class {
+  };
+
+  // src/paymaster/index.ts
+  var defaultPaymaster = new PaymasterRpc({ default: true });
+
   // src/account/default.ts
   var Account = class extends RpcProvider2 {
     signer;
     address;
     cairoVersion;
     transactionVersion;
-    constructor(providerOrOptions, address, pkOrSigner, cairoVersion, transactionVersion = config.get("transactionVersion")) {
+    paymaster;
+    constructor(providerOrOptions, address, pkOrSigner, cairoVersion, transactionVersion = config.get("transactionVersion"), paymaster) {
       super(providerOrOptions);
       this.address = address.toLowerCase();
       this.signer = isString(pkOrSigner) || pkOrSigner instanceof Uint8Array ? new Signer(pkOrSigner) : pkOrSigner;
@@ -17409,6 +17796,7 @@ ${indent}}` : "}";
         this.cairoVersion = cairoVersion.toString();
       }
       this.transactionVersion = transactionVersion;
+      this.paymaster = paymaster ? new PaymasterRpc(paymaster) : defaultPaymaster;
       logger.debug("Account setup", {
         transactionVersion: this.transactionVersion,
         cairoVersion: this.cairoVersion,
@@ -17639,6 +18027,95 @@ ${indent}}` : "}";
         }
       );
     }
+    async buildPaymasterTransaction(calls, paymasterDetails) {
+      if (!paymasterDetails.deploymentData) {
+        const snip9Version = await this.getSnip9Version();
+        if (snip9Version === OutsideExecutionVersion.UNSUPPORTED) {
+          throw Error("Account is not compatible with SNIP-9");
+        }
+      }
+      const parameters = {
+        version: "0x1",
+        feeMode: paymasterDetails.feeMode,
+        timeBounds: paymasterDetails.timeBounds
+      };
+      let transaction;
+      if (paymasterDetails.deploymentData) {
+        if (calls.length > 0) {
+          transaction = {
+            type: "deploy_and_invoke",
+            invoke: { userAddress: this.address, calls },
+            deployment: paymasterDetails.deploymentData
+          };
+        } else {
+          transaction = {
+            type: "deploy",
+            deployment: paymasterDetails.deploymentData
+          };
+        }
+      } else {
+        transaction = {
+          type: "invoke",
+          invoke: { userAddress: this.address, calls }
+        };
+      }
+      return this.paymaster.buildTransaction(transaction, parameters);
+    }
+    async estimatePaymasterTransactionFee(calls, paymasterDetails) {
+      const preparedTransaction = await this.buildPaymasterTransaction(calls, paymasterDetails);
+      return preparedTransaction.fee;
+    }
+    async preparePaymasterTransaction(preparedTransaction) {
+      let transaction;
+      switch (preparedTransaction.type) {
+        case "deploy_and_invoke": {
+          const signature = await this.signMessage(preparedTransaction.typed_data);
+          transaction = {
+            type: "deploy_and_invoke",
+            invoke: {
+              userAddress: this.address,
+              typedData: preparedTransaction.typed_data,
+              signature: signatureToHexArray(signature)
+            },
+            deployment: preparedTransaction.deployment
+          };
+          break;
+        }
+        case "invoke": {
+          const signature = await this.signMessage(preparedTransaction.typed_data);
+          transaction = {
+            type: "invoke",
+            invoke: {
+              userAddress: this.address,
+              typedData: preparedTransaction.typed_data,
+              signature: signatureToHexArray(signature)
+            }
+          };
+          break;
+        }
+        case "deploy": {
+          transaction = {
+            type: "deploy",
+            deployment: preparedTransaction.deployment
+          };
+          break;
+        }
+        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 }));
+    }
     /**
      * First check if contract is already declared, if not declare it
      * If contract already declared returned transaction_hash is ''.
@@ -18185,8 +18662,8 @@ ${indent}}` : "}";
   // src/wallet/account.ts
   var WalletAccount = class _WalletAccount extends Account {
     walletProvider;
-    constructor(providerOrOptions, walletProvider, address, cairoVersion) {
-      super(providerOrOptions, address, "", cairoVersion);
+    constructor(providerOrOptions, walletProvider, address, cairoVersion, paymaster) {
+      super(providerOrOptions, address, "", cairoVersion, void 0, paymaster);
       this.walletProvider = walletProvider;
       this.walletProvider.on("accountsChanged", (res) => {
         if (!res) return;
@@ -18268,12 +18745,12 @@ ${indent}}` : "}";
     signMessage(typedData) {
       return signMessage(this.walletProvider, typedData);
     }
-    static async connect(provider, walletProvider, cairoVersion, silentMode = false) {
+    static async connect(provider, walletProvider, cairoVersion, paymaster, silentMode = false) {
       const [accountAddress] = await requestAccounts(walletProvider, silentMode);
-      return new _WalletAccount(provider, walletProvider, accountAddress, cairoVersion);
+      return new _WalletAccount(provider, walletProvider, accountAddress, cairoVersion, paymaster);
     }
-    static async connectSilent(provider, walletProvider, cairoVersion) {
-      return _WalletAccount.connect(provider, walletProvider, cairoVersion, true);
+    static async connectSilent(provider, walletProvider, cairoVersion, paymaster) {
+      return _WalletAccount.connect(provider, walletProvider, cairoVersion, paymaster, true);
     }
     // TODO: MISSING ESTIMATES
   };