starknet 6.9.0 → 6.10.1

package/dist/utils/provider.d.ts

@@ -0,0 +1,217 @@
+import { NetworkName } from '../constants';
+import { BlockIdentifier, CompiledContract, CompiledSierra, ContractClass, GetBlockResponse, InvocationsDetailsWithNonce, PendingBlock, PendingStateUpdate, SierraContractClass, StateUpdateResponse, V3TransactionDetails } from '../types';
+import type { GetTransactionReceiptResponse } from './transactionReceipt';
+/**
+ * Helper - Async Sleep for 'delay' time
+ *
+ * @param {number} delay - Number of milliseconds to delay
+ * @returns {Promise<unknown>}
+ * @example
+ * ```typescript
+ * await provider.wait(1000) // 1000 milliseconds == 1 second
+ * ```
+ */
+export declare function wait(delay: number): Promise<unknown>;
+/**
+ * Create Sierra compressed Contract Class from a given Compiled Sierra
+ *
+ * CompiledSierra -> SierraContractClass
+ *
+ * @param {CompiledSierra} contract sierra code from the Cairo compiler
+ * @returns {SierraContractClass} compressed Sierra
+ * @example
+ * ```typescript
+ * const result = provider.createSierraContractClass({
+    "sierra_program": [
+        "0x1",
+        "0x4",
+        "0x0",
+        "0x2",
+        "0x4",
+        "0x1",
+        "0x3b4",
+        "0x4c",
+        "0x65",
+        "0x52616e6765436865636b",...})
+ * // result = {sierra_program: 'H4sIAAAAAAAAA6x9WZbsrI7uVGqd53qgb8ZynwzYY7jDv5JAAmxHZuQ+96yq/L0jIzEINZ8axP/5j/q/+j//+z/wH9f/o/p/zPbh+Iot49+u9v8G3//rTdDhDDF4Z0MKPthQ+m+S2v6n1S//638VvdXW2PQ6RvxuDG+jiybCXKJ7Hef6ZRi9E+Q89WmKLilfqbrsL6PUCf8...}
+ * ```
+ */
+export declare function createSierraContractClass(contract: CompiledSierra): SierraContractClass;
+/**
+ * Create a compressed contract from a given compiled Cairo 0 & 1 contract or a string.
+ * @param {CompiledContract | string} contract - Compiled Cairo 0 or Cairo 1 contract, or string
+ * @returns {ContractClass} Cairo 0 or Cairo 1 compressed contract
+ * @example
+ * ```typescript
+ * const result = provider.parseContract({
+    "sierra_program": [
+        "0x1",
+        "0x4",
+        "0x0",
+        "0x2",
+        "0x4",
+        "0x1",
+        "0x3b4",
+        "0x4c",
+        "0x65",
+        "0x52616e6765436865636b",...})
+ * // result = {sierra_program: 'H4sIAAAAAAAAA6x9WZbsrI7uVGqd53qgb8ZynwzYY7jDv5JAAmxHZuQ+96yq/L0jIzEINZ8axP/5j/q/+j//+z/wH9f/o/p/zPbh+Iot49+u9v8G3//rTdDhDDF4Z0MKPthQ+m+S2v6n1S//638VvdXW2PQ6RvxuDG+jiybCXKJ7Hef6ZRi9E+Q89WmKLilfqbrsL6PUCf8...}
+ * ```
+ */
+export declare function parseContract(contract: CompiledContract | string): ContractClass;
+/**
+ * Return randomly select available public node
+ * @param {NetworkName} networkName NetworkName
+ * @param {boolean} mute mute public node warning
+ * @returns {string} default node url
+ * @example
+ * ```typescript
+ * const result= provider.getDefaultNodeUrl(constants.NetworkName.SN_MAIN,false);
+ * // console : "Using default public node url, please provide nodeUrl in provider options!"
+ * // result = "https://starknet-mainnet.public.blastapi.io/rpc/v0_7"
+ * ```
+ */
+export declare const getDefaultNodeUrl: (networkName?: NetworkName, mute?: boolean) => string;
+export declare const validBlockTags: ("latest" | "pending")[];
+/**
+ * This class is formatting the identifier of a block.
+ *
+ * hex string and BigInt are detected as block hashes. identifier return { block_hash: hash }
+ *
+ * decimal string and number are detected as block numbers. identifier return { block_number: number }
+ *
+ * text string are detected as block tag. identifier return tag
+ *
+ * null is detected as 'pending' block tag. identifier return 'pending'
+ * @example
+ * ```typescript
+ * const result = new provider.Block(null).identifier;
+ * // result = "pending"
+ * ```
+ */
+export declare class Block {
+    /**
+     * @param {BlockIdentifier} hash if not null, contains the block hash
+     */
+    hash: BlockIdentifier;
+    /**
+     * @param {BlockIdentifier} number if not null, contains the block number
+     */
+    number: BlockIdentifier;
+    /**
+     * @param {BlockIdentifier} tag if not null, contains "pending" or "latest"
+     */
+    tag: BlockIdentifier;
+    private setIdentifier;
+    /**
+     * Create a Block instance
+     * @param {BlockIdentifier} _identifier  hex string and BigInt are detected as block hashes.
+     * decimal string and number are detected as block numbers.
+     * text string are detected as block tag.
+     * null is considered as a 'pending' block tag.
+     */
+    constructor(_identifier: BlockIdentifier);
+    /**
+     * @returns {any} the identifier as a string
+     * @example
+     * ```typescript
+     * const result = new provider.Block(123456n).queryIdentifier;
+     * // result = "blockHash=0x1e240"
+     * ```
+     */
+    get queryIdentifier(): any;
+    /**
+     * @returns {any} the identifier as an object
+     * @example
+     * ```typescript
+     * const result = new provider.Block(56789).identifier;
+     * // result = { block_number: 56789 }
+     * ```
+     */
+    get identifier(): any;
+    /**
+     * change the identifier of an existing Block instance
+     * @example
+     * ```typescript
+     * const myBlock = new provider.Block("latest");
+     * myBlock.identifier ="0x3456789abc";
+     * const result = myBlock.identifier;
+     * // result = { block_hash: '0x3456789abc' }
+     * ```
+     */
+    set identifier(_identifier: BlockIdentifier);
+    valueOf: () => BlockIdentifier;
+    toString: () => BlockIdentifier;
+}
+/**
+ * Check if the given transaction details is a V3 transaction.
+ *
+ * @param {InvocationsDetailsWithNonce} details The transaction details to be checked.
+ * @return {boolean} Returns true if the transaction is a V3 transaction, otherwise false.
+ * @example
+ * ```typescript
+ * const invocation: InvocationsDetailsWithNonce = {
+ *   nonce: 1,
+ *   version: 3,
+ *   maxFee: 10 ** 15,
+ *   feeDataAvailabilityMode: RPC.EDataAvailabilityMode.L1,
+ *   tip: 10 ** 13,
+ *   paymasterData: [],
+ *   resourceBounds: {
+ *       l1_gas: { max_amount: num.toHex(10 ** 14), max_price_per_unit: num.toHex(50) },
+ *       l2_gas: { max_amount: num.toHex(0), max_price_per_unit: num.toHex(0) }}};
+ * const result = provider.isV3Tx(invocation);
+ * // result = true
+ * ```
+ */
+export declare function isV3Tx(details: InvocationsDetailsWithNonce): details is V3TransactionDetails;
+/**
+ * Determines if the given response matches the specified version.
+ *
+ * @param {('0.5' | '0.6' | '0.7')} version The version to compare against the response.
+ * @param {string} response The response to check against the version.
+ * @returns {boolean} True if the response matches the version, false otherwise.
+ * @example
+ * ``` typescript
+ * const result = provider.isVersion("0.7","0_7");
+ * // result = false
+ * ```
+ */
+export declare function isVersion(version: '0.5' | '0.6' | '0.7', response: string): boolean;
+/**
+ * Guard Pending Block
+ * @param {GetBlockResponse} response answer of myProvider.getBlock()
+ * @return {boolean} true if block is the pending block
+ * @example
+ * ```typescript
+ * const block = await myProvider.getBlock("pending");
+ * const result = provider.isPendingBlock(block);
+ * // result = true
+ * ```
+ */
+export declare function isPendingBlock(response: GetBlockResponse): response is PendingBlock;
+/**
+ * Guard Pending Transaction
+ * @param {GetTransactionReceiptResponse} response transaction Receipt
+ * @return {boolean} true if the transaction is part of the pending block
+ * @example
+ * ```typescript
+ * const block = await myProvider.getBlockWithTxs("pending");
+ * const txR = await myProvider.getTransactionReceipt(block.transactions[0].transaction_hash);
+ * const result = provider.isPendingTransaction(txR);
+ * // result = true
+ * ```
+ */
+export declare function isPendingTransaction(response: GetTransactionReceiptResponse): boolean;
+/**
+ * Guard Pending State Update
+ * @param {StateUpdateResponse} response State of a block
+ * @return {boolean} true if the block is pending
+ * @example
+ * ```typescript
+ * const state: StateUpdateResponse = await myProvider.getStateUpdate("pending");
+ * const result = provider.isPendingStateUpdate(state);
+ * // result = true
+ * ```
+ */
+export declare function isPendingStateUpdate(response: StateUpdateResponse): response is PendingStateUpdate;

package/dist/utils/provider.mjs

@@ -0,0 +1,158 @@
+import { NetworkName, RPC_NODES } from "../constants.mjs";
+import {
+  BlockTag
+} from "../types/index.mjs";
+import { ETransactionVersion } from "../types/api/index.mjs";
+import { isSierra } from "./contract.mjs";
+import { formatSpaces } from "./hash/index.mjs";
+import { parse, stringify } from "./json.mjs";
+import { isBigInt, isHex, isNumber, toHex } from "./num.mjs";
+import { isDecimalString, isString } from "./shortString.mjs";
+import { compressProgram } from "./stark.mjs";
+export function wait(delay) {
+  return new Promise((res) => {
+    setTimeout(res, delay);
+  });
+}
+export function createSierraContractClass(contract) {
+  const result = { ...contract };
+  delete result.sierra_program_debug_info;
+  result.abi = formatSpaces(stringify(contract.abi));
+  result.sierra_program = formatSpaces(stringify(contract.sierra_program));
+  result.sierra_program = compressProgram(result.sierra_program);
+  return result;
+}
+export function parseContract(contract) {
+  const parsedContract = isString(contract) ? parse(contract) : contract;
+  if (!isSierra(contract)) {
+    return {
+      ...parsedContract,
+      ..."program" in parsedContract && { program: compressProgram(parsedContract.program) }
+    };
+  }
+  return createSierraContractClass(parsedContract);
+}
+export const getDefaultNodeUrl = (networkName, mute = false) => {
+  if (!mute) {
+    console.warn("Using default public node url, please provide nodeUrl in provider options!");
+  }
+  const nodes = RPC_NODES[networkName ?? NetworkName.SN_SEPOLIA];
+  const randIdx = Math.floor(Math.random() * nodes.length);
+  return nodes[randIdx];
+};
+export const validBlockTags = Object.values(BlockTag);
+export class Block {
+  /**
+   * @param {BlockIdentifier} hash if not null, contains the block hash
+   */
+  hash = null;
+  /**
+   * @param {BlockIdentifier} number if not null, contains the block number
+   */
+  number = null;
+  /**
+   * @param {BlockIdentifier} tag if not null, contains "pending" or "latest"
+   */
+  tag = null;
+  setIdentifier(__identifier) {
+    if (isString(__identifier)) {
+      if (isDecimalString(__identifier)) {
+        this.number = parseInt(__identifier, 10);
+      } else if (isHex(__identifier)) {
+        this.hash = __identifier;
+      } else if (validBlockTags.includes(__identifier)) {
+        this.tag = __identifier;
+      } else {
+        throw TypeError(`Block identifier unmanaged: ${__identifier}`);
+      }
+    } else if (isBigInt(__identifier)) {
+      this.hash = toHex(__identifier);
+    } else if (isNumber(__identifier)) {
+      this.number = __identifier;
+    } else {
+      this.tag = BlockTag.PENDING;
+    }
+    if (isNumber(this.number) && this.number < 0) {
+      throw TypeError(`Block number (${this.number}) can't be negative`);
+    }
+  }
+  /**
+   * Create a Block instance
+   * @param {BlockIdentifier} _identifier  hex string and BigInt are detected as block hashes.
+   * decimal string and number are detected as block numbers.
+   * text string are detected as block tag.
+   * null is considered as a 'pending' block tag.
+   */
+  constructor(_identifier) {
+    this.setIdentifier(_identifier);
+  }
+  // TODO: fix any
+  /**
+   * @returns {any} the identifier as a string
+   * @example
+   * ```typescript
+   * const result = new provider.Block(123456n).queryIdentifier;
+   * // result = "blockHash=0x1e240"
+   * ```
+   */
+  get queryIdentifier() {
+    if (this.number !== null) {
+      return `blockNumber=${this.number}`;
+    }
+    if (this.hash !== null) {
+      return `blockHash=${this.hash}`;
+    }
+    return `blockNumber=${this.tag}`;
+  }
+  // TODO: fix any
+  /**
+   * @returns {any} the identifier as an object
+   * @example
+   * ```typescript
+   * const result = new provider.Block(56789).identifier;
+   * // result = { block_number: 56789 }
+   * ```
+   */
+  get identifier() {
+    if (this.number !== null) {
+      return { block_number: this.number };
+    }
+    if (this.hash !== null) {
+      return { block_hash: this.hash };
+    }
+    return this.tag;
+  }
+  /**
+   * change the identifier of an existing Block instance
+   * @example
+   * ```typescript
+   * const myBlock = new provider.Block("latest");
+   * myBlock.identifier ="0x3456789abc";
+   * const result = myBlock.identifier;
+   * // result = { block_hash: '0x3456789abc' }
+   * ```
+   */
+  set identifier(_identifier) {
+    this.setIdentifier(_identifier);
+  }
+  valueOf = () => this.number;
+  toString = () => this.hash;
+}
+export function isV3Tx(details) {
+  const version = details.version ? toHex(details.version) : ETransactionVersion.V3;
+  return version === ETransactionVersion.V3 || version === ETransactionVersion.F3;
+}
+export function isVersion(version, response) {
+  const [majorS, minorS] = version.split(".");
+  const [majorR, minorR] = response.split(".");
+  return majorS === majorR && minorS === minorR;
+}
+export function isPendingBlock(response) {
+  return response.status === "PENDING";
+}
+export function isPendingTransaction(response) {
+  return !("block_hash" in response);
+}
+export function isPendingStateUpdate(response) {
+  return !("block_hash" in response);
+}

package/dist/utils/responseParser/index.cjs

@@ -0,0 +1,27 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _interface = require("./interface.cjs");
+Object.keys(_interface).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _interface[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _interface[key];
+    }
+  });
+});
+var _rpc = require("./rpc.cjs");
+Object.keys(_rpc).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _rpc[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _rpc[key];
+    }
+  });
+});

package/dist/utils/responseParser/index.d.ts

@@ -0,0 +1,2 @@
+export * from './interface';
+export * from './rpc';

package/dist/utils/responseParser/index.mjs

@@ -0,0 +1,2 @@
+export * from "./interface.mjs";
+export * from "./rpc.mjs";

package/dist/utils/responseParser/interface.cjs

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ResponseParser = void 0;
+class ResponseParser {}
+exports.ResponseParser = ResponseParser;

package/dist/utils/responseParser/interface.d.ts

@@ -0,0 +1,13 @@
+import { BlockWithTxHashes, FeeEstimate, CallContractResponse, DeclareContractResponse, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetTransactionResponse, InvokeFunctionResponse, SimulateTransactionResponse } from '../../types';
+import type { GetTransactionReceiptResponse } from '../transactionReceipt';
+export declare abstract class ResponseParser {
+    abstract parseGetBlockResponse(res: BlockWithTxHashes): GetBlockResponse;
+    abstract parseGetTransactionResponse(res: any): GetTransactionResponse;
+    abstract parseGetTransactionReceiptResponse(res: any): GetTransactionReceiptResponse;
+    abstract parseFeeEstimateResponse(res: FeeEstimate[]): EstimateFeeResponse;
+    abstract parseCallContractResponse(res: any): CallContractResponse;
+    abstract parseInvokeFunctionResponse(res: any): InvokeFunctionResponse;
+    abstract parseDeployContractResponse(res: any): DeployContractResponse;
+    abstract parseDeclareContractResponse(res: any): DeclareContractResponse;
+    abstract parseSimulateTransactionResponse(res: any): SimulateTransactionResponse;
+}

package/dist/utils/responseParser/interface.mjs

@@ -0,0 +1,2 @@
+export class ResponseParser {
+}

package/dist/utils/responseParser/rpc.cjs

@@ -0,0 +1,83 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.RPCResponseParser = void 0;
+var _num = require("../num.cjs");
+var _shortString = require("../shortString.cjs");
+var _stark = require("../stark.cjs");
+class RPCResponseParser {
+  margin;
+  constructor(margin) {
+    this.margin = margin;
+  }
+  estimatedFeeToMaxFee(estimatedFee) {
+    return (0, _stark.estimatedFeeToMaxFee)(estimatedFee, this.margin?.maxFee);
+  }
+  estimateFeeToBounds(estimate) {
+    return (0, _stark.estimateFeeToBounds)(estimate, this.margin?.l1BoundMaxAmount, this.margin?.l1BoundMaxPricePerUnit);
+  }
+  parseGetBlockResponse(res) {
+    return {
+      status: "PENDING",
+      ...res
+    };
+  }
+  parseTransactionReceipt(res) {
+    if ("actual_fee" in res && (0, _shortString.isString)(res.actual_fee)) {
+      return {
+        ...res,
+        actual_fee: {
+          amount: res.actual_fee,
+          unit: "FRI"
+        }
+      };
+    }
+    return res;
+  }
+  parseFeeEstimateResponse(res) {
+    const val = res[0];
+    return {
+      overall_fee: (0, _num.toBigInt)(val.overall_fee),
+      gas_consumed: (0, _num.toBigInt)(val.gas_consumed),
+      gas_price: (0, _num.toBigInt)(val.gas_price),
+      unit: val.unit,
+      suggestedMaxFee: this.estimatedFeeToMaxFee(val.overall_fee),
+      resourceBounds: this.estimateFeeToBounds(val),
+      data_gas_consumed: val.data_gas_consumed ? (0, _num.toBigInt)(val.data_gas_consumed) : 0n,
+      data_gas_price: val.data_gas_price ? (0, _num.toBigInt)(val.data_gas_price) : 0n
+    };
+  }
+  parseFeeEstimateBulkResponse(res) {
+    return res.map(val => ({
+      overall_fee: (0, _num.toBigInt)(val.overall_fee),
+      gas_consumed: (0, _num.toBigInt)(val.gas_consumed),
+      gas_price: (0, _num.toBigInt)(val.gas_price),
+      unit: val.unit,
+      suggestedMaxFee: this.estimatedFeeToMaxFee(val.overall_fee),
+      resourceBounds: this.estimateFeeToBounds(val),
+      data_gas_consumed: val.data_gas_consumed ? (0, _num.toBigInt)(val.data_gas_consumed) : 0n,
+      data_gas_price: val.data_gas_price ? (0, _num.toBigInt)(val.data_gas_price) : 0n
+    }));
+  }
+  parseSimulateTransactionResponse(res) {
+    return res.map(it => {
+      return {
+        ...it,
+        suggestedMaxFee: this.estimatedFeeToMaxFee(it.fee_estimation.overall_fee),
+        resourceBounds: this.estimateFeeToBounds(it.fee_estimation)
+      };
+    });
+  }
+  parseContractClassResponse(res) {
+    return {
+      ...res,
+      abi: (0, _shortString.isString)(res.abi) ? JSON.parse(res.abi) : res.abi
+    };
+  }
+  parseL1GasPriceResponse(res) {
+    return res.l1_gas_price.price_in_wei;
+  }
+}
+exports.RPCResponseParser = RPCResponseParser;

package/dist/utils/responseParser/rpc.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Map RPC Response to common interface response
+ * Intersection (sequencer response ∩ (∪ rpc responses))
+ */
+import type { BlockWithTxHashes, ContractClassPayload, ContractClassResponse, EstimateFeeResponse, EstimateFeeResponseBulk, FeeEstimate, GetBlockResponse, GetTxReceiptResponseWithoutHelper, RpcProviderOptions, SimulateTransactionResponse, TransactionReceipt } from '../../types/provider';
+import { ResponseParser } from './interface';
+export declare class RPCResponseParser implements Omit<ResponseParser, 'parseDeclareContractResponse' | 'parseDeployContractResponse' | 'parseInvokeFunctionResponse' | 'parseGetTransactionReceiptResponse' | 'parseGetTransactionResponse' | 'parseCallContractResponse'> {
+    private margin;
+    constructor(margin?: RpcProviderOptions['feeMarginPercentage']);
+    private estimatedFeeToMaxFee;
+    private estimateFeeToBounds;
+    parseGetBlockResponse(res: BlockWithTxHashes): GetBlockResponse;
+    parseTransactionReceipt(res: TransactionReceipt): GetTxReceiptResponseWithoutHelper;
+    parseFeeEstimateResponse(res: FeeEstimate[]): EstimateFeeResponse;
+    parseFeeEstimateBulkResponse(res: FeeEstimate[]): EstimateFeeResponseBulk;
+    parseSimulateTransactionResponse(res: any): SimulateTransactionResponse;
+    parseContractClassResponse(res: ContractClassPayload): ContractClassResponse;
+    parseL1GasPriceResponse(res: BlockWithTxHashes): string;
+}

package/dist/utils/responseParser/rpc.mjs

@@ -0,0 +1,77 @@
+import { toBigInt } from "../num.mjs";
+import { isString } from "../shortString.mjs";
+import { estimateFeeToBounds, estimatedFeeToMaxFee } from "../stark.mjs";
+export class RPCResponseParser {
+  margin;
+  constructor(margin) {
+    this.margin = margin;
+  }
+  estimatedFeeToMaxFee(estimatedFee) {
+    return estimatedFeeToMaxFee(estimatedFee, this.margin?.maxFee);
+  }
+  estimateFeeToBounds(estimate) {
+    return estimateFeeToBounds(
+      estimate,
+      this.margin?.l1BoundMaxAmount,
+      this.margin?.l1BoundMaxPricePerUnit
+    );
+  }
+  parseGetBlockResponse(res) {
+    return { status: "PENDING", ...res };
+  }
+  parseTransactionReceipt(res) {
+    if ("actual_fee" in res && isString(res.actual_fee)) {
+      return {
+        ...res,
+        actual_fee: {
+          amount: res.actual_fee,
+          unit: "FRI"
+        }
+      };
+    }
+    return res;
+  }
+  parseFeeEstimateResponse(res) {
+    const val = res[0];
+    return {
+      overall_fee: toBigInt(val.overall_fee),
+      gas_consumed: toBigInt(val.gas_consumed),
+      gas_price: toBigInt(val.gas_price),
+      unit: val.unit,
+      suggestedMaxFee: this.estimatedFeeToMaxFee(val.overall_fee),
+      resourceBounds: this.estimateFeeToBounds(val),
+      data_gas_consumed: val.data_gas_consumed ? toBigInt(val.data_gas_consumed) : 0n,
+      data_gas_price: val.data_gas_price ? toBigInt(val.data_gas_price) : 0n
+    };
+  }
+  parseFeeEstimateBulkResponse(res) {
+    return res.map((val) => ({
+      overall_fee: toBigInt(val.overall_fee),
+      gas_consumed: toBigInt(val.gas_consumed),
+      gas_price: toBigInt(val.gas_price),
+      unit: val.unit,
+      suggestedMaxFee: this.estimatedFeeToMaxFee(val.overall_fee),
+      resourceBounds: this.estimateFeeToBounds(val),
+      data_gas_consumed: val.data_gas_consumed ? toBigInt(val.data_gas_consumed) : 0n,
+      data_gas_price: val.data_gas_price ? toBigInt(val.data_gas_price) : 0n
+    }));
+  }
+  parseSimulateTransactionResponse(res) {
+    return res.map((it) => {
+      return {
+        ...it,
+        suggestedMaxFee: this.estimatedFeeToMaxFee(it.fee_estimation.overall_fee),
+        resourceBounds: this.estimateFeeToBounds(it.fee_estimation)
+      };
+    });
+  }
+  parseContractClassResponse(res) {
+    return {
+      ...res,
+      abi: isString(res.abi) ? JSON.parse(res.abi) : res.abi
+    };
+  }
+  parseL1GasPriceResponse(res) {
+    return res.l1_gas_price.price_in_wei;
+  }
+}

package/dist/utils/shortString.cjs

@@ -0,0 +1,56 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.decodeShortString = decodeShortString;
+exports.encodeShortString = encodeShortString;
+exports.isASCII = isASCII;
+exports.isDecimalString = isDecimalString;
+exports.isLongText = void 0;
+exports.isShortString = isShortString;
+exports.isShortText = void 0;
+exports.isString = isString;
+exports.isText = isText;
+exports.splitLongString = splitLongString;
+var _constants = require("../constants.cjs");
+var _encode = require("./encode.cjs");
+var _num = require("./num.cjs");
+function isASCII(str) {
+  return /^[\x00-\x7F]*$/.test(str);
+}
+function isShortString(str) {
+  return str.length <= _constants.TEXT_TO_FELT_MAX_LEN;
+}
+function isDecimalString(str) {
+  return /^[0-9]*$/i.test(str);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isText(val) {
+  return isString(val) && !(0, _num.isHex)(val) && !(0, _num.isStringWholeNumber)(val);
+}
+const isShortText = val => isText(val) && isShortString(val);
+exports.isShortText = isShortText;
+const isLongText = val => isText(val) && !isShortString(val);
+exports.isLongText = isLongText;
+function splitLongString(longStr) {
+  const regex = RegExp(`[^]{1,${_constants.TEXT_TO_FELT_MAX_LEN}}`, "g");
+  return longStr.match(regex) || [];
+}
+function encodeShortString(str) {
+  if (!isASCII(str)) throw new Error(`${str} is not an ASCII string`);
+  if (!isShortString(str)) throw new Error(`${str} is too long`);
+  return (0, _encode.addHexPrefix)(str.replace(/./g, char => char.charCodeAt(0).toString(16)));
+}
+function decodeShortString(str) {
+  if (!isASCII(str)) throw new Error(`${str} is not an ASCII string`);
+  if ((0, _num.isHex)(str)) {
+    return (0, _encode.removeHexPrefix)(str).replace(/.{2}/g, hex => String.fromCharCode(parseInt(hex, 16)));
+  }
+  if (isDecimalString(str)) {
+    return decodeShortString("0X".concat(BigInt(str).toString(16)));
+  }
+  throw new Error(`${str} is not Hex or decimal`);
+}