starknet 7.2.0 → 7.3.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, {
@@ -919,6 +929,10 @@ var starknet = (() => {
       `https://free-rpc.nethermind.io/sepolia-juno/`
     ]
   };
+  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",
@@ -11962,7 +11976,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;
 
@@ -17395,13 +17420,257 @@ ${indent}}` : "}";
     }
   }
 
+  // src/utils/paymaster.ts
+  var paymaster_exports = {};
+  __export(paymaster_exports, {
+    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];
+  };
+
+  // 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 +17678,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,
@@ -17601,6 +17871,13 @@ ${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),
@@ -17639,6 +17916,88 @@ ${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 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");
+      }
+      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 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 +18544,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;
@@ -18227,7 +18586,14 @@ ${indent}}` : "}";
     /**
      * ACCOUNT METHODS
      */
-    execute(calls) {
+    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
+        );
+      }
       const txCalls = [].concat(calls).map((it) => {
         const { contractAddress, entrypoint, calldata } = it;
         return {
@@ -18268,12 +18634,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
   };