starknet 6.9.0 → 6.10.1

package/dist/channel/rpc_0_7.cjs

@@ -0,0 +1,619 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RpcChannel = void 0;
+var _constants = require("../constants.cjs");
+var _errors = require("../provider/errors.cjs");
+var _types = require("../types/index.cjs");
+var _api = require("../types/api/index.cjs");
+var _calldata = require("../utils/calldata/index.cjs");
+var _contract = require("../utils/contract.cjs");
+var _eth = require("../utils/eth.cjs");
+var _fetchPonyfill = _interopRequireDefault(require("../utils/fetchPonyfill.cjs"));
+var _hash = require("../utils/hash/index.cjs");
+var _json = require("../utils/json.cjs");
+var _num = require("../utils/num.cjs");
+var _provider = require("../utils/provider.cjs");
+var _stark = require("../utils/stark.cjs");
+var _transaction = require("../utils/transaction.cjs");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const defaultOptions = {
+  headers: {
+    "Content-Type": "application/json"
+  },
+  blockIdentifier: _types.BlockTag.PENDING,
+  retries: 200
+};
+class RpcChannel {
+  nodeUrl;
+  headers;
+  retries;
+  requestId;
+  blockIdentifier;
+  chainId;
+  specVersion;
+  transactionRetryIntervalFallback;
+  waitMode;
+  // behave like web2 rpc and return when tx is processed
+  constructor(optionsOrProvider) {
+    const {
+      nodeUrl,
+      retries,
+      headers,
+      blockIdentifier,
+      chainId,
+      specVersion,
+      waitMode,
+      transactionRetryIntervalFallback
+    } = optionsOrProvider || {};
+    if (Object.values(_constants.NetworkName).includes(nodeUrl)) {
+      this.nodeUrl = (0, _provider.getDefaultNodeUrl)(nodeUrl, optionsOrProvider?.default);
+    } else if (nodeUrl) {
+      this.nodeUrl = nodeUrl;
+    } else {
+      this.nodeUrl = (0, _provider.getDefaultNodeUrl)(void 0, optionsOrProvider?.default);
+    }
+    this.retries = retries || defaultOptions.retries;
+    this.headers = {
+      ...defaultOptions.headers,
+      ...headers
+    };
+    this.blockIdentifier = blockIdentifier || defaultOptions.blockIdentifier;
+    this.chainId = chainId;
+    this.specVersion = specVersion;
+    this.waitMode = waitMode || false;
+    this.requestId = 0;
+    this.transactionRetryIntervalFallback = transactionRetryIntervalFallback;
+  }
+  get transactionRetryIntervalDefault() {
+    return this.transactionRetryIntervalFallback ?? 5e3;
+  }
+  setChainId(chainId) {
+    this.chainId = chainId;
+  }
+  fetch(method, params, id = 0) {
+    const rpcRequestBody = {
+      id,
+      jsonrpc: "2.0",
+      method,
+      ...(params && {
+        params
+      })
+    };
+    return (0, _fetchPonyfill.default)(this.nodeUrl, {
+      method: "POST",
+      body: (0, _json.stringify)(rpcRequestBody),
+      headers: this.headers
+    });
+  }
+  errorHandler(method, params, rpcError, otherError) {
+    if (rpcError) {
+      const {
+        code,
+        message,
+        data
+      } = rpcError;
+      throw new _errors.LibraryError(`RPC: ${method} with params ${(0, _json.stringify)(params, null, 2)}
+ 
+        ${code}: ${message}: ${(0, _json.stringify)(data)}`);
+    }
+    if (otherError instanceof _errors.LibraryError) {
+      throw otherError;
+    }
+    if (otherError) {
+      throw Error(otherError.message);
+    }
+  }
+  async fetchEndpoint(method, params) {
+    try {
+      const rawResult = await this.fetch(method, params, this.requestId += 1);
+      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 getChainId() {
+    this.chainId ??= await this.fetchEndpoint("starknet_chainId");
+    return this.chainId;
+  }
+  async getSpecVersion() {
+    this.specVersion ??= await this.fetchEndpoint("starknet_specVersion");
+    return this.specVersion;
+  }
+  getNonceForAddress(contractAddress, blockIdentifier = this.blockIdentifier) {
+    const contract_address = (0, _num.toHex)(contractAddress);
+    const block_id = new _provider.Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getNonce", {
+      contract_address,
+      block_id
+    });
+  }
+  /**
+   * Get the most recent accepted block hash and number
+   */
+  getBlockLatestAccepted() {
+    return this.fetchEndpoint("starknet_blockHashAndNumber");
+  }
+  /**
+   * Get the most recent accepted block number
+   * redundant use getBlockLatestAccepted();
+   * @returns Number of the latest block
+   */
+  getBlockNumber() {
+    return this.fetchEndpoint("starknet_blockNumber");
+  }
+  getBlockWithTxHashes(blockIdentifier = this.blockIdentifier) {
+    const block_id = new _provider.Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getBlockWithTxHashes", {
+      block_id
+    });
+  }
+  getBlockWithTxs(blockIdentifier = this.blockIdentifier) {
+    const block_id = new _provider.Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getBlockWithTxs", {
+      block_id
+    });
+  }
+  getBlockWithReceipts(blockIdentifier = this.blockIdentifier) {
+    const block_id = new _provider.Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getBlockWithReceipts", {
+      block_id
+    });
+  }
+  getBlockStateUpdate(blockIdentifier = this.blockIdentifier) {
+    const block_id = new _provider.Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getStateUpdate", {
+      block_id
+    });
+  }
+  getBlockTransactionsTraces(blockIdentifier = this.blockIdentifier) {
+    const block_id = new _provider.Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_traceBlockTransactions", {
+      block_id
+    });
+  }
+  getBlockTransactionCount(blockIdentifier = this.blockIdentifier) {
+    const block_id = new _provider.Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getBlockTransactionCount", {
+      block_id
+    });
+  }
+  getTransactionByHash(txHash) {
+    const transaction_hash = (0, _num.toHex)(txHash);
+    return this.fetchEndpoint("starknet_getTransactionByHash", {
+      transaction_hash
+    });
+  }
+  getTransactionByBlockIdAndIndex(blockIdentifier, index) {
+    const block_id = new _provider.Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getTransactionByBlockIdAndIndex", {
+      block_id,
+      index
+    });
+  }
+  getTransactionReceipt(txHash) {
+    const transaction_hash = (0, _num.toHex)(txHash);
+    return this.fetchEndpoint("starknet_getTransactionReceipt", {
+      transaction_hash
+    });
+  }
+  getTransactionTrace(txHash) {
+    const transaction_hash = (0, _num.toHex)(txHash);
+    return this.fetchEndpoint("starknet_traceTransaction", {
+      transaction_hash
+    });
+  }
+  /**
+   * Get the status of a transaction
+   */
+  getTransactionStatus(transactionHash) {
+    const transaction_hash = (0, _num.toHex)(transactionHash);
+    return this.fetchEndpoint("starknet_getTransactionStatus", {
+      transaction_hash
+    });
+  }
+  /**
+   * @param invocations AccountInvocations
+   * @param simulateTransactionOptions blockIdentifier and flags to skip validation and fee charge<br/>
+   * - blockIdentifier<br/>
+   * - skipValidate (default false)<br/>
+   * - skipFeeCharge (default true)<br/>
+   */
+  simulateTransaction(invocations, simulateTransactionOptions = {}) {
+    const {
+      blockIdentifier = this.blockIdentifier,
+      skipValidate = true,
+      skipFeeCharge = true
+    } = simulateTransactionOptions;
+    const block_id = new _provider.Block(blockIdentifier).identifier;
+    const simulationFlags = [];
+    if (skipValidate) simulationFlags.push(_api.RPCSPEC07.ESimulationFlag.SKIP_VALIDATE);
+    if (skipFeeCharge) simulationFlags.push(_api.RPCSPEC07.ESimulationFlag.SKIP_FEE_CHARGE);
+    return this.fetchEndpoint("starknet_simulateTransactions", {
+      block_id,
+      transactions: invocations.map(it => this.buildTransaction(it)),
+      simulation_flags: simulationFlags
+    });
+  }
+  async waitForTransaction(txHash, options) {
+    const transactionHash = (0, _num.toHex)(txHash);
+    let {
+      retries
+    } = this;
+    let onchain = false;
+    let isErrorState = false;
+    const retryInterval = options?.retryInterval ?? this.transactionRetryIntervalDefault;
+    const errorStates = options?.errorStates ?? [_api.RPCSPEC07.ETransactionStatus.REJECTED
+    // TODO: commented out to preserve the long-standing behavior of "reverted" not being treated as an error by default
+    // should decide which behavior to keep in the future
+    // RPC.ETransactionExecutionStatus.REVERTED,
+    ];
+    const successStates = options?.successStates ?? [_api.RPCSPEC07.ETransactionExecutionStatus.SUCCEEDED, _api.RPCSPEC07.ETransactionStatus.ACCEPTED_ON_L2, _api.RPCSPEC07.ETransactionStatus.ACCEPTED_ON_L1];
+    let txStatus;
+    while (!onchain) {
+      await (0, _provider.wait)(retryInterval);
+      try {
+        txStatus = await this.getTransactionStatus(transactionHash);
+        const executionStatus = txStatus.execution_status;
+        const finalityStatus = txStatus.finality_status;
+        if (!finalityStatus) {
+          const error = new Error("waiting for transaction status");
+          throw error;
+        }
+        if (errorStates.includes(executionStatus) || errorStates.includes(finalityStatus)) {
+          const message = `${executionStatus}: ${finalityStatus}`;
+          const error = new Error(message);
+          error.response = txStatus;
+          isErrorState = true;
+          throw error;
+        } else if (successStates.includes(executionStatus) || successStates.includes(finalityStatus)) {
+          onchain = true;
+        }
+      } catch (error) {
+        if (error instanceof Error && isErrorState) {
+          throw error;
+        }
+        if (retries <= 0) {
+          throw new Error(`waitForTransaction timed-out with retries ${this.retries}`);
+        }
+      }
+      retries -= 1;
+    }
+    let txReceipt = null;
+    while (txReceipt === null) {
+      try {
+        txReceipt = await this.getTransactionReceipt(transactionHash);
+      } catch (error) {
+        if (retries <= 0) {
+          throw new Error(`waitForTransaction timed-out with retries ${this.retries}`);
+        }
+      }
+      retries -= 1;
+      await (0, _provider.wait)(retryInterval);
+    }
+    return txReceipt;
+  }
+  getStorageAt(contractAddress, key, blockIdentifier = this.blockIdentifier) {
+    const contract_address = (0, _num.toHex)(contractAddress);
+    const parsedKey = (0, _num.toStorageKey)(key);
+    const block_id = new _provider.Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getStorageAt", {
+      contract_address,
+      key: parsedKey,
+      block_id
+    });
+  }
+  getClassHashAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+    const contract_address = (0, _num.toHex)(contractAddress);
+    const block_id = new _provider.Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getClassHashAt", {
+      block_id,
+      contract_address
+    });
+  }
+  getClass(classHash, blockIdentifier = this.blockIdentifier) {
+    const class_hash = (0, _num.toHex)(classHash);
+    const block_id = new _provider.Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getClass", {
+      class_hash,
+      block_id
+    });
+  }
+  getClassAt(contractAddress, blockIdentifier = this.blockIdentifier) {
+    const contract_address = (0, _num.toHex)(contractAddress);
+    const block_id = new _provider.Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_getClassAt", {
+      block_id,
+      contract_address
+    });
+  }
+  async getEstimateFee(invocations, {
+    blockIdentifier = this.blockIdentifier,
+    skipValidate = true
+  }) {
+    const block_id = new _provider.Block(blockIdentifier).identifier;
+    let flags = {};
+    if (!(0, _provider.isVersion)("0.5", await this.getSpecVersion())) {
+      flags = {
+        simulation_flags: skipValidate ? [_api.RPCSPEC07.ESimulationFlag.SKIP_VALIDATE] : []
+      };
+    }
+    return this.fetchEndpoint("starknet_estimateFee", {
+      request: invocations.map(it => this.buildTransaction(it, "fee")),
+      block_id,
+      ...flags
+    });
+  }
+  async invoke(functionInvocation, details) {
+    let promise;
+    if (!(0, _provider.isV3Tx)(details)) {
+      promise = this.fetchEndpoint("starknet_addInvokeTransaction", {
+        invoke_transaction: {
+          sender_address: functionInvocation.contractAddress,
+          calldata: _calldata.CallData.toHex(functionInvocation.calldata),
+          type: _api.RPCSPEC07.ETransactionType.INVOKE,
+          max_fee: (0, _num.toHex)(details.maxFee || 0),
+          version: _api.RPCSPEC07.ETransactionVersion.V1,
+          signature: (0, _stark.signatureToHexArray)(functionInvocation.signature),
+          nonce: (0, _num.toHex)(details.nonce)
+        }
+      });
+    } else {
+      promise = this.fetchEndpoint("starknet_addInvokeTransaction", {
+        invoke_transaction: {
+          type: _api.RPCSPEC07.ETransactionType.INVOKE,
+          sender_address: functionInvocation.contractAddress,
+          calldata: _calldata.CallData.toHex(functionInvocation.calldata),
+          version: _api.RPCSPEC07.ETransactionVersion.V3,
+          signature: (0, _stark.signatureToHexArray)(functionInvocation.signature),
+          nonce: (0, _num.toHex)(details.nonce),
+          resource_bounds: details.resourceBounds,
+          tip: (0, _num.toHex)(details.tip),
+          paymaster_data: details.paymasterData.map(it => (0, _num.toHex)(it)),
+          account_deployment_data: details.accountDeploymentData.map(it => (0, _num.toHex)(it)),
+          nonce_data_availability_mode: details.nonceDataAvailabilityMode,
+          fee_data_availability_mode: details.feeDataAvailabilityMode
+        }
+      });
+    }
+    return this.waitMode ? this.waitForTransaction((await promise).transaction_hash) : promise;
+  }
+  async declare({
+    contract,
+    signature,
+    senderAddress,
+    compiledClassHash
+  }, details) {
+    let promise;
+    if (!(0, _contract.isSierra)(contract) && !(0, _provider.isV3Tx)(details)) {
+      promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
+        declare_transaction: {
+          type: _api.RPCSPEC07.ETransactionType.DECLARE,
+          contract_class: {
+            program: contract.program,
+            entry_points_by_type: contract.entry_points_by_type,
+            abi: contract.abi
+          },
+          version: _api.RPCSPEC07.ETransactionVersion.V1,
+          max_fee: (0, _num.toHex)(details.maxFee || 0),
+          signature: (0, _stark.signatureToHexArray)(signature),
+          sender_address: senderAddress,
+          nonce: (0, _num.toHex)(details.nonce)
+        }
+      });
+    } else if ((0, _contract.isSierra)(contract) && !(0, _provider.isV3Tx)(details)) {
+      promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
+        declare_transaction: {
+          type: _api.RPCSPEC07.ETransactionType.DECLARE,
+          contract_class: {
+            sierra_program: (0, _stark.decompressProgram)(contract.sierra_program),
+            contract_class_version: contract.contract_class_version,
+            entry_points_by_type: contract.entry_points_by_type,
+            abi: contract.abi
+          },
+          compiled_class_hash: compiledClassHash || "",
+          version: _api.RPCSPEC07.ETransactionVersion.V2,
+          max_fee: (0, _num.toHex)(details.maxFee || 0),
+          signature: (0, _stark.signatureToHexArray)(signature),
+          sender_address: senderAddress,
+          nonce: (0, _num.toHex)(details.nonce)
+        }
+      });
+    } else if ((0, _contract.isSierra)(contract) && (0, _provider.isV3Tx)(details)) {
+      promise = this.fetchEndpoint("starknet_addDeclareTransaction", {
+        declare_transaction: {
+          type: _api.RPCSPEC07.ETransactionType.DECLARE,
+          sender_address: senderAddress,
+          compiled_class_hash: compiledClassHash || "",
+          version: _api.RPCSPEC07.ETransactionVersion.V3,
+          signature: (0, _stark.signatureToHexArray)(signature),
+          nonce: (0, _num.toHex)(details.nonce),
+          contract_class: {
+            sierra_program: (0, _stark.decompressProgram)(contract.sierra_program),
+            contract_class_version: contract.contract_class_version,
+            entry_points_by_type: contract.entry_points_by_type,
+            abi: contract.abi
+          },
+          resource_bounds: details.resourceBounds,
+          tip: (0, _num.toHex)(details.tip),
+          paymaster_data: details.paymasterData.map(it => (0, _num.toHex)(it)),
+          account_deployment_data: details.accountDeploymentData.map(it => (0, _num.toHex)(it)),
+          nonce_data_availability_mode: details.nonceDataAvailabilityMode,
+          fee_data_availability_mode: details.feeDataAvailabilityMode
+        }
+      });
+    } else {
+      throw Error("declare unspotted parameters");
+    }
+    return this.waitMode ? this.waitForTransaction((await promise).transaction_hash) : promise;
+  }
+  async deployAccount({
+    classHash,
+    constructorCalldata,
+    addressSalt,
+    signature
+  }, details) {
+    let promise;
+    if (!(0, _provider.isV3Tx)(details)) {
+      promise = this.fetchEndpoint("starknet_addDeployAccountTransaction", {
+        deploy_account_transaction: {
+          constructor_calldata: _calldata.CallData.toHex(constructorCalldata || []),
+          class_hash: (0, _num.toHex)(classHash),
+          contract_address_salt: (0, _num.toHex)(addressSalt || 0),
+          type: _api.RPCSPEC07.ETransactionType.DEPLOY_ACCOUNT,
+          max_fee: (0, _num.toHex)(details.maxFee || 0),
+          version: _api.RPCSPEC07.ETransactionVersion.V1,
+          signature: (0, _stark.signatureToHexArray)(signature),
+          nonce: (0, _num.toHex)(details.nonce)
+        }
+      });
+    } else {
+      promise = this.fetchEndpoint("starknet_addDeployAccountTransaction", {
+        deploy_account_transaction: {
+          type: _api.RPCSPEC07.ETransactionType.DEPLOY_ACCOUNT,
+          version: _api.RPCSPEC07.ETransactionVersion.V3,
+          signature: (0, _stark.signatureToHexArray)(signature),
+          nonce: (0, _num.toHex)(details.nonce),
+          contract_address_salt: (0, _num.toHex)(addressSalt || 0),
+          constructor_calldata: _calldata.CallData.toHex(constructorCalldata || []),
+          class_hash: (0, _num.toHex)(classHash),
+          resource_bounds: details.resourceBounds,
+          tip: (0, _num.toHex)(details.tip),
+          paymaster_data: details.paymasterData.map(it => (0, _num.toHex)(it)),
+          nonce_data_availability_mode: details.nonceDataAvailabilityMode,
+          fee_data_availability_mode: details.feeDataAvailabilityMode
+        }
+      });
+    }
+    return this.waitMode ? this.waitForTransaction((await promise).transaction_hash) : promise;
+  }
+  callContract(call, blockIdentifier = this.blockIdentifier) {
+    const block_id = new _provider.Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_call", {
+      request: {
+        contract_address: call.contractAddress,
+        entry_point_selector: (0, _hash.getSelectorFromName)(call.entrypoint),
+        calldata: _calldata.CallData.toHex(call.calldata)
+      },
+      block_id
+    });
+  }
+  /**
+   * NEW: Estimate the fee for a message from L1
+   * @param message Message From L1
+   */
+  estimateMessageFee(message, blockIdentifier = this.blockIdentifier) {
+    const {
+      from_address,
+      to_address,
+      entry_point_selector,
+      payload
+    } = message;
+    const formattedMessage = {
+      from_address: (0, _eth.validateAndParseEthAddress)(from_address),
+      to_address: (0, _num.toHex)(to_address),
+      entry_point_selector: (0, _hash.getSelector)(entry_point_selector),
+      payload: (0, _num.getHexStringArray)(payload)
+    };
+    const block_id = new _provider.Block(blockIdentifier).identifier;
+    return this.fetchEndpoint("starknet_estimateMessageFee", {
+      message: formattedMessage,
+      block_id
+    });
+  }
+  /**
+   * Returns an object about the sync status, or false if the node is not synching
+   * @returns Object with the stats data
+   */
+  getSyncingStats() {
+    return this.fetchEndpoint("starknet_syncing");
+  }
+  /**
+   * Returns all events matching the given filter
+   * @returns events and the pagination of the events
+   */
+  getEvents(eventFilter) {
+    return this.fetchEndpoint("starknet_getEvents", {
+      filter: eventFilter
+    });
+  }
+  buildTransaction(invocation, versionType) {
+    const defaultVersions = (0, _transaction.getVersionsByType)(versionType);
+    let details;
+    if (!(0, _provider.isV3Tx)(invocation)) {
+      details = {
+        signature: (0, _stark.signatureToHexArray)(invocation.signature),
+        nonce: (0, _num.toHex)(invocation.nonce),
+        max_fee: (0, _num.toHex)(invocation.maxFee || 0)
+      };
+    } else {
+      details = {
+        signature: (0, _stark.signatureToHexArray)(invocation.signature),
+        nonce: (0, _num.toHex)(invocation.nonce),
+        resource_bounds: invocation.resourceBounds,
+        tip: (0, _num.toHex)(invocation.tip),
+        paymaster_data: invocation.paymasterData.map(it => (0, _num.toHex)(it)),
+        nonce_data_availability_mode: invocation.nonceDataAvailabilityMode,
+        fee_data_availability_mode: invocation.feeDataAvailabilityMode,
+        account_deployment_data: invocation.accountDeploymentData.map(it => (0, _num.toHex)(it))
+      };
+    }
+    if (invocation.type === _types.TransactionType.INVOKE) {
+      return {
+        // v0 v1 v3
+        type: _api.RPCSPEC07.ETransactionType.INVOKE,
+        sender_address: invocation.contractAddress,
+        calldata: _calldata.CallData.toHex(invocation.calldata),
+        version: (0, _num.toHex)(invocation.version || defaultVersions.v3),
+        ...details
+      };
+    }
+    if (invocation.type === _types.TransactionType.DECLARE) {
+      if (!(0, _contract.isSierra)(invocation.contract)) {
+        return {
+          type: invocation.type,
+          contract_class: invocation.contract,
+          sender_address: invocation.senderAddress,
+          version: (0, _num.toHex)(invocation.version || defaultVersions.v1),
+          ...details
+        };
+      }
+      return {
+        // Cairo 1 - v2 v3
+        type: invocation.type,
+        contract_class: {
+          ...invocation.contract,
+          sierra_program: (0, _stark.decompressProgram)(invocation.contract.sierra_program)
+        },
+        compiled_class_hash: invocation.compiledClassHash || "",
+        sender_address: invocation.senderAddress,
+        version: (0, _num.toHex)(invocation.version || defaultVersions.v3),
+        ...details
+      };
+    }
+    if (invocation.type === _types.TransactionType.DEPLOY_ACCOUNT) {
+      const {
+        account_deployment_data,
+        ...restDetails
+      } = details;
+      return {
+        type: invocation.type,
+        constructor_calldata: _calldata.CallData.toHex(invocation.constructorCalldata || []),
+        class_hash: (0, _num.toHex)(invocation.classHash),
+        contract_address_salt: (0, _num.toHex)(invocation.addressSalt || 0),
+        version: (0, _num.toHex)(invocation.version || defaultVersions.v3),
+        ...restDetails
+      };
+    }
+    throw Error("RPC buildTransaction received unknown TransactionType");
+  }
+}
+exports.RpcChannel = RpcChannel;

package/dist/channel/rpc_0_7.d.ts

@@ -0,0 +1,81 @@
+import { StarknetChainId } from '../constants';
+import { AccountInvocationItem, AccountInvocations, BigNumberish, BlockIdentifier, Call, DeclareContractTransaction, DeployAccountContractTransaction, Invocation, InvocationsDetailsWithNonce, RpcProviderOptions, getEstimateFeeBulkOptions, getSimulateTransactionOptions, waitForTransactionOptions } from '../types';
+import { JRPC, RPCSPEC07 as RPC } from '../types/api';
+export declare class RpcChannel {
+    nodeUrl: string;
+    headers: object;
+    readonly retries: number;
+    requestId: number;
+    readonly blockIdentifier: BlockIdentifier;
+    private chainId?;
+    private specVersion?;
+    private transactionRetryIntervalFallback?;
+    readonly waitMode: Boolean;
+    constructor(optionsOrProvider?: RpcProviderOptions);
+    private get transactionRetryIntervalDefault();
+    setChainId(chainId: StarknetChainId): void;
+    fetch(method: string, params?: object, id?: string | number): any;
+    protected errorHandler(method: string, params: any, rpcError?: JRPC.Error, otherError?: any): void;
+    protected fetchEndpoint<T extends keyof RPC.Methods>(method: T, params?: RPC.Methods[T]['params']): Promise<RPC.Methods[T]['result']>;
+    getChainId(): Promise<"0x534e5f4d41494e" | "0x534e5f5345504f4c4941">;
+    getSpecVersion(): Promise<string>;
+    getNonceForAddress(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<string>;
+    /**
+     * Get the most recent accepted block hash and number
+     */
+    getBlockLatestAccepted(): Promise<RPC.BlockHashAndNumber>;
+    /**
+     * Get the most recent accepted block number
+     * redundant use getBlockLatestAccepted();
+     * @returns Number of the latest block
+     */
+    getBlockNumber(): Promise<number>;
+    getBlockWithTxHashes(blockIdentifier?: BlockIdentifier): Promise<RPC.BlockWithTxHashes>;
+    getBlockWithTxs(blockIdentifier?: BlockIdentifier): Promise<RPC.BlockWithTxs>;
+    getBlockWithReceipts(blockIdentifier?: BlockIdentifier): Promise<RPC.BlockWithTxReceipts>;
+    getBlockStateUpdate(blockIdentifier?: BlockIdentifier): Promise<RPC.StateUpdate>;
+    getBlockTransactionsTraces(blockIdentifier?: BlockIdentifier): Promise<RPC.BlockTransactionsTraces>;
+    getBlockTransactionCount(blockIdentifier?: BlockIdentifier): Promise<number>;
+    getTransactionByHash(txHash: BigNumberish): Promise<RPC.TransactionWithHash>;
+    getTransactionByBlockIdAndIndex(blockIdentifier: BlockIdentifier, index: number): Promise<RPC.TransactionWithHash>;
+    getTransactionReceipt(txHash: BigNumberish): Promise<RPC.API.SPEC.TXN_RECEIPT_WITH_BLOCK_INFO>;
+    getTransactionTrace(txHash: BigNumberish): Promise<RPC.API.SPEC.TRANSACTION_TRACE>;
+    /**
+     * Get the status of a transaction
+     */
+    getTransactionStatus(transactionHash: BigNumberish): Promise<RPC.TransactionStatus>;
+    /**
+     * @param invocations AccountInvocations
+     * @param simulateTransactionOptions blockIdentifier and flags to skip validation and fee charge<br/>
+     * - blockIdentifier<br/>
+     * - skipValidate (default false)<br/>
+     * - skipFeeCharge (default true)<br/>
+     */
+    simulateTransaction(invocations: AccountInvocations, simulateTransactionOptions?: getSimulateTransactionOptions): Promise<RPC.SimulateTransactionResponse>;
+    waitForTransaction(txHash: BigNumberish, options?: waitForTransactionOptions): Promise<RPC.API.SPEC.TXN_RECEIPT>;
+    getStorageAt(contractAddress: BigNumberish, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<string>;
+    getClassHashAt(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<string>;
+    getClass(classHash: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<RPC.ContractClass>;
+    getClassAt(contractAddress: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<RPC.ContractClass>;
+    getEstimateFee(invocations: AccountInvocations, { blockIdentifier, skipValidate }: getEstimateFeeBulkOptions): Promise<RPC.API.SPEC.FEE_ESTIMATE[]>;
+    invoke(functionInvocation: Invocation, details: InvocationsDetailsWithNonce): Promise<any>;
+    declare({ contract, signature, senderAddress, compiledClassHash }: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<any>;
+    deployAccount({ classHash, constructorCalldata, addressSalt, signature }: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce): Promise<any>;
+    callContract(call: Call, blockIdentifier?: BlockIdentifier): Promise<string[]>;
+    /**
+     * NEW: Estimate the fee for a message from L1
+     * @param message Message From L1
+     */
+    estimateMessageFee(message: RPC.L1Message, blockIdentifier?: BlockIdentifier): Promise<RPC.API.SPEC.FEE_ESTIMATE>;
+    /**
+     * Returns an object about the sync status, or false if the node is not synching
+     * @returns Object with the stats data
+     */
+    getSyncingStats(): Promise<RPC.Syncing>;
+    /**
+     * Returns all events matching the given filter
+     * @returns events and the pagination of the events
+     */
+    getEvents(eventFilter: RPC.EventFilter): Promise<RPC.API.SPEC.EVENTS_CHUNK>;
+    buildTransaction(invocation: AccountInvocationItem, versionType?: 'fee' | 'transaction'): RPC.BaseTransaction;
+}