starknet 4.13.2 → 4.15.0

package/src/provider/sequencer.ts

@@ -45,6 +45,16 @@ import { Block, BlockIdentifier } from './utils';
 
 type NetworkName = 'mainnet-alpha' | 'goerli-alpha' | 'goerli-alpha-2';
 
+export type SequencerProviderOptions =
+  | { network: NetworkName | StarknetChainId }
+  | {
+      baseUrl: string;
+      feederGatewayUrl?: string;
+      gatewayUrl?: string;
+      chainId?: StarknetChainId;
+      headers?: object;
+    };
+
 function isEmptyQueryObject(obj?: Record<any, any>): obj is undefined {
   return (
     obj === undefined ||
@@ -54,15 +64,9 @@ function isEmptyQueryObject(obj?: Record<any, any>): obj is undefined {
   );
 }
 
-export type SequencerProviderOptions =
-  | { network: NetworkName }
-  | {
-      baseUrl: string;
-      feederGatewayUrl?: string;
-      gatewayUrl?: string;
-      chainId?: StarknetChainId;
-      headers?: object;
-    };
+const defaultOptions: SequencerProviderOptions = {
+  network: 'goerli-alpha-2',
+};
 
 export class SequencerProvider implements ProviderInterface {
   public baseUrl: string;
@@ -77,7 +81,7 @@ export class SequencerProvider implements ProviderInterface {
 
   private responseParser = new SequencerAPIResponseParser();
 
-  constructor(optionsOrProvider: SequencerProviderOptions = { network: 'goerli-alpha-2' }) {
+  constructor(optionsOrProvider: SequencerProviderOptions = defaultOptions) {
     if ('network' in optionsOrProvider) {
       this.baseUrl = SequencerProvider.getNetworkFromName(optionsOrProvider.network);
       this.chainId = SequencerProvider.getChainIdFromBaseUrl(this.baseUrl);
@@ -100,13 +104,13 @@ export class SequencerProvider implements ProviderInterface {
     }
   }
 
-  protected static getNetworkFromName(name: NetworkName) {
+  protected static getNetworkFromName(name: NetworkName | StarknetChainId) {
     switch (name) {
-      case 'mainnet-alpha':
+      case 'mainnet-alpha' || StarknetChainId.MAINNET:
         return 'https://alpha-mainnet.starknet.io';
-      case 'goerli-alpha':
+      case 'goerli-alpha' || StarknetChainId.TESTNET:
         return 'https://alpha4.starknet.io';
-      case 'goerli-alpha-2':
+      case 'goerli-alpha-2' || StarknetChainId.TESTNET2:
         return 'https://alpha4-2.starknet.io';
       default:
         return 'https://alpha4.starknet.io';
@@ -119,6 +123,9 @@ export class SequencerProvider implements ProviderInterface {
       if (url.host.includes('mainnet.starknet.io')) {
         return StarknetChainId.MAINNET;
       }
+      if (url.host.includes('alpha4-2.starknet.io')) {
+        return StarknetChainId.TESTNET2;
+      }
     } catch {
       // eslint-disable-next-line no-console
       console.error(`Could not parse baseUrl: ${baseUrl}`);
@@ -256,7 +263,7 @@ export class SequencerProvider implements ProviderInterface {
     );
   }
 
-  public async getNonce(
+  public async getNonceForAddress(
     contractAddress: string,
     blockIdentifier: BlockIdentifier = 'pending'
   ): Promise<BigNumberish> {
@@ -447,17 +454,20 @@ export class SequencerProvider implements ProviderInterface {
     return this.fetchEndpoint('get_code', { contractAddress, blockIdentifier });
   }
 
-  public async waitForTransaction(txHash: BigNumberish, retryInterval: number = 8000) {
+  public async waitForTransaction(
+    txHash: BigNumberish,
+    retryInterval: number = 8000,
+    successStates = ['ACCEPTED_ON_L1', 'ACCEPTED_ON_L2', 'PENDING']
+  ) {
+    const errorStates = ['REJECTED', 'NOT_RECEIVED'];
     let onchain = false;
+    let res;
 
     while (!onchain) {
       // eslint-disable-next-line no-await-in-loop
       await wait(retryInterval);
       // eslint-disable-next-line no-await-in-loop
-      const res = await this.getTransactionStatus(txHash);
-
-      const successStates = ['ACCEPTED_ON_L1', 'ACCEPTED_ON_L2', 'PENDING'];
-      const errorStates = ['REJECTED', 'NOT_RECEIVED'];
+      res = await this.getTransactionStatus(txHash);
 
       if (successStates.includes(res.tx_status)) {
         onchain = true;
@@ -470,6 +480,8 @@ export class SequencerProvider implements ProviderInterface {
         throw error;
       }
     }
+    const txReceipt = await this.getTransactionReceipt(txHash);
+    return txReceipt;
   }
 
   /**

package/src/provider/utils.ts

@@ -1,4 +1,6 @@
 /* eslint-disable max-classes-per-file */
+import { BN } from 'bn.js';
+
 import type { BlockNumber } from '../types';
 import { BigNumberish, isHex, toBN, toHex } from '../utils/number';
 
@@ -34,6 +36,7 @@ export function txIdentifier(txHash?: BigNumberish, txId?: BigNumberish): string
 // null appends nothing to the request url
 
 export type BlockIdentifier = BlockNumber | BigNumberish;
+export const validBlockTags = ['latest', 'pending'];
 
 export class Block {
   hash: BlockIdentifier = null;
@@ -42,22 +45,26 @@ export class Block {
 
   tag: BlockIdentifier = null;
 
-  private setIdentifier: (_identifier: BlockIdentifier) => void;
+  private setIdentifier(__identifier: BlockIdentifier) {
+    if (typeof __identifier === 'string' && isHex(__identifier)) {
+      this.hash = __identifier;
+    } else if (BN.isBN(__identifier)) {
+      this.hash = toHex(__identifier);
+    } else if (typeof __identifier === 'number') {
+      this.number = __identifier;
+    } else if (typeof __identifier === 'string' && validBlockTags.includes(__identifier)) {
+      this.tag = __identifier;
+    } else {
+      // default
+      this.tag = 'pending';
+    }
+  }
 
   constructor(_identifier: BlockIdentifier) {
-    this.setIdentifier = function (__identifier: BlockIdentifier) {
-      if (typeof __identifier === 'string' && isHex(__identifier)) {
-        this.hash = __identifier;
-      } else if (typeof __identifier === 'number') {
-        this.number = __identifier;
-      } else {
-        this.tag = __identifier;
-      }
-    };
-
     this.setIdentifier(_identifier);
   }
 
+  // TODO: fix any
   get queryIdentifier(): any {
     if (this.number !== null) {
       return `blockNumber=${this.number}`;
@@ -70,6 +77,7 @@ export class Block {
     return `blockNumber=${this.tag}`;
   }
 
+  // TODO: fix any
   get identifier(): any {
     if (this.number !== null) {
       return { block_number: this.number };

package/src/types/account.ts

@@ -2,7 +2,7 @@ import BN from 'bn.js';
 
 import { BlockIdentifier } from '../provider/utils';
 import { BigNumberish } from '../utils/number';
-import { EstimateFeeResponse } from './provider';
+import { DeclareTransactionReceiptResponse, EstimateFeeResponse } from './provider';
 
 export interface EstimateFee extends EstimateFeeResponse {
   suggestedMaxFee: BN;
@@ -12,3 +12,23 @@ export interface EstimateFeeDetails {
   nonce?: BigNumberish;
   blockIdentifier?: BlockIdentifier;
 }
+
+export interface DeployContractResponse {
+  contract_address: string;
+  transaction_hash: string;
+}
+
+export interface DeployContractUDCResponse extends DeployContractResponse {
+  address: string;
+  deployer: string;
+  unique: string;
+  classHash: string;
+  calldata_len: string;
+  calldata: Array<string>;
+  salt: string;
+}
+
+export type DeclareDeployContractResponse = {
+  declare: DeclareTransactionReceiptResponse;
+  deploy: DeployContractUDCResponse;
+};

package/src/types/lib.ts

@@ -21,8 +21,8 @@ export interface ContractClass {
 
 export type UniversalDeployerContractPayload = {
   classHash: BigNumberish;
-  salt: string;
-  unique: boolean;
+  salt?: string;
+  unique?: boolean;
   constructorCalldata?: RawArgs;
   additionalCalls?: AllowArray<Call>; // support multicall
 };
@@ -52,6 +52,9 @@ export type DeclareContractPayload = {
   classHash: BigNumberish; // Once the classHash is included in CompiledContract, this can be removed
 };
 
+export type DeclareDeployContractPayload = DeclareContractPayload &
+  UniversalDeployerContractPayload;
+
 export type DeclareContractTransaction = {
   contractDefinition: ContractClass;
   senderAddress: string;

package/src/types/provider.ts

@@ -106,11 +106,6 @@ export interface InvokeFunctionResponse {
   transaction_hash: string;
 }
 
-export interface DeployContractResponse {
-  contract_address: string;
-  transaction_hash: string;
-}
-
 export interface DeclareContractResponse {
   transaction_hash: string;
   class_hash: string;

package/src/utils/events.ts

@@ -0,0 +1,32 @@
+import { UDC } from '../constants';
+import { InvokeTransactionReceiptResponse } from '../types/provider';
+import { cleanHex } from './number';
+
+/**
+ * Parse Transaction Receipt Event from UDC invoke transaction and
+ * create DeployContractResponse compatibile response with adition of UDC Event data
+ *
+ * @param txReceipt
+ * @returns DeployContractResponse | UDC Event Response data
+ */
+export function parseUDCEvent(txReceipt: InvokeTransactionReceiptResponse) {
+  if (!txReceipt.events) {
+    throw new Error('UDC emited event is empty');
+  }
+  const event = txReceipt.events.find(
+    (it) => cleanHex(it.from_address) === cleanHex(UDC.ADDRESS)
+  ) || {
+    data: [],
+  };
+  return {
+    transaction_hash: txReceipt.transaction_hash,
+    contract_address: event.data[0],
+    address: event.data[0],
+    deployer: event.data[1],
+    unique: event.data[2],
+    classHash: event.data[3],
+    calldata_len: event.data[4],
+    calldata: event.data.slice(5, 5 + parseInt(event.data[4], 16)),
+    salt: event.data[event.data.length - 1],
+  };
+}

package/src/utils/number.ts

@@ -34,6 +34,12 @@ export function toFelt(num: BigNumberish): string {
   return toBN(num).toString();
 }
 
+/**
+ * Remove hex string leading zero and lower case '0x01A'.. -> '0x1a..'
+ * @param hex string
+ */
+export const cleanHex = (hex: string) => hex.toLowerCase().replace(/^(0x)0+/, '$1');
+
 /*
  Asserts input is equal to or greater then lowerBound and lower then upperBound.
  Assert message specifies inputName.

package/src/utils/starknetId.ts

@@ -0,0 +1,116 @@
+/* eslint-disable no-param-reassign */
+import BN from 'bn.js';
+
+import { StarknetChainId } from '../constants';
+
+const basicAlphabet = 'abcdefghijklmnopqrstuvwxyz0123456789-';
+const basicSizePlusOne = new BN(basicAlphabet.length + 1);
+const bigAlphabet = '这来';
+const basicAlphabetSize = new BN(basicAlphabet.length);
+const bigAlphabetSize = new BN(bigAlphabet.length);
+const bigAlphabetSizePlusOne = new BN(bigAlphabet.length + 1);
+
+function extractStars(str: string): [string, number] {
+  let k = 0;
+  while (str.endsWith(bigAlphabet[bigAlphabet.length - 1])) {
+    str = str.substring(0, str.length - 1);
+    k += 1;
+  }
+  return [str, k];
+}
+
+export function useDecoded(encoded: BN[]): string {
+  let decoded = '';
+
+  encoded.forEach((subdomain) => {
+    while (!subdomain.isZero()) {
+      const code = subdomain.mod(basicSizePlusOne).toNumber();
+      subdomain = subdomain.div(basicSizePlusOne);
+      if (code === basicAlphabet.length) {
+        const nextSubdomain = subdomain.div(bigAlphabetSizePlusOne);
+        if (nextSubdomain.isZero()) {
+          const code2 = subdomain.mod(bigAlphabetSizePlusOne).toNumber();
+          subdomain = nextSubdomain;
+          if (code2 === 0) decoded += basicAlphabet[0];
+          else decoded += bigAlphabet[code2 - 1];
+        } else {
+          const code2 = subdomain.mod(bigAlphabetSize).toNumber();
+          decoded += bigAlphabet[code2];
+          subdomain = subdomain.div(bigAlphabetSize);
+        }
+      } else decoded += basicAlphabet[code];
+    }
+
+    const [str, k] = extractStars(decoded);
+    if (k)
+      decoded =
+        str +
+        (k % 2 === 0
+          ? bigAlphabet[bigAlphabet.length - 1].repeat(k / 2 - 1) +
+            bigAlphabet[0] +
+            basicAlphabet[1]
+          : bigAlphabet[bigAlphabet.length - 1].repeat((k - 1) / 2 + 1));
+    decoded += '.';
+  });
+  return decoded.concat('stark');
+}
+
+export function useEncoded(decoded: string): BN {
+  let encoded = new BN(0);
+  let multiplier = new BN(1);
+
+  if (decoded.endsWith(bigAlphabet[0] + basicAlphabet[1])) {
+    const [str, k] = extractStars(decoded.substring(0, decoded.length - 2));
+    decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(2 * (k + 1));
+  } else {
+    const [str, k] = extractStars(decoded);
+    if (k) decoded = str + bigAlphabet[bigAlphabet.length - 1].repeat(1 + 2 * (k - 1));
+  }
+
+  for (let i = 0; i < decoded.length; i += 1) {
+    const char = decoded[i];
+    const index = basicAlphabet.indexOf(char);
+    const bnIndex = new BN(basicAlphabet.indexOf(char));
+
+    if (index !== -1) {
+      // add encoded + multiplier * index
+      if (i === decoded.length - 1 && decoded[i] === basicAlphabet[0]) {
+        encoded = encoded.add(multiplier.mul(basicAlphabetSize));
+        multiplier = multiplier.mul(basicSizePlusOne);
+        // add 0
+        multiplier = multiplier.mul(basicSizePlusOne);
+      } else {
+        encoded = encoded.add(multiplier.mul(bnIndex));
+        multiplier = multiplier.mul(basicSizePlusOne);
+      }
+    } else if (bigAlphabet.indexOf(char) !== -1) {
+      // add encoded + multiplier * (basicAlphabetSize)
+      encoded = encoded.add(multiplier.mul(basicAlphabetSize));
+      multiplier = multiplier.mul(basicSizePlusOne);
+      // add encoded + multiplier * index
+      const newid = (i === decoded.length - 1 ? 1 : 0) + bigAlphabet.indexOf(char);
+      encoded = encoded.add(multiplier.mul(new BN(newid)));
+      multiplier = multiplier.mul(bigAlphabetSize);
+    }
+  }
+
+  return encoded;
+}
+
+export function getStarknetIdContract(chainId: StarknetChainId): string {
+  const starknetIdMainnetContract =
+    '0x6ac597f8116f886fa1c97a23fa4e08299975ecaf6b598873ca6792b9bbfb678';
+  const starknetIdTestnetContract =
+    '0x05cf267a0af6101667013fc6bd3f6c11116a14cda9b8c4b1198520d59f900b17';
+
+  switch (chainId) {
+    case StarknetChainId.MAINNET:
+      return starknetIdMainnetContract;
+
+    case StarknetChainId.TESTNET:
+      return starknetIdTestnetContract;
+
+    default:
+      throw new Error('Starknet.id is not yet deployed on this network');
+  }
+}

package/www/docs/API/account.md

@@ -6,7 +6,7 @@ sidebar_position: 2
 
 An Account extends <ins>[`Provider`](/docs/API/provider)</ins> and inherits all of its methods.
 
-It also introduces new methods that allow Accounts to create and verify signatures with a custom <ins>[`Signer`](/docs/API/signer)</ins>.
+It also introduces new methods that allow Accounts to create and verify signatures with a custom <ins>[`Signer`](/docs/API/signer)</ins>, declare and deploy Contract and deploy new Account
 
 This API is the primary way to interact with an account contract on StarkNet.
 
@@ -89,7 +89,7 @@ The _estimateFeeDetails_ object may include any of:
 
 account.**estimateAccountDeployFee**(contractPayload [ , estimateFeeDetails ]) => _Promise < EstimateFeeResponse >_
 
-Estimate Fee for executing a DEPLOY_ACCOUNT transaction on starknet
+Estimate Fee for executing a DEPLOY_ACCOUNT transaction on StarkNet
 
 The _contractPayload_ object structure:
 
@@ -142,6 +142,8 @@ The _transactionsDetail_ object may include any of:
 
 <hr />
 
+### Declare
+
 account.**declare**(contractPayload [ , transactionsDetail ]) => _Promise < DeclareContractResponse >_
 
 Declares a given compiled contract (json) to starknet.
@@ -180,6 +182,158 @@ const declareTx = await account.declare({
 
 <hr />
 
+### Deploy
+
+Deploys a given compiled contract (json) to starknet, wrapper around _execute_ invoke function
+
+**deploy**(deployContractPayload [ , transactionsDetail ]) => _Promise < InvokeFunctionResponse >_
+
+@param object **_deployContractPayload_**
+
+- **classHash**: computed class hash of compiled contract
+- **constructorCalldata**: constructor calldata
+- optional salt: address salt - default random
+- optional unique: bool if true ensure unique salt - default true
+- optional additionalCalls - optional additional calls array to support multi-call
+
+@param object **transactionsDetail** Invocation Details
+
+- optional nonce
+- optional version
+- optional maxFee
+
+@returns **transaction_hash**
+
+Example:
+
+```typescript
+  const deployment = await account.deploy({
+    classHash: erc20ClassHash,
+    constructorCalldata: [
+      encodeShortString('Token'),
+      encodeShortString('ERC20'),
+      account.address,
+    ],
+    salt: randomAddress(),
+    unique: true, // Using true here so as not to clash with normal erc20 deploy in account and provider test
+  });
+
+  await provider.waitForTransaction(deployment.transaction_hash);
+```
+
+Example multi-call:
+
+```typescript
+TODO Example with multi-call
+```
+
+<hr />
+
+### DeployContract
+
+✅ NEW
+High level wrapper for deploy. Doesn't require waitForTransaction. Response similar to deprecated provider deployContract.
+
+**deployContract**(payload [ , details ]) => _Promise < DeployContractUDCResponse >_
+
+@param object **_payload_** UniversalDeployerContractPayload
+
+- **classHash**: computed class hash of compiled contract
+- **constructorCalldata**: constructor calldata
+- optional salt: address salt - default random
+- optional unique: bool if true ensure unique salt - default true
+- optional additionalCalls - optional additional calls array to support multi-call
+
+@param object **details** InvocationsDetails
+
+- optional nonce
+- optional version
+- optional maxFee
+
+@returns Promise DeployContractUDCResponse
+
+- contract_address
+- transaction_hash
+- address
+- deployer
+- unique
+- classHash
+- calldata_len
+- calldata
+- salt
+
+Example:
+
+```typescript
+  const deployResponse = await account.deployContract({
+    classHash: erc20ClassHash,
+    constructorCalldata: [
+      encodeShortString('Token'),
+      encodeShortString('ERC20'),
+      account.address,
+    ],
+  });
+```
+
+<hr />
+
+### DeclareDeploy
+
+✅ NEW
+High level wrapper for declare & deploy. Doesn't require waitForTransaction. Functionality similar to deprecated provider deployContract. Declare and Deploy contract using single function.
+
+**declareDeploy**(payload [ , details ]) => _Promise < DeclareDeployContractResponse >_
+
+@param object **_payload_** DeclareDeployContractPayload
+
+- **contract**: compiled contract code
+- **classHash**: computed class hash of compiled contract
+- optional constructorCalldata: constructor calldata
+- optional salt: address salt - default random
+- optional unique: bool if true ensure unique salt - default true
+- optional additionalCalls - optional additional calls array to support multi-call
+
+@param object **details** InvocationsDetails
+
+- optional nonce
+- optional version
+- optional maxFee
+
+@returns Promise object DeclareDeployContractResponse
+
+- declare: CommonTransactionReceiptResponse
+  - transaction_hash
+- deploy: DeployContractUDCResponse;
+  - contract_address
+  - transaction_hash
+  - address
+  - deployer
+  - unique
+  - classHash
+  - calldata_len
+  - calldata
+  - salt
+  <hr />
+
+Example:
+
+```typescript
+  const declareDeploy = await account.declareDeploy({
+    contract: compiledErc20,
+    classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
+    constructorCalldata: [
+      encodeShortString('Token'),
+      encodeShortString('ERC20'),
+      account.address,
+    ],
+  });
+
+  const declareTransactionHash = declareDeploy.declare.transaction_hash
+  const erc20Address = declareDeploy.deploy.contract_address;
+```
+
+### deployAccount
+
 account.**deployAccount**(contractPayload [ , transactionsDetail ]) => _Promise < DeployContractResponse >_
 
 Declares a given compiled contract (json) to starknet.
@@ -263,3 +417,23 @@ The _details_ object may include any of:
 
 - details.**blockIdentifier**
 - details.**nonce**
+
+<hr />
+
+account.**getStarkName**(StarknetIdContract) => _Promise<string | Error>_
+
+Gets starknet.id stark name with the address of the account
+
+The _StarknetIdContract_ argument can be undefined, if it is, the function will automatically use official starknet id contracts of your network (It currently supports TESTNET 1 only).
+
+Returns directly a string (Example: `vitalik.stark`).
+
+<hr />
+
+account.**getAddressFromStarkName**(name, StarknetIdContract) => _Promise<string | Error>_
+
+Gets account address with the starknet id stark name.
+
+The _StarknetIdContract_ argument can be undefined, if it is, the function will automatically use official starknet id contracts of your network (It currently supports TESTNET 1 only).
+
+Returns directly the address in a string (Example: `0xff...34`).

package/www/docs/API/contractFactory.md

@@ -8,33 +8,29 @@ Contract Factory allow you to deploy contracts to StarkNet. To deploy a Contract
 
 ## Creating an instance
 
-`new starknet.ContractFactory( compiledContract , providerOrAccount, [ , abi ] )`
+`new starknet.ContractFactory( compiledContract, classHash, account, [ , abi ] )`
 
 Creates a new instance of a ContractFactory for the contract described by the _compiledContract_.
 
-`contractFactory.connect(providerOrAccount)` _for changing the provider or account_
+`contractFactory.connect(account)` _for changing the provider or account_
 
 `contractFactory.attach(address)` _for changing the address of the connected contract factory_
 
 ## Properties
 
-contractFactory.**abi** => _Abi_
+contractFactory.**compiledContract** => _CompiledContract_ (the compiled contract the contractFactory was constructed with)
 
-The ABI the contractFactory was constructed with.
+contractFactory.**classHash** => _string_ (contract classHash can be obtained using tool for compiling contract)
 
-contractFactory.**compiledContract** => _CompiledContract_
+contractFactory.**account** => _AccountInterface_ (account that are used to interact with the network)
 
-The compiled contract the contractFactory was constructed with.
-
-contractFactory.**providerOrAccount** => _ProviderInterface | AccountInterface_
-
-Provider or account that are used to interact with the network.
+contractFactory.**abi** => _Abi_ (the ABI the contractFactory was constructed with)
 
 ## Methods
 
 contractFactory.**attach**( address ) ⇒ _Contract_
 
-Return an instance of a _Contract_ attached to address. This is the same as using the _Contract_ constructor with address and this _compiledContract_ and _providerOrAccount_ passed in when creating the ContractFactory.
+Return an instance of a _Contract_ attached to address. This is the same as using the _Contract_ constructor with address and this _compiledContract_ and _account_ passed in when creating the ContractFactory.
 
 <hr />
 

package/www/docs/API/provider.md

@@ -141,9 +141,9 @@ Estimate fee for invoke transaction.
 
 <hr/>
 
-provider.**getNonce**(contractAddress, blockIdentifier) => _Promise < BigNumberish >_
+provider.**getNonceForAddress**(contractAddress, blockIdentifier) => _Promise < BigNumberish >_
 
-Gets the nonce of the provided contractAddress.
+Gets the nonce of the provided contractAddress. This was renamed from `getNonce` to `getNonceForAddress` to avoid confusion when inheriting an Account from the Provider class.
 
 <hr/>
 
@@ -242,7 +242,9 @@ Estimate fee for declare transaction.
 
 <hr/>
 
-provider.**waitForTransaction**(txHash [ , retryInterval]) => _Promise < void >_
+### waitForTransaction
+
+provider.**waitForTransaction**(txHash [ , retryInterval]) => _Promise < GetTransactionReceiptResponse >_
 
 Wait for the transaction to be accepted on L2 or L1.
 
@@ -476,12 +478,6 @@ Gets the latest block number.
 
 <hr/>
 
-provider.**getNonce**(contractAddress, blockIdentifier) => _Promise < BigNumberish >_
-
-Gets the nonce of the provided contractAddress
-
-<hr/>
-
 provider.**getPendingTransactions**() => _Promise < PendingTransactions >_
 
 ###### _PendingTransactions_