starknet 3.1.0 → 3.2.0

package/src/account/default.ts

@@ -3,13 +3,15 @@ import { Signer, SignerInterface } from '../signer';
 import {
   Abi,
   AddTransactionResponse,
-  ExecuteInvocation,
+  Call,
   InvocationsDetails,
   KeyPair,
   Signature,
 } from '../types';
+import { getSelectorFromName } from '../utils/hash';
 import { BigNumberish, bigNumberishArrayToDecimalStringArray, toBN, toHex } from '../utils/number';
-import { compileCalldata, getSelectorFromName } from '../utils/stark';
+import { compileCalldata } from '../utils/stark';
+import { fromCallsToExecuteCalldata } from '../utils/transaction';
 import { TypedData, getMessageHash } from '../utils/typedData';
 import { AccountInterface } from './interface';
 
@@ -41,51 +43,28 @@ export class Account extends Provider implements AccountInterface {
    * @returns a confirmation of invoking a function on the starknet contract
    */
   public async execute(
-    transactions: ExecuteInvocation | ExecuteInvocation[],
-    abis: Abi[] = [],
+    calls: Call | Call[],
+    abis: Abi[] | undefined = undefined,
     transactionsDetail: InvocationsDetails = {}
   ): Promise<AddTransactionResponse> {
-    if (Array.isArray(transactions) && transactions.length !== 1) {
-      throw new Error('Only one transaction at a time is currently supported');
-    }
-
-    const {
-      contractAddress,
-      calldata = [],
-      entrypoint,
-      ...invocation
-    } = Array.isArray(transactions) ? transactions[0] : transactions;
-    const { nonce } = transactionsDetail;
+    const transactions = Array.isArray(calls) ? calls : [calls];
 
-    const nonceBn = toBN(nonce ?? (await this.getNonce()));
-    const calldataDecimal = bigNumberishArrayToDecimalStringArray(calldata);
+    const signerDetails = {
+      walletAddress: this.address,
+      nonce: toBN(transactionsDetail.nonce ?? (await this.getNonce())),
+      maxFee: toBN(transactionsDetail.maxFee ?? '0'),
+    };
 
-    const signature = await this.signer.signTransaction(
-      [
-        {
-          ...invocation,
-          contractAddress,
-          calldata: calldataDecimal,
-          entrypoint,
-        },
-      ],
-      { walletAddress: this.address, nonce: nonceBn },
-      abis
-    );
+    const signature = await this.signer.signTransaction(transactions, signerDetails, abis);
 
-    const entrypointSelector = getSelectorFromName(entrypoint);
+    const calldata = [...fromCallsToExecuteCalldata(transactions), signerDetails.nonce.toString()];
 
-    return super.invokeFunction({
-      contractAddress: this.address,
-      entrypoint: 'execute',
-      calldata: [
-        contractAddress,
-        entrypointSelector,
-        calldataDecimal.length.toString(),
-        ...calldataDecimal,
-        nonceBn.toString(),
-      ],
-      signature,
+    return this.fetchEndpoint('add_transaction', undefined, {
+      type: 'INVOKE_FUNCTION',
+      contract_address: this.address,
+      entry_point_selector: getSelectorFromName('__execute__'),
+      calldata,
+      signature: bigNumberishArrayToDecimalStringArray(signature),
     });
   }
 
@@ -114,7 +93,7 @@ export class Account extends Provider implements AccountInterface {
   /**
    * Verify a signature of a JSON object
    *
-   * @param json - JSON object to be verified
+   * @param hash - JSON object to be verified
    * @param signature - signature of the JSON object
    * @returns true if the signature is valid, false otherwise
    * @throws {Error} if the JSON object is not a valid JSON or the signature is not a valid signature

package/src/account/interface.ts

@@ -2,8 +2,8 @@ import { ProviderInterface } from '../provider';
 import {
   Abi,
   AddTransactionResponse,
+  Call,
   DeployContractPayload,
-  ExecuteInvocation,
   InvocationsDetails,
   Signature,
 } from '../types';
@@ -41,7 +41,7 @@ export abstract class AccountInterface extends ProviderInterface {
    * @returns response from addTransaction
    */
   public abstract execute(
-    transactions: ExecuteInvocation | ExecuteInvocation[],
+    transactions: Call | Call[],
     abis?: Abi[],
     transactionsDetail?: InvocationsDetails
   ): Promise<AddTransactionResponse>;

package/src/index.ts

@@ -5,6 +5,7 @@ export * from './types';
 export * from './contract';
 export * from './provider';
 export * from './account';
+export * from './signer';
 
 /**
  * Utils

package/src/provider/default.ts

@@ -17,21 +17,16 @@ import {
   Invocation,
   TransactionReceipt,
 } from '../types';
+import { getSelectorFromName } from '../utils/hash';
 import { parse, stringify } from '../utils/json';
 import { BigNumberish, bigNumberishArrayToDecimalStringArray, toBN, toHex } from '../utils/number';
-import { compressProgram, getSelectorFromName, randomAddress } from '../utils/stark';
+import { compressProgram, randomAddress } from '../utils/stark';
 import { ProviderInterface } from './interface';
 import { BlockIdentifier, getFormattedBlockIdentifier, txIdentifier } from './utils';
 
 type NetworkName = 'mainnet-alpha' | 'goerli-alpha';
 
-type ProviderOptions =
-  | {
-      network: NetworkName;
-    }
-  | {
-      baseUrl: string;
-    };
+type ProviderOptions = { network: NetworkName } | { baseUrl: string };
 
 function wait(delay: number) {
   return new Promise((res) => setTimeout(res, delay));
@@ -133,14 +128,21 @@ export class Provider implements ProviderInterface {
     const queryString = this.getQueryString(query);
     const headers = this.getHeaders(method);
 
-    const { data } = await axios.request<Endpoints[T]['RESPONSE']>({
-      method,
-      url: urljoin(baseUrl, endpoint, queryString),
-      data: stringify(request),
-      headers,
-    });
-
-    return data;
+    try {
+      const { data } = await axios.request<Endpoints[T]['RESPONSE']>({
+        method,
+        url: urljoin(baseUrl, endpoint, queryString),
+        data: stringify(request),
+        headers,
+      });
+      return data;
+    } catch (error: any) {
+      const data = error?.response?.data;
+      if (data?.message) {
+        throw new Error(`${data.code}: ${data.message}`);
+      }
+      throw error;
+    }
   }
 
   /**
@@ -344,7 +346,10 @@ export class Provider implements ProviderInterface {
       if (res.tx_status === 'ACCEPTED_ON_L1' || res.tx_status === 'ACCEPTED_ON_L2') {
         onchain = true;
       } else if (res.tx_status === 'REJECTED' || res.tx_status === 'NOT_RECEIVED') {
-        const error = Error(res.tx_status) as Error & { response: GetTransactionStatusResponse };
+        const message = res.tx_failure_reason
+          ? `${res.tx_status}: ${res.tx_failure_reason.code}\n${res.tx_failure_reason.error_message}`
+          : res.tx_status;
+        const error = new Error(message) as Error & { response: GetTransactionStatusResponse };
         error.response = res;
         throw error;
       }

package/src/signer/default.ts

@@ -1,9 +1,6 @@
 import { Abi, Invocation, InvocationsSignerDetails, KeyPair, Signature } from '../types';
 import { getStarkKey, sign } from '../utils/ellipticCurve';
-import { addHexPrefix } from '../utils/encode';
-import { hashMessage } from '../utils/hash';
-import { bigNumberishArrayToDecimalStringArray, toBN } from '../utils/number';
-import { getSelectorFromName } from '../utils/stark';
+import { hashMulticall } from '../utils/hash';
 import { TypedData, getMessageHash } from '../utils/typedData';
 import { SignerInterface } from './interface';
 
@@ -21,38 +18,25 @@ export class Signer implements SignerInterface {
   public async signTransaction(
     transactions: Invocation[],
     transactionsDetail: InvocationsSignerDetails,
-    abis: Abi[] = []
+    abis?: Abi[]
   ): Promise<Signature> {
-    if (transactions.length !== 1) {
-      throw new Error('Only one transaction at a time is currently supported by this signer');
-    }
-    if (abis?.length !== 0 && abis.length !== transactions.length) {
+    if (abis && abis.length !== transactions.length) {
       throw new Error('ABI must be provided for each transaction or no transaction');
     }
     // now use abi to display decoded data somewhere, but as this signer is headless, we can't do that
 
-    const { contractAddress, entrypoint, calldata = [] } = transactions[0];
-    const { nonce, walletAddress } = transactionsDetail;
-
-    const nonceBn = toBN(nonce);
-    const entrypointSelector = getSelectorFromName(entrypoint);
-    const calldataDecimal = bigNumberishArrayToDecimalStringArray(calldata);
-
-    const msgHash = addHexPrefix(
-      hashMessage(
-        walletAddress,
-        contractAddress,
-        entrypointSelector,
-        calldataDecimal,
-        nonceBn.toString()
-      )
+    const msgHash = hashMulticall(
+      transactionsDetail.walletAddress,
+      transactions,
+      transactionsDetail.nonce.toString(),
+      transactionsDetail.maxFee.toString()
     );
 
     return sign(this.keyPair, msgHash);
   }
 
-  public async signMessage(typedData: TypedData, walletAddress: string): Promise<Signature> {
-    const msgHash = getMessageHash(typedData, walletAddress);
+  public async signMessage(typedData: TypedData, accountAddress: string): Promise<Signature> {
+    const msgHash = getMessageHash(typedData, accountAddress);
     return sign(this.keyPair, msgHash);
   }
 }

package/src/signer/interface.ts

@@ -13,11 +13,12 @@ export abstract class SignerInterface {
    * Sign an JSON object for off-chain usage with the starknet private key and return the signature
    * This adds a message prefix so it cant be interchanged with transactions
    *
-   * @param json - JSON object to be signed
+   * @param typedData - JSON object to be signed
+   * @param accountAddress - account
    * @returns the signature of the JSON object
    * @throws {Error} if the JSON object is not a valid JSON
    */
-  public abstract signMessage(typedData: TypedData, walletAddress: string): Promise<Signature>;
+  public abstract signMessage(typedData: TypedData, accountAddress: string): Promise<Signature>;
 
   /**
    * Signs a transaction with the starknet private key and returns the signature

package/src/types/api.ts

@@ -137,6 +137,11 @@ export type GetCodeResponse = {
 export type GetTransactionStatusResponse = {
   tx_status: Status;
   block_hash: string;
+  tx_failure_reason?: {
+    tx_id: number;
+    code: string;
+    error_message: string;
+  };
 };
 
 export type GetTransactionResponse = {

package/src/types/lib.ts

@@ -3,7 +3,7 @@ import type { ec as EC } from 'elliptic';
 import type { BigNumberish } from '../utils/number';
 
 export type KeyPair = EC.KeyPair;
-export type Signature = BigNumberish[];
+export type Signature = string[];
 export type RawCalldata = BigNumberish[];
 
 export type DeployContractPayload = {
@@ -19,14 +19,13 @@ export type Invocation = {
   signature?: Signature;
 };
 
-export type ExecuteInvocation = Omit<Invocation, 'signature'>;
+export type Call = Omit<Invocation, 'signature'>;
 
 export type InvocationsDetails = {
   nonce?: BigNumberish;
+  maxFee?: BigNumberish;
 };
 
-export type Call = Omit<Invocation, 'signature' | 'nonce'>;
-
 export type Status =
   | 'NOT_RECEIVED'
   | 'RECEIVED'

package/src/utils/ellipticCurve.ts

@@ -80,7 +80,7 @@ export function sign(keyPair: KeyPair, msgHash: string): Signature {
   assertInRange(r, ONE, toBN(addHexPrefix(MAX_ECDSA_VAL)), 'r');
   assertInRange(s, ONE, toBN(addHexPrefix(EC_ORDER)), 's');
   assertInRange(w, ONE, toBN(addHexPrefix(MAX_ECDSA_VAL)), 'w');
-  return [r, s];
+  return [r.toString(), s.toString()];
 }
 
 function chunkArray(arr: any[], n: number): any[][] {

package/src/utils/hash.ts

@@ -3,9 +3,14 @@ import { keccak256 } from 'ethereum-cryptography/keccak';
 import assert from 'minimalistic-assert';
 
 import { CONSTANT_POINTS, FIELD_PRIME, MASK_250, ONE, ZERO } from '../constants';
+import { Call } from '../types';
 import { ec } from './ellipticCurve';
 import { addHexPrefix, buf2hex, utf8ToArray } from './encode';
-import { BigNumberish, toBN } from './number';
+import { BigNumberish, bigNumberishArrayToDecimalStringArray, toBN, toHex } from './number';
+import { encodeShortString } from './shortString';
+
+export const transactionPrefix = encodeShortString('StarkNet Transaction');
+export const transactionVersion = 0;
 
 function keccakHex(value: string): string {
   return addHexPrefix(buf2hex(keccak256(utf8ToArray(value))));
@@ -22,6 +27,18 @@ export function starknetKeccak(value: string): BN {
   return toBN(keccakHex(value)).and(MASK_250);
 }
 
+/**
+ * Function to get the hex selector from a given function name
+ *
+ * [Reference](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/public/abi.py#L25-L26)
+ * @param funcName - selectors abi function name
+ * @returns hex selector of given abi function name
+ */
+export function getSelectorFromName(funcName: string) {
+  // sometimes BigInteger pads the hex string with zeros, which isnt allowed in the starknet api
+  return toHex(starknetKeccak(funcName));
+}
+
 const constantPoints = CONSTANT_POINTS.map((coords: string[]) =>
   ec.curve.point(coords[0], coords[1])
 );
@@ -47,17 +64,27 @@ export function computeHashOnElements(data: BigNumberish[]) {
   return [...data, data.length].reduce((x, y) => pedersen([x, y]), 0).toString();
 }
 
-export function hashCalldata(calldata: string[]): string {
-  return computeHashOnElements(calldata);
-}
-
-export function hashMessage(
+export function hashMulticall(
   account: string,
-  to: string,
-  selector: string,
-  calldata: string[],
-  nonce: string
+  transactions: Call[],
+  nonce: string,
+  maxFee: string
 ) {
-  const calldataHash = hashCalldata(calldata);
-  return computeHashOnElements([account, to, selector, calldataHash, nonce]);
+  const hashArray = transactions
+    .map(({ contractAddress, entrypoint, calldata }) => [
+      contractAddress,
+      getSelectorFromName(entrypoint),
+      computeHashOnElements(calldata || []),
+    ])
+    .map(bigNumberishArrayToDecimalStringArray)
+    .map(computeHashOnElements);
+
+  return computeHashOnElements([
+    transactionPrefix,
+    account,
+    computeHashOnElements(hashArray),
+    nonce,
+    maxFee,
+    transactionVersion,
+  ]);
 }

package/src/utils/stark.ts

@@ -3,9 +3,8 @@ import { gzip } from 'pako';
 import { Calldata, CompressedProgram, Program, RawArgs, Signature } from '../types';
 import { genKeyPair, getStarkKey } from './ellipticCurve';
 import { addHexPrefix, btoaUniversal } from './encode';
-import { starknetKeccak } from './hash';
 import { stringify } from './json';
-import { toBN, toHex } from './number';
+import { toBN } from './number';
 
 /**
  * Function to compress compiled cairo program
@@ -20,18 +19,6 @@ export function compressProgram(jsonProgram: Program | string): CompressedProgra
   return btoaUniversal(compressedProgram);
 }
 
-/**
- * Function to get the hex selector from a given function name
- *
- * [Reference](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/public/abi.py#L25-L26)
- * @param funcName - selectors abi function name
- * @returns hex selector of given abi function name
- */
-export function getSelectorFromName(funcName: string) {
-  // sometimes BigInteger pads the hex string with zeros, which isnt allowed in the starknet api
-  return toHex(starknetKeccak(funcName));
-}
-
 export function randomAddress(): string {
   const randomKeyPair = genKeyPair();
   return getStarkKey(randomKeyPair);

package/src/utils/transaction.ts

@@ -0,0 +1,50 @@
+import { ParsedStruct } from '../contract';
+import { Call } from '../types';
+import { getSelectorFromName } from './hash';
+import { BigNumberish, bigNumberishArrayToDecimalStringArray, toBN } from './number';
+
+/**
+ * Transforms a list of Calls, each with their own calldata, into
+ * two arrays: one with the entrypoints, and one with the concatenated calldata.
+ * @param calls
+ * @returns
+ */
+export const transformCallsToMulticallArrays = (calls: Call[]) => {
+  const callArray: ParsedStruct[] = [];
+  const calldata: BigNumberish[] = [];
+  calls.forEach((call) => {
+    const data = call.calldata || [];
+    callArray.push({
+      to: toBN(call.contractAddress).toString(10),
+      selector: toBN(getSelectorFromName(call.entrypoint)).toString(10),
+      data_offset: calldata.length.toString(),
+      data_len: data.length.toString(),
+    });
+    calldata.push(...data);
+  });
+  return {
+    callArray,
+    calldata: bigNumberishArrayToDecimalStringArray(calldata),
+  };
+};
+
+/**
+ * Transforms a list of calls in the full flattened calldata expected
+ * by the __execute__ protocol.
+ * @param calls
+ * @returns
+ */
+export const fromCallsToExecuteCalldata = (calls: Call[]): string[] => {
+  const { callArray, calldata } = transformCallsToMulticallArrays(calls);
+  return [
+    callArray.length.toString(),
+    ...callArray
+      .map(
+        ({ to, selector, data_offset, data_len }) =>
+          [to, selector, data_offset, data_len] as string[]
+      )
+      .flat(),
+    calldata.length.toString(),
+    ...calldata,
+  ];
+};

package/src/utils/typedData/index.ts

@@ -1,7 +1,6 @@
-import { computeHashOnElements } from '../hash';
+import { computeHashOnElements, getSelectorFromName } from '../hash';
 import { BigNumberish, toBN, toHex } from '../number';
 import { encodeShortString } from '../shortString';
-import { getSelectorFromName } from '../stark';
 import { TypedData } from './types';
 import { validateTypedData } from './utils';
 
@@ -161,7 +160,7 @@ export const getStructHash = <T extends TypedData>(
  * with Keccak256.
  *
  * @param {TypedData} typedData
- * @param {boolean} hash
+ * @param {BigNumberish} account
  * @return {string}
  */
 export const getMessageHash = (typedData: TypedData, account: BigNumberish): string => {

package/types/api.d.ts

@@ -127,6 +127,11 @@ export declare type GetCodeResponse = {
 export declare type GetTransactionStatusResponse = {
   tx_status: Status;
   block_hash: string;
+  tx_failure_reason?: {
+    tx_id: number;
+    code: string;
+    error_message: string;
+  };
 };
 export declare type GetTransactionResponse = {
   status: Status;

package/types/lib.d.ts

@@ -2,7 +2,7 @@ import type { ec as EC } from 'elliptic';
 
 import type { BigNumberish } from '../utils/number';
 export declare type KeyPair = EC.KeyPair;
-export declare type Signature = BigNumberish[];
+export declare type Signature = string[];
 export declare type RawCalldata = BigNumberish[];
 export declare type DeployContractPayload = {
   contract: CompiledContract | string;
@@ -15,11 +15,11 @@ export declare type Invocation = {
   calldata?: RawCalldata;
   signature?: Signature;
 };
-export declare type ExecuteInvocation = Omit<Invocation, 'signature'>;
+export declare type Call = Omit<Invocation, 'signature'>;
 export declare type InvocationsDetails = {
   nonce?: BigNumberish;
+  maxFee?: BigNumberish;
 };
-export declare type Call = Omit<Invocation, 'signature' | 'nonce'>;
 export declare type Status =
   | 'NOT_RECEIVED'
   | 'RECEIVED'

package/utils/ellipticCurve.js

@@ -136,7 +136,7 @@ function sign(keyPair, msgHash) {
     (0, number_1.toBN)((0, encode_1.addHexPrefix)(constants_1.MAX_ECDSA_VAL)),
     'w'
   );
-  return [r, s];
+  return [r.toString(), s.toString()];
 }
 exports.sign = sign;
 function chunkArray(arr, n) {

package/utils/hash.d.ts

@@ -1,6 +1,9 @@
 import BN from 'bn.js';
 
+import { Call } from '../types';
 import { BigNumberish } from './number';
+export declare const transactionPrefix: string;
+export declare const transactionVersion = 0;
 /**
  * Function to get the starknet keccak hash from a string
  *
@@ -9,13 +12,19 @@ import { BigNumberish } from './number';
  * @returns starknet keccak hash as BigNumber
  */
 export declare function starknetKeccak(value: string): BN;
+/**
+ * Function to get the hex selector from a given function name
+ *
+ * [Reference](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/public/abi.py#L25-L26)
+ * @param funcName - selectors abi function name
+ * @returns hex selector of given abi function name
+ */
+export declare function getSelectorFromName(funcName: string): string;
 export declare function pedersen(input: [BigNumberish, BigNumberish]): string;
 export declare function computeHashOnElements(data: BigNumberish[]): string;
-export declare function hashCalldata(calldata: string[]): string;
-export declare function hashMessage(
+export declare function hashMulticall(
   account: string,
-  to: string,
-  selector: string,
-  calldata: string[],
-  nonce: string
+  transactions: Call[],
+  nonce: string,
+  maxFee: string
 ): string;

package/utils/hash.js

@@ -39,11 +39,13 @@ var __importDefault =
     return mod && mod.__esModule ? mod : { default: mod };
   };
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.hashMessage =
-  exports.hashCalldata =
+exports.hashMulticall =
   exports.computeHashOnElements =
   exports.pedersen =
+  exports.getSelectorFromName =
   exports.starknetKeccak =
+  exports.transactionVersion =
+  exports.transactionPrefix =
     void 0;
 var keccak_1 = require('ethereum-cryptography/keccak');
 var minimalistic_assert_1 = __importDefault(require('minimalistic-assert'));
@@ -51,6 +53,9 @@ var constants_1 = require('../constants');
 var ellipticCurve_1 = require('./ellipticCurve');
 var encode_1 = require('./encode');
 var number_1 = require('./number');
+var shortString_1 = require('./shortString');
+exports.transactionPrefix = (0, shortString_1.encodeShortString)('StarkNet Transaction');
+exports.transactionVersion = 0;
 function keccakHex(value) {
   return (0, encode_1.addHexPrefix)(
     (0, encode_1.buf2hex)((0, keccak_1.keccak256)((0, encode_1.utf8ToArray)(value)))
@@ -67,6 +72,18 @@ function starknetKeccak(value) {
   return (0, number_1.toBN)(keccakHex(value)).and(constants_1.MASK_250);
 }
 exports.starknetKeccak = starknetKeccak;
+/**
+ * Function to get the hex selector from a given function name
+ *
+ * [Reference](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/public/abi.py#L25-L26)
+ * @param funcName - selectors abi function name
+ * @returns hex selector of given abi function name
+ */
+function getSelectorFromName(funcName) {
+  // sometimes BigInteger pads the hex string with zeros, which isnt allowed in the starknet api
+  return (0, number_1.toHex)(starknetKeccak(funcName));
+}
+exports.getSelectorFromName = getSelectorFromName;
 var constantPoints = constants_1.CONSTANT_POINTS.map(function (coords) {
   return ellipticCurve_1.ec.curve.point(coords[0], coords[1]);
 });
@@ -99,12 +116,27 @@ function computeHashOnElements(data) {
     .toString();
 }
 exports.computeHashOnElements = computeHashOnElements;
-function hashCalldata(calldata) {
-  return computeHashOnElements(calldata);
-}
-exports.hashCalldata = hashCalldata;
-function hashMessage(account, to, selector, calldata, nonce) {
-  var calldataHash = hashCalldata(calldata);
-  return computeHashOnElements([account, to, selector, calldataHash, nonce]);
+function hashMulticall(account, transactions, nonce, maxFee) {
+  var hashArray = transactions
+    .map(function (_a) {
+      var contractAddress = _a.contractAddress,
+        entrypoint = _a.entrypoint,
+        calldata = _a.calldata;
+      return [
+        contractAddress,
+        getSelectorFromName(entrypoint),
+        computeHashOnElements(calldata || []),
+      ];
+    })
+    .map(number_1.bigNumberishArrayToDecimalStringArray)
+    .map(computeHashOnElements);
+  return computeHashOnElements([
+    exports.transactionPrefix,
+    account,
+    computeHashOnElements(hashArray),
+    nonce,
+    maxFee,
+    exports.transactionVersion,
+  ]);
 }
-exports.hashMessage = hashMessage;
+exports.hashMulticall = hashMulticall;

package/utils/stark.d.ts

@@ -7,14 +7,6 @@ import { Calldata, CompressedProgram, Program, RawArgs, Signature } from '../typ
  * @returns Compressed cairo program
  */
 export declare function compressProgram(jsonProgram: Program | string): CompressedProgram;
-/**
- * Function to get the hex selector from a given function name
- *
- * [Reference](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/public/abi.py#L25-L26)
- * @param funcName - selectors abi function name
- * @returns hex selector of given abi function name
- */
-export declare function getSelectorFromName(funcName: string): string;
 export declare function randomAddress(): string;
 export declare function makeAddress(input: string): string;
 export declare function formatSignature(sig?: Signature): string[];