starknet 7.2.0 → 7.4.0

package/dist/index.js

@@ -70,6 +70,8 @@ __export(index_exports, {
   OutsideExecutionTypesV1: () => OutsideExecutionTypesV1,
   OutsideExecutionTypesV2: () => OutsideExecutionTypesV2,
   OutsideExecutionVersion: () => OutsideExecutionVersion,
+  PaymasterInterface: () => PaymasterInterface,
+  PaymasterRpc: () => PaymasterRpc,
   Provider: () => RpcProvider2,
   ProviderInterface: () => ProviderInterface,
   RPC: () => api_exports,
@@ -108,6 +110,7 @@ __export(index_exports, {
   config: () => config,
   constants: () => constants_exports,
   contractClassResponseToLegacyCompiledContract: () => contractClassResponseToLegacyCompiledContract,
+  defaultPaymaster: () => defaultPaymaster,
   defaultProvider: () => defaultProvider,
   ec: () => ec_exports,
   encode: () => encode_exports,
@@ -137,6 +140,7 @@ __export(index_exports, {
   num: () => num_exports,
   outsideExecution: () => outsideExecution_exports,
   parseCalldataField: () => parseCalldataField,
+  paymaster: () => paymaster_exports,
   provider: () => provider_exports,
   selector: () => selector_exports,
   shortString: () => shortString_exports,
@@ -172,6 +176,7 @@ __export(constants_exports, {
   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,
@@ -193,6 +198,7 @@ __export(constants_exports, {
 var api_exports = {};
 __export(api_exports, {
   JRPC: () => jsonrpc_exports,
+  PAYMASTER_API: () => import_starknet_types_08.PAYMASTER_API,
   RPCSPEC07: () => RPCSPEC07,
   RPCSPEC08: () => RPCSPEC08
 });
@@ -203,6 +209,7 @@ var jsonrpc_exports = {};
 // src/types/api/index.ts
 var RPCSPEC07 = __toESM(require("starknet-types-07"));
 var RPCSPEC08 = __toESM(require("starknet-types-08"));
+var import_starknet_types_08 = require("starknet-types-08");
 __reExport(api_exports, require("starknet-types-08"));
 
 // src/utils/encode.ts
@@ -365,21 +372,20 @@ 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`],
+  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
@@ -829,6 +835,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 = {};
@@ -973,6 +988,7 @@ function isBigNumberish(input) {
 // src/utils/hash/selector.ts
 var selector_exports = {};
 __export(selector_exports, {
+  getL1MessageHash: () => getL1MessageHash,
   getL2MessageHash: () => getL2MessageHash,
   getSelector: () => getSelector,
   getSelectorFromName: () => getSelectorFromName,
@@ -1023,6 +1039,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 = {};
@@ -3176,6 +3195,7 @@ __export(hash_exports, {
   computePoseidonHashOnElements: () => computePoseidonHashOnElements,
   computeSierraContractClassHash: () => computeSierraContractClassHash,
   formatSpaces: () => formatSpaces,
+  getL1MessageHash: () => getL1MessageHash,
   getL2MessageHash: () => getL2MessageHash,
   getSelector: () => getSelector,
   getSelectorFromName: () => getSelectorFromName,
@@ -3903,7 +3923,18 @@ var errorCodes = {
   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;
 
@@ -4617,6 +4648,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;
   }
@@ -4687,6 +4723,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");
     }
@@ -4728,6 +4769,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;
   }
@@ -4798,6 +4844,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 {
@@ -8861,19 +8913,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) => {
@@ -8894,9 +8947,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;
   }, []);
@@ -8930,8 +8984,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);
@@ -9038,13 +9103,332 @@ 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) => {
+  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;
@@ -9052,6 +9436,7 @@ var Account = class extends RpcProvider2 {
       this.cairoVersion = cairoVersion.toString();
     }
     this.transactionVersion = transactionVersion;
+    this.paymaster = paymaster ? new PaymasterRpc(paymaster) : defaultPaymaster;
     logger.debug("Account setup", {
       transactionVersion: this.transactionVersion,
       cairoVersion: this.cairoVersion,
@@ -9282,6 +9667,95 @@ var Account = class extends RpcProvider2 {
       }
     );
   }
+  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 ''.
@@ -9828,8 +10302,8 @@ function onNetworkChanged(swo, callback) {
 // 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;
@@ -9911,12 +10385,12 @@ var WalletAccount = class _WalletAccount extends Account {
   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
 };
@@ -10335,6 +10809,8 @@ function units(amount, simbol = "fri") {
   OutsideExecutionTypesV1,
   OutsideExecutionTypesV2,
   OutsideExecutionVersion,
+  PaymasterInterface,
+  PaymasterRpc,
   Provider,
   ProviderInterface,
   RPC,
@@ -10373,6 +10849,7 @@ function units(amount, simbol = "fri") {
   config,
   constants,
   contractClassResponseToLegacyCompiledContract,
+  defaultPaymaster,
   defaultProvider,
   ec,
   encode,
@@ -10402,6 +10879,7 @@ function units(amount, simbol = "fri") {
   num,
   outsideExecution,
   parseCalldataField,
+  paymaster,
   provider,
   selector,
   shortString,