starknet 3.18.0 → 3.19.0

package/__tests__/defaultProvider.test.ts

@@ -0,0 +1,321 @@
+import {
+  BlockNumber,
+  DeclareContractResponse,
+  DeployContractResponse,
+  GetBlockResponse,
+  stark,
+} from '../src';
+import { toBN } from '../src/utils/number';
+import {
+  compiledErc20,
+  compiledOpenZeppelinAccount,
+  describeIfNotDevnet,
+  getTestProvider,
+} from './fixtures';
+
+const { compileCalldata } = stark;
+
+const testProvider = getTestProvider();
+
+describe('defaultProvider', () => {
+  let exampleTransactionHash: string;
+  let exampleContractAddress: string;
+
+  let exampleBlock: GetBlockResponse;
+  let exampleBlockNumber: BlockNumber;
+  let exampleBlockHash: string;
+
+  beforeAll(async () => {
+    const { transaction_hash, contract_address } = await testProvider.deployContract({
+      contract: compiledErc20,
+    });
+    await testProvider.waitForTransaction(transaction_hash);
+    exampleTransactionHash = transaction_hash;
+    exampleContractAddress = contract_address;
+
+    exampleBlock = await testProvider.getBlock('latest');
+    exampleBlockHash = exampleBlock.block_hash;
+    exampleBlockNumber = exampleBlock.block_number;
+  });
+
+  describe('endpoints', () => {
+    test(`getBlock(blockHash=undefined, blockNumber=${exampleBlockNumber})`, () => {
+      return expect(testProvider.getBlock(exampleBlockNumber)).resolves.not.toThrow();
+    });
+
+    test(`getBlock(blockHash=${exampleBlockHash}, blockNumber=undefined)`, () => {
+      return expect(testProvider.getBlock(exampleBlockHash)).resolves.not.toThrow();
+    });
+
+    test('getBlock(blockIdentifier=latest)', async () => {
+      expect(exampleBlock).not.toBeNull();
+
+      const { block_number, accepted_time } = exampleBlock;
+
+      expect(typeof block_number).toEqual('number');
+
+      return expect(typeof accepted_time).toEqual('number');
+    });
+
+    test('getBlock() -> { blockNumber }', async () => {
+      const block = await testProvider.getBlock();
+      return expect(block).toHaveProperty('block_number');
+    });
+
+    describe('getStorageAt', () => {
+      test('with "key" type of number', () => {
+        return expect(testProvider.getStorageAt(exampleContractAddress, 0)).resolves.not.toThrow();
+      });
+
+      test('"key" type of string', () => {
+        return expect(
+          testProvider.getStorageAt(exampleContractAddress, '0x0')
+        ).resolves.not.toThrow();
+      });
+
+      test('with "key" type of BN', () => {
+        return expect(
+          testProvider.getStorageAt(exampleContractAddress, toBN('0x0'))
+        ).resolves.not.toThrow();
+      });
+    });
+
+    test('getTransaction() - successful transaction', async () => {
+      const transaction = await testProvider.getTransaction(exampleTransactionHash);
+
+      expect(transaction).toHaveProperty('transaction_hash');
+    });
+
+    test('getTransactionReceipt() - successful transaction', async () => {
+      const transactionReceipt = await testProvider.getTransactionReceipt(exampleTransactionHash);
+
+      return expect(transactionReceipt).toHaveProperty('actual_fee');
+    });
+
+    test('callContract()', () => {
+      return expect(
+        testProvider.callContract({
+          contractAddress: exampleContractAddress,
+          entrypoint: 'balance_of',
+          calldata: compileCalldata({
+            user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
+          }),
+        })
+      ).resolves.not.toThrow();
+    });
+
+    test('callContract() - gateway error', async () => {
+      return expect(
+        testProvider.callContract({
+          contractAddress: exampleContractAddress,
+          entrypoint: 'non_existent_entrypoint',
+          calldata: compileCalldata({
+            user: '0xdeadbeef',
+          }),
+        })
+      ).rejects.toThrowError();
+    });
+  });
+
+  describe('addTransaction()', () => {
+    test('declareContract()', async () => {
+      const response = await testProvider.declareContract({
+        contract: compiledErc20,
+      });
+
+      expect(response.transaction_hash).toBeDefined();
+      expect(response.class_hash).toBeDefined();
+    });
+
+    test('deployContract()', async () => {
+      const response = await testProvider.deployContract({
+        contract: compiledOpenZeppelinAccount,
+      });
+
+      expect(response.transaction_hash).toBeDefined();
+      expect(response.contract_address).toBeDefined();
+    });
+  });
+
+  describeIfNotDevnet('Provider', () => {
+    const provider = getTestProvider();
+    describe(`Provider methods`, () => {
+      describe('getBlock', () => {
+        test('pending', async () => {
+          const latestBlock = await provider.getBlock();
+          expect(latestBlock).toHaveProperty('block_hash');
+          expect(latestBlock).toHaveProperty('parent_hash');
+          expect(latestBlock).toHaveProperty('block_number');
+          expect(latestBlock).toHaveProperty('status');
+          expect(latestBlock).toHaveProperty('sequencer');
+          expect(latestBlock).toHaveProperty('new_root');
+          expect(latestBlock).toHaveProperty('old_root');
+          expect(latestBlock).toHaveProperty('accepted_time');
+          expect(latestBlock).toHaveProperty('gas_price');
+          expect(latestBlock).toHaveProperty('transactions');
+          expect(Array.isArray(latestBlock.transactions)).toBe(true);
+        });
+
+        test('Block Hash 0x8a30a1212d142cb0053fe9921e1dbf64f651d328565bd2e7ac24059c270f43', async () => {
+          const block = await provider.getBlock(
+            '0x8a30a1212d142cb0053fe9921e1dbf64f651d328565bd2e7ac24059c270f43'
+          );
+
+          expect(block).toHaveProperty('block_hash');
+          expect(block).toHaveProperty('parent_hash');
+          expect(block).toHaveProperty('block_number');
+          expect(block).toHaveProperty('status');
+          expect(block).toHaveProperty('sequencer');
+          expect(block).toHaveProperty('new_root');
+          expect(block).toHaveProperty('old_root');
+          expect(block).toHaveProperty('accepted_time');
+          expect(block).toHaveProperty('gas_price');
+          expect(block).toHaveProperty('transactions');
+          expect(Array.isArray(block.transactions)).toBe(true);
+        });
+
+        test('Block Number 102634', async () => {
+          const block = await provider.getBlock(102634);
+          expect(block).toHaveProperty('block_hash');
+          expect(block).toHaveProperty('parent_hash');
+          expect(block).toHaveProperty('block_number');
+          expect(block).toHaveProperty('status');
+          expect(block).toHaveProperty('sequencer');
+          expect(block).toHaveProperty('new_root');
+          expect(block).toHaveProperty('old_root');
+          expect(block).toHaveProperty('accepted_time');
+          expect(block).toHaveProperty('gas_price');
+          expect(block).toHaveProperty('transactions');
+          expect(Array.isArray(block.transactions)).toBe(true);
+        });
+      });
+
+      describe('getStorageAt', () => {
+        test('pending', async () => {
+          const storage = await provider.getStorageAt(
+            '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
+            0
+          );
+          expect(typeof storage).toBe('string');
+        });
+
+        test('Block Hash 0x7104702055c2a5773a870ceada9552ec659d69c18053b14078983f07527dea8', async () => {
+          const storage = await provider.getStorageAt(
+            '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
+            0,
+            '0x7225762c7ff5e7e5f0867f0a8e73594df4f44f05a65375339a76398e8ae3e64'
+          );
+          expect(typeof storage).toBe('string');
+        });
+      });
+
+      describe('getTransaction', () => {
+        test('Deploy Transaction Hash 0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348', async () => {
+          const transaction = await provider.getTransaction(
+            '0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348'
+          );
+
+          expect(transaction.transaction_hash).toBeTruthy();
+          expect(transaction.contract_address).toBeTruthy();
+        });
+
+        test('Invoke Transaction Hash 0x2a56c636f45761c99a67ecdf0f185a6d5fe5239924ed9a4886fddbfaf3227b', async () => {
+          const transaction = await provider.getTransaction(
+            '0x2a56c636f45761c99a67ecdf0f185a6d5fe5239924ed9a4886fddbfaf3227b'
+          );
+
+          expect(transaction.transaction_hash).toBeTruthy();
+          expect(transaction.contract_address).toBeTruthy();
+          expect(Array.isArray(transaction.calldata)).toBe(true);
+          expect(transaction.entry_point_selector).toBeTruthy();
+          expect(Array.isArray(transaction.signature)).toBe(true);
+          expect(transaction.max_fee).toBeTruthy();
+        });
+
+        test('Declare Transaction Hash 0x79b130f2e808db6ab4b83f0182f016a128d73752b849e5b0221c2b3a35a87ea', async () => {
+          const transaction = await provider.getTransaction(
+            '0x79b130f2e808db6ab4b83f0182f016a128d73752b849e5b0221c2b3a35a87ea'
+          );
+
+          expect(transaction.max_fee).toBeTruthy();
+          expect(transaction.transaction_hash).toBeTruthy();
+          expect(transaction).toHaveProperty('nonce');
+          expect(transaction).toHaveProperty('sender_address');
+          expect(transaction).toHaveProperty('version');
+        });
+      });
+
+      describe('getTransactionReceipt', () => {
+        test('Transaction Hash 0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348', async () => {
+          const receipt = await provider.getTransactionReceipt(
+            '0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348'
+          );
+
+          expect(receipt).toHaveProperty('transaction_hash');
+          expect(receipt).toHaveProperty('status');
+          expect(receipt).toHaveProperty('status_data');
+          expect(receipt).toHaveProperty('messages_sent');
+          expect(receipt).toHaveProperty('l1_origin_message');
+          expect(receipt).toHaveProperty('events');
+        });
+      });
+
+      describe('Contract methods', () => {
+        let contractAddress: string;
+        let deployResponse: DeployContractResponse;
+        let declareResponse: DeclareContractResponse;
+
+        beforeAll(async () => {
+          deployResponse = await provider.deployContract({ contract: compiledErc20 });
+          contractAddress = deployResponse.contract_address;
+          declareResponse = await provider.declareContract({ contract: compiledErc20 });
+          await Promise.all([
+            provider.waitForTransaction(deployResponse.transaction_hash),
+            provider.waitForTransaction(declareResponse.transaction_hash),
+          ]);
+        });
+
+        describe('deployContract', () => {
+          test('response', () => {
+            expect(deployResponse.contract_address).toBeTruthy();
+            expect(deployResponse.transaction_hash).toBeTruthy();
+          });
+        });
+
+        describe('declareContract', () => {
+          test('response', async () => {
+            expect(declareResponse.class_hash).toBeTruthy();
+            expect(declareResponse.transaction_hash).toBeTruthy();
+          });
+        });
+
+        describe('getClassAt', () => {
+          test('response', async () => {
+            const classResponse = await provider.getClassAt(contractAddress);
+
+            expect(classResponse).toHaveProperty('program');
+            expect(classResponse).toHaveProperty('entry_points_by_type');
+          });
+        });
+
+        describe('callContract', () => {
+          test('result', () => {
+            return expect(
+              provider
+                .callContract({
+                  contractAddress: deployResponse.contract_address,
+                  entrypoint: 'balance_of',
+                  calldata: compileCalldata({
+                    user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
+                  }),
+                })
+                .then((res) => {
+                  expect(Array.isArray(res.result)).toBe(true);
+                })
+            ).resolves.not.toThrow();
+          });
+        });
+      });
+    });
+  });
+});

package/__tests__/fixtures.ts

@@ -1,6 +1,6 @@
 import fs from 'fs';
 
-import { Account, Provider, ec, json } from '../src';
+import { Account, ProviderInterface, RpcProvider, SequencerProvider, ec, json } from '../src';
 import { CompiledContract } from '../src/types';
 
 const readContract = (name: string): CompiledContract =>
@@ -18,10 +18,20 @@ const DEFAULT_TEST_ACCOUNT_ADDRESS = // run `starknet-devnet --seed 0` and this
 const DEFAULT_TEST_ACCOUNT_PRIVATE_KEY = '0xe3e70682c2094cac629f6fbed82c07cd';
 
 const BASE_URL = process.env.TEST_PROVIDER_BASE_URL || DEFAULT_TEST_PROVIDER_BASE_URL;
-export const IS_DEVNET = !BASE_URL.includes('starknet.io');
+const RPC_URL = process.env.TEST_RPC_URL;
+
+const IS_RPC = !!RPC_URL;
+const IS_RPC_DEVNET = Boolean(
+  RPC_URL && (RPC_URL.includes('localhost') || RPC_URL.includes('127.0.0.1'))
+);
+const IS_SEQUENCER = !IS_RPC;
+const IS_SEQUENCER_DEVNET = !BASE_URL.includes('starknet.io');
+export const IS_DEVNET = IS_SEQUENCER ? IS_SEQUENCER_DEVNET : IS_RPC_DEVNET;
 
 export const getTestProvider = () => {
-  const provider = new Provider({ baseUrl: BASE_URL });
+  const provider = RPC_URL
+    ? new RpcProvider({ nodeUrl: RPC_URL })
+    : new SequencerProvider({ baseUrl: BASE_URL });
 
   if (IS_DEVNET) {
     // accelerate the tests when running locally
@@ -35,16 +45,27 @@ export const getTestProvider = () => {
 };
 
 // test account with fee token balance
-export const getTestAccount = () => {
-  const provider = getTestProvider();
+export const getTestAccount = (provider: ProviderInterface) => {
+  let testAccountAddress = process.env.TEST_ACCOUNT_ADDRESS;
+  let testAccountPrivateKey = process.env.TEST_ACCOUNT_PRIVATE_KEY;
+
+  if (!IS_DEVNET) {
+    if (!testAccountPrivateKey) {
+      throw new Error('TEST_ACCOUNT_PRIVATE_KEY is not set');
+    }
 
-  const testAccountAddress = process.env.TEST_ACCOUNT_ADDRESS || DEFAULT_TEST_ACCOUNT_ADDRESS;
-  const testAccountPrivateKey =
-    process.env.TEST_ACCOUNT_PRIVATE_KEY || DEFAULT_TEST_ACCOUNT_PRIVATE_KEY;
+    if (!testAccountAddress) {
+      throw new Error('TEST_ACCOUNT_ADDRESS is not set');
+    }
+  } else {
+    testAccountAddress = DEFAULT_TEST_ACCOUNT_ADDRESS;
+    testAccountPrivateKey = DEFAULT_TEST_ACCOUNT_PRIVATE_KEY;
+  }
 
   return new Account(provider, testAccountAddress, ec.getKeyPair(testAccountPrivateKey));
 };
 
-export const testIf = (condition: boolean) => (condition ? test : test.skip);
-export const testIfDevnet = testIf(IS_DEVNET);
-export const testIfNotDevnet = testIf(!IS_DEVNET);
+const describeIf = (condition: boolean) => (condition ? describe : describe.skip);
+export const describeIfSequencer = describeIf(IS_DEVNET);
+export const describeIfRpc = describeIf(IS_RPC);
+export const describeIfNotDevnet = describeIf(!IS_DEVNET);

package/__tests__/rpcProvider.test.ts

@@ -0,0 +1,17 @@
+import { RpcProvider } from '../src';
+import { describeIfRpc, getTestProvider } from './fixtures';
+
+describeIfRpc('RPCProvider', () => {
+  let provider: RpcProvider;
+
+  beforeAll(async () => {
+    provider = getTestProvider() as RpcProvider;
+  });
+
+  describe('RPC methods', () => {
+    test('getChainId', async () => {
+      const chainId = await provider.getChainId();
+      expect(chainId).toBe('0x534e5f474f45524c49');
+    });
+  });
+});

package/__tests__/sequencerProvider.test.ts

@@ -0,0 +1,45 @@
+import { SequencerProvider } from '../src';
+import {
+  compiledErc20,
+  describeIfNotDevnet,
+  describeIfSequencer,
+  getTestProvider,
+} from './fixtures';
+
+describeIfSequencer('SequencerProvider', () => {
+  let provider: SequencerProvider;
+
+  beforeAll(async () => {
+    provider = getTestProvider() as SequencerProvider;
+  });
+
+  describe('Gateway specific methods', () => {
+    let exampleTransactionHash: string;
+
+    beforeAll(async () => {
+      const { transaction_hash } = await provider.deployContract({
+        contract: compiledErc20,
+      });
+      await provider.waitForTransaction(transaction_hash);
+      exampleTransactionHash = transaction_hash;
+    });
+
+    test('getTransactionStatus()', async () => {
+      return expect(provider.getTransactionStatus(exampleTransactionHash)).resolves.not.toThrow();
+    });
+
+    test('transaction trace', async () => {
+      const transactionTrace = await provider.getTransactionTrace(exampleTransactionHash);
+      expect(transactionTrace).toHaveProperty('function_invocation');
+      expect(transactionTrace).toHaveProperty('signature');
+    });
+
+    describeIfNotDevnet('which are not available on devnet', () => {
+      test('getContractAddresses()', async () => {
+        const { GpsStatementVerifier, Starknet } = await provider.getContractAddresses();
+        expect(typeof GpsStatementVerifier).toBe('string');
+        expect(typeof Starknet).toBe('string');
+      });
+    });
+  });
+});

package/__tests__/utils/typedData.test.ts

@@ -1,4 +1,5 @@
 import typedDataExample from '../../__mocks__/typedDataExample.json';
+import typedDataStructArrayExample from '../../__mocks__/typedDataStructArrayExample.json';
 import { number } from '../../src';
 import { BigNumberish } from '../../src/utils/number';
 import { encodeType, getMessageHash, getStructHash, getTypeHash } from '../../src/utils/typedData';
@@ -9,7 +10,12 @@ describe('typedData', () => {
     expect(typeEncoding).toMatchInlineSnapshot(
       `"Mail(from:Person,to:Person,contents:felt)Person(name:felt,wallet:felt)"`
     );
+    const typeEncodingStructArr = encodeType(typedDataStructArrayExample, 'Mail');
+    expect(typeEncodingStructArr).toMatchInlineSnapshot(
+      `"Mail(from:Person,to:Person,posts_len:felt,posts:Post*)Person(name:felt,wallet:felt)Post(title:felt,content:felt)"`
+    );
   });
+
   test('should get right type hash', () => {
     const typeHashDomain = getTypeHash(typedDataExample, 'StarkNetDomain');
     expect(typeHashDomain).toMatchInlineSnapshot(
@@ -23,18 +29,36 @@ describe('typedData', () => {
     expect(typeHashMail).toMatchInlineSnapshot(
       `"0x13d89452df9512bf750f539ba3001b945576243288137ddb6c788457d4b2f79"`
     );
+    const typeHashPost = getTypeHash(typedDataStructArrayExample, 'Post');
+    expect(typeHashPost).toMatchInlineSnapshot(
+      `"0x1d71e69bf476486b43cdcfaf5a85c00bb2d954c042b281040e513080388356d"`
+    );
+    const typeHashMailWithStructArray = getTypeHash(typedDataStructArrayExample, 'Mail');
+    expect(typeHashMailWithStructArray).toMatchInlineSnapshot(
+      `"0x873b878e35e258fc99e3085d5aaad3a81a0c821f189c08b30def2cde55ff27"`
+    );
   });
+
   test('should get right hash for StarkNetDomain', () => {
     const hash = getStructHash(typedDataExample, 'StarkNetDomain', typedDataExample.domain as any);
     expect(hash).toMatchInlineSnapshot(
       `"0x54833b121883a3e3aebff48ec08a962f5742e5f7b973469c1f8f4f55d470b07"`
     );
   });
+
   test('should get right hash for entire message', () => {
     const hash = getMessageHash(typedDataExample, '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826');
     expect(hash).toMatchInlineSnapshot(
       `"0x6fcff244f63e38b9d88b9e3378d44757710d1b244282b435cb472053c8d78d0"`
     );
+
+    const hashStructArr = getMessageHash(
+      typedDataStructArrayExample,
+      '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826'
+    );
+    expect(hashStructArr).toMatchInlineSnapshot(
+      `"0x5914ed2764eca2e6a41eb037feefd3d2e33d9af6225a9e7fe31ac943ff712c"`
+    );
   });
 
   interface StringStruct {

package/account/default.d.ts

@@ -1,84 +1,61 @@
-import { Provider, ProviderInterface } from '../provider';
+import { ProviderInterface, ProviderOptions } from '../provider';
+import { Provider } from '../provider/default';
 import { SignerInterface } from '../signer';
-import {
-  Abi,
-  AddTransactionResponse,
-  Call,
-  InvocationsDetails,
-  KeyPair,
-  Signature,
-  Transaction,
-} from '../types';
+import { Abi, Call, InvocationsDetails, InvokeFunctionResponse, KeyPair, Signature } from '../types';
 import { EstimateFee, EstimateFeeDetails } from '../types/account';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData';
 import { AccountInterface } from './interface';
 export declare class Account extends Provider implements AccountInterface {
-  address: string;
-  signer: SignerInterface;
-  constructor(
-    provider: ProviderInterface,
-    address: string,
-    keyPairOrSigner: KeyPair | SignerInterface
-  );
-  getNonce(): Promise<string>;
-  estimateFee(
-    calls: Call | Call[],
-    { nonce: providedNonce, blockIdentifier }?: EstimateFeeDetails
-  ): Promise<EstimateFee>;
-  /**
-   * Invoke execute function in account contract
-   *
-   * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/gateway/gateway_client.py#L13-L17)
-   *
-   * @param calls - one or more calls to be executed
-   * @param abis - one or more abis which can be used to display the calls
-   * @param transactionsDetail - optional transaction details
-   * @returns a confirmation of invoking a function on the starknet contract
-   */
-  execute(
-    calls: Call | Call[],
-    abis?: Abi[] | undefined,
-    transactionsDetail?: InvocationsDetails
-  ): Promise<AddTransactionResponse>;
-  /**
-   * Temporary method to allow dapps on starknet.js v2 to work with Argent X v3
-   * @deprecated to remove ASAP
-   */
-  LEGACY_addTransaction(transaction: Transaction): Promise<AddTransactionResponse>;
-  /**
-   * Sign an JSON object with the starknet private key and return the signature
-   *
-   * @param json - JSON object to be signed
-   * @returns the signature of the JSON object
-   * @throws {Error} if the JSON object is not a valid JSON
-   */
-  signMessage(typedData: TypedData): Promise<Signature>;
-  /**
-   * Hash a JSON object with pederson hash and return the hash
-   *
-   * @param json - JSON object to be hashed
-   * @returns the hash of the JSON object
-   * @throws {Error} if the JSON object is not a valid JSON
-   */
-  hashMessage(typedData: TypedData): Promise<string>;
-  /**
-   * Verify a signature of a given hash
-   * @warning This method is not recommended, use verifyMessage instead
-   *
-   * @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
-   */
-  verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
-  /**
-   * Verify a signature of a JSON object
-   *
-   * @param hash - hash to be verified
-   * @param signature - signature of the hash
-   * @returns true if the signature is valid, false otherwise
-   * @throws {Error} if the signature is not a valid signature
-   */
-  verifyMessage(typedData: TypedData, signature: Signature): Promise<boolean>;
+    address: string;
+    signer: SignerInterface;
+    constructor(providerOrOptions: ProviderOptions | ProviderInterface, address: string, keyPairOrSigner: KeyPair | SignerInterface);
+    getNonce(): Promise<string>;
+    estimateFee(calls: Call | Call[], { nonce: providedNonce, blockIdentifier }?: EstimateFeeDetails): Promise<EstimateFee>;
+    /**
+     * Invoke execute function in account contract
+     *
+     * [Reference](https://github.com/starkware-libs/cairo-lang/blob/f464ec4797361b6be8989e36e02ec690e74ef285/src/starkware/starknet/services/api/gateway/gateway_client.py#L13-L17)
+     *
+     * @param calls - one or more calls to be executed
+     * @param abis - one or more abis which can be used to display the calls
+     * @param transactionsDetail - optional transaction details
+     * @returns a confirmation of invoking a function on the starknet contract
+     */
+    execute(calls: Call | Call[], abis?: Abi[] | undefined, transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
+    /**
+     * Sign an JSON object with the starknet private key and return the signature
+     *
+     * @param json - JSON object to be signed
+     * @returns the signature of the JSON object
+     * @throws {Error} if the JSON object is not a valid JSON
+     */
+    signMessage(typedData: TypedData): Promise<Signature>;
+    /**
+     * Hash a JSON object with pederson hash and return the hash
+     *
+     * @param json - JSON object to be hashed
+     * @returns the hash of the JSON object
+     * @throws {Error} if the JSON object is not a valid JSON
+     */
+    hashMessage(typedData: TypedData): Promise<string>;
+    /**
+     * Verify a signature of a given hash
+     * @warning This method is not recommended, use verifyMessage instead
+     *
+     * @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
+     */
+    verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
+    /**
+     * Verify a signature of a JSON object
+     *
+     * @param hash - hash to be verified
+     * @param signature - signature of the hash
+     * @returns true if the signature is valid, false otherwise
+     * @throws {Error} if the signature is not a valid signature
+     */
+    verifyMessage(typedData: TypedData, signature: Signature): Promise<boolean>;
 }