feat: getNonce endpoint for sequencer

__tests__/defaultProvider.test.ts

@@ -62,6 +62,11 @@ describe('defaultProvider', () => {
       return expect(block).toHaveProperty('block_number');
     });
 
+    test('getNonce()', async () => {
+      const nonce = await testProvider.getNonce(exampleContractAddress);
+      return expect(nonce).toEqual('0x0');
+    });
+
     describe('getStorageAt', () => {
       test('with "key" type of number', () => {
         return expect(testProvider.getStorageAt(exampleContractAddress, 0)).resolves.not.toThrow();

__tests__/sequencerProvider.test.ts

@@ -9,12 +9,12 @@ import {
 
 // Run only if Devnet Sequencer
 describeIfSequencer('SequencerProvider', () => {
-  let provider: SequencerProvider;
+  let sequencerProvider: SequencerProvider;
   let customSequencerProvider: Provider;
   let exampleContractAddress: string;
 
   beforeAll(async () => {
-    provider = getTestProvider() as SequencerProvider;
+    sequencerProvider = getTestProvider() as SequencerProvider;
     customSequencerProvider = new Provider({
       sequencer: {
         baseUrl: 'https://alpha4.starknet.io',
@@ -28,32 +28,34 @@ describeIfSequencer('SequencerProvider', () => {
     let exampleTransactionHash: string;
 
     beforeAll(async () => {
-      const { transaction_hash, contract_address } = await provider.deployContract({
+      const { transaction_hash, contract_address } = await sequencerProvider.deployContract({
         contract: compiledErc20,
       });
-      await provider.waitForTransaction(transaction_hash);
+      await sequencerProvider.waitForTransaction(transaction_hash);
       exampleTransactionHash = transaction_hash;
       exampleContractAddress = contract_address;
     });
 
     test('getTransactionStatus()', async () => {
-      return expect(provider.getTransactionStatus(exampleTransactionHash)).resolves.not.toThrow();
+      return expect(
+        sequencerProvider.getTransactionStatus(exampleTransactionHash)
+      ).resolves.not.toThrow();
     });
 
     test('transaction trace', async () => {
-      const transactionTrace = await provider.getTransactionTrace(exampleTransactionHash);
+      const transactionTrace = await sequencerProvider.getTransactionTrace(exampleTransactionHash);
       expect(transactionTrace).toHaveProperty('function_invocation');
       expect(transactionTrace).toHaveProperty('signature');
     });
 
     test('getCode() -> { bytecode }', async () => {
-      const code = await provider.getCode(exampleContractAddress);
+      const code = await sequencerProvider.getCode(exampleContractAddress);
       return expect(Array.isArray(code.bytecode)).toBe(true);
     });
 
     describeIfNotDevnet('which are not available on devnet', () => {
       test('getContractAddresses()', async () => {
-        const { GpsStatementVerifier, Starknet } = await provider.getContractAddresses();
+        const { GpsStatementVerifier, Starknet } = await sequencerProvider.getContractAddresses();
         expect(typeof GpsStatementVerifier).toBe('string');
         expect(typeof Starknet).toBe('string');
       });

src/provider/default.ts

@@ -65,6 +65,10 @@ export class Provider implements ProviderInterface {
     return this.provider.getEstimateFee(invocation, blockIdentifier, invocationDetails);
   }
 
+  public async getNonce(contractAddress: string): Promise<any> {
+    return this.provider.getNonce(contractAddress);
+  }
+
   public async getStorageAt(
     contractAddress: string,
     key: BigNumberish,

src/provider/interface.ts

@@ -62,6 +62,14 @@ export abstract class ProviderInterface {
     blockIdentifier?: BlockIdentifier
   ): Promise<ContractClass>;
 
+  /**
+   * Gets the nonce of a contract with respect to a specific block
+   *
+   * @param contractAddress - contract address
+   * @returns the hex nonce
+   */
+  public abstract getNonce(contractAddress: string): Promise<any>;
+
   /**
    * Gets the contract's storage variable at a specific key.
    *

src/provider/sequencer.ts

@@ -229,6 +229,10 @@ export class SequencerProvider implements ProviderInterface {
     );
   }
 
+  public async getNonce(contractAddress: string): Promise<any> {
+    return this.fetchEndpoint('get_nonce', { contractAddress });
+  }
+
   public async getStorageAt(
     contractAddress: string,
     key: BigNumberish,

src/types/api/rpc.ts

@@ -143,7 +143,7 @@ export namespace RPC {
     starknet_getNonce: {
       QUERY: never;
       REQUEST: any[];
-      RESPONSE: string;
+      RESPONSE: any;
     };
     starknet_getStorageAt: {
       QUERY: never;

src/types/api/sequencer.ts

@@ -259,6 +259,13 @@ export namespace Sequencer {
       REQUEST: never;
       RESPONSE: TransactionReceiptResponse;
     };
+    get_nonce: {
+      QUERY: {
+        contractAddress: string;
+      };
+      REQUEST: never;
+      RESPONSE: any;
+    };
     get_storage_at: {
       QUERY: {
         contractAddress: string;