starknet 2.9.0 → 3.0.0

package/.eslintrc

@@ -18,7 +18,9 @@
   },
   "plugins": ["@typescript-eslint"],
   "rules": {
+    "class-methods-use-this": 0,
     "import/prefer-default-export": 0,
-    "@typescript-eslint/naming-convention": 0
+    "@typescript-eslint/naming-convention": 0,
+    "@typescript-eslint/no-unused-vars": ["error", { "argsIgnorePattern": "^_" }]
   }
 }

package/CHANGELOG.md

@@ -1,3 +1,27 @@
+# [3.0.0](https://github.com/seanjameshan/starknet.js/compare/v2.9.0...v3.0.0) (2022-02-10)
+
+### Bug Fixes
+
+- **account:** dont allow additional signatures in execute ([ac02d46](https://github.com/seanjameshan/starknet.js/commit/ac02d46c5759904886f56a7b9e7e2686dbf52d4c))
+- comments ([f261120](https://github.com/seanjameshan/starknet.js/commit/f261120e1971710cde8f95bd17a5869860db8160))
+- review comments ([ee93bd6](https://github.com/seanjameshan/starknet.js/commit/ee93bd6e51eabcf3507a77d21c5bdc6fe93d5d1c))
+- **test:** remove only for getTransactionReceipt test ([eb11d3b](https://github.com/seanjameshan/starknet.js/commit/eb11d3b60f434f81390f4d13c0462ad8c7ed7321))
+- **types:** change type of `block_number` from `number` to `BlockNumber` in TransactionReceipt ([7a48ff8](https://github.com/seanjameshan/starknet.js/commit/7a48ff8e15a93a778fec62fdff10f92b1a073dec))
+- **types:** update TransactionReceipt type ([9f9f6a2](https://github.com/seanjameshan/starknet.js/commit/9f9f6a2f4cf3b8bfb438edda06ec38bd1471c03d))
+
+### Features
+
+- **account:** introduce execute method ([0be78c6](https://github.com/seanjameshan/starknet.js/commit/0be78c67a40d0b457c571a57a8b49008f5e423de))
+- **contract:** add an option to pass block identifier ([e34dd86](https://github.com/seanjameshan/starknet.js/commit/e34dd86c07495b7b8c38ee410838e15226a7b8d6))
+- new signer and provider interface ([4b2a71c](https://github.com/seanjameshan/starknet.js/commit/4b2a71c578e363b11abb1c3adb74472bbb9f73fe))
+- **provider:** add getTransactionReceipt() ([4267a5f](https://github.com/seanjameshan/starknet.js/commit/4267a5f5cec77bb4b09b2e8b4979ec0ee611d416))
+- split account and signer ([ca4ad9d](https://github.com/seanjameshan/starknet.js/commit/ca4ad9d62aee8b0637096eb3059e96dd4407f663))
+- update readme ([ed021dc](https://github.com/seanjameshan/starknet.js/commit/ed021dc25a394affec8ea92ed79eed4c68a040d8))
+
+### BREAKING CHANGES
+
+- new provider and signer interfaces
+
 # [2.9.0](https://github.com/seanjameshan/starknet.js/compare/v2.8.0...v2.9.0) (2022-02-04)
 
 ### Bug Fixes

package/README.md

@@ -40,6 +40,8 @@ Install starknet with `npm`
 
 ```bash
 $ npm install starknet
+# or
+$ npm install starknet@next
 ```
 
 Import `starknet` and use the [API](https://www.starknetjs.com/modules.html)
@@ -54,16 +56,18 @@ const CONTRACT_ADDRESS =
   "0x03e19baa6cb2078631bcdb34844f3f7879449a544c9ce722681a54af08cff4b9";
 
 /**
- * addTransaction() example
+ * invokeFunction() example
 **/
 
 /** Reset the liquidity pool **/
-const addTokenResponse = await defaultProvider.addTransaction({
-  type: "INVOKE_FUNCTION",
-  contract_address: CONTRACT_ADDRESS,
-  entry_point_selector: getSelectorFromName("init_pool"),
-  calldata: ["1000000", "1000000"],
-});
+const addTokenResponse = await defaultProvider.invokeFunction(
+  {
+    contractAddress: CONTRACT_ADDRESS,
+    entrypoint: "init_pool",
+    calldata: ["1000000", "1000000"],
+  },
+  abi // for displaying purposes only (default implementation has no display/ui)
+);
 console.log(addTokenResponse);
 
 /**
@@ -72,8 +76,8 @@ console.log(addTokenResponse);
 
 /** Get the balance of the liquidity pool of token A **/
 const poolBalanceTokenA = await defaultProvider.callContract({
-  contract_address: CONTRACT_ADDRESS,
-  entry_point_selector: getSelectorFromName("get_pool_token_balance"),
+  contractAddress: CONTRACT_ADDRESS,
+  entrypoint: "get_pool_token_balance",
   calldata: ["1"],
 });
 const balanceA = poolBalanceTokenA.result[0];
@@ -81,16 +85,14 @@ console.log('token a liquidity pool balance: ', parseInt(balanceA, 16));
 
 /** Get the balance of the liquidity pool of token B **/
 const poolBalanceTokenB = await defaultProvider.callContract({
-  contract_address: CONTRACT_ADDRESS,
-  entry_point_selector: getSelectorFromName("get_pool_token_balance"),
+  contractAddress: CONTRACT_ADDRESS,
+  entrypoint: "get_pool_token_balance",
   calldata: ["2"],
 });
 const balanceB = poolBalanceTokenB.result[0];
 console.log('token b liquidity pool balance: ', parseInt(balanceB, 16));
 ```
 
-For more information about **signing transactions**, please take a look at this [pull request](https://github.com/seanjameshan/starknet.js/pull/51)
-
 ## 🌐 API
 
 [Click Here](https://www.starknetjs.com/modules.html)
@@ -113,6 +115,6 @@ This library would not be possible without these rockstars.
 
 ## 📜 License
 
-Copyright (c) 2021 Sean James Han
+Copyright (c) 2022 0xs34n
 
 Licensed under the [MIT license](https://github.com/seanjameshan/starknet.js/blob/main/LICENSE).

package/__tests__/account.test.ts

@@ -1,36 +1,18 @@
 import fs from 'fs';
 
+import typedDataExample from '../__mocks__/typedDataExample.json';
 import {
+  Account,
   CompiledContract,
   Contract,
   compileCalldata,
   defaultProvider,
   ec,
-  encode,
-  hash,
   json,
   number,
   stark,
 } from '../src';
-
-describe('getStarkAccountFromPrivateKey()', () => {
-  test('it works with valid privateKey', () => {
-    const privateKey = '0xb696427c0d79c5d28a1fa6f748bae1b98b3f4b86bd1a2505bab144673c856fa9';
-
-    const starkKeyPair = ec.getKeyPair(privateKey);
-    const starkKey = ec.getStarkKey(starkKeyPair);
-
-    expect(starkKey).toBe('0x060d46f8d7ef3d83ed05f3ed9beb91e22f9529289b9d863683fd71eafaf28035');
-  });
-  test('it works with valid privateKey', () => {
-    const privateKey = '0x5f65099e269b080000000000000000000000000000000000000000000000000';
-
-    const starkKeyPair = ec.getKeyPair(privateKey);
-    const starkKey = ec.getStarkKey(starkKeyPair);
-
-    expect(starkKey).toBe('0xf321e59b257a577836d8313150aabd21f412491358c329966218df76bab591');
-  });
-});
+import { toBN } from '../src/utils/number';
 
 const compiledArgentAccount: CompiledContract = json.parse(
   fs.readFileSync('./__mocks__/ArgentAccount.json').toString('ascii')
@@ -44,31 +26,30 @@ describe('deploy and test Wallet', () => {
 
   const starkKeyPair = ec.getKeyPair(privateKey);
   const starkKeyPub = ec.getStarkKey(starkKeyPair);
-  let wallet: Contract;
   let walletAddress: string;
   let erc20: Contract;
   let erc20Address: string;
+  let account: Account;
+
   beforeAll(async () => {
-    const { code: codeErc20, address: erc20AddressLocal } = await defaultProvider.deployContract(
-      compiledErc20,
-      []
-    );
+    const { code: codeErc20, address: erc20AddressLocal } = await defaultProvider.deployContract({
+      contract: compiledErc20,
+    });
     erc20Address = erc20AddressLocal;
     erc20 = new Contract(compiledErc20.abi, erc20Address);
 
     expect(codeErc20).toBe('TRANSACTION_RECEIVED');
 
-    const { code, address: walletAddressLocal } = await defaultProvider.deployContract(
-      compiledArgentAccount,
-      compileCalldata({
+    const { code, address: walletAddressLocal } = await defaultProvider.deployContract({
+      contract: compiledArgentAccount,
+      constructorCalldata: compileCalldata({
         signer: starkKeyPub,
         guardian: '0',
         L1_address: '0',
       }),
-      starkKeyPub
-    );
+      addressSalt: starkKeyPub,
+    });
     walletAddress = walletAddressLocal;
-    wallet = new Contract(compiledArgentAccount.abi, walletAddress);
     expect(code).toBe('TRANSACTION_RECEIVED');
 
     const { code: codeErc20Mint, transaction_hash: txErc20Mint } = await erc20.invoke('mint', {
@@ -78,12 +59,21 @@ describe('deploy and test Wallet', () => {
 
     expect(codeErc20Mint).toBe('TRANSACTION_RECEIVED');
 
+    account = new Account(defaultProvider, walletAddressLocal, starkKeyPair);
+
     await defaultProvider.waitForTx(txErc20Mint);
   });
+  test('same wallet address', () => {
+    expect(walletAddress).toBe(account.address);
+  });
   test('read nonce', async () => {
-    const { nonce } = await wallet.call('get_nonce');
+    const { result } = await account.callContract({
+      contractAddress: account.address,
+      entrypoint: 'get_nonce',
+    });
+    const nonce = result[0];
 
-    expect(number.toBN(nonce as string).toString()).toStrictEqual(number.toBN(0).toString());
+    expect(number.toBN(nonce).toString()).toStrictEqual(number.toBN(0).toString());
   });
   test('read balance of wallet', async () => {
     const { res } = await erc20.call('balance_of', {
@@ -93,31 +83,13 @@ describe('deploy and test Wallet', () => {
     expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(1000).toString());
   });
   test('execute by wallet owner', async () => {
-    const { nonce } = await wallet.call('get_nonce');
-    const msgHash = encode.addHexPrefix(
-      hash.hashMessage(
-        wallet.connectedTo,
-        erc20Address,
-        stark.getSelectorFromName('transfer'),
-        [erc20Address, '10'],
-        nonce.toString()
-      )
-    );
-
-    const signature = ec.sign(starkKeyPair, msgHash);
-    const { code, transaction_hash } = await wallet.invoke(
-      'execute',
-      {
-        to: erc20Address,
-        selector: stark.getSelectorFromName('transfer'),
-        calldata: [erc20Address, '10'],
-        nonce: nonce.toString(),
-      },
-      signature
-    );
+    const { code, transaction_hash } = await account.execute({
+      contractAddress: erc20Address,
+      entrypoint: 'transfer',
+      calldata: [toBN(erc20Address).toString(), '10'],
+    });
 
     expect(code).toBe('TRANSACTION_RECEIVED');
-
     await defaultProvider.waitForTx(transaction_hash);
   });
   test('read balance of wallet after transfer', async () => {
@@ -127,35 +99,28 @@ describe('deploy and test Wallet', () => {
 
     expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(990).toString());
   });
-});
+  test('execute with custom nonce', async () => {
+    const { result } = await account.callContract({
+      contractAddress: account.address,
+      entrypoint: 'get_nonce',
+    });
+    const nonce = toBN(result[0]).toNumber();
+    const { code, transaction_hash } = await account.execute(
+      {
+        contractAddress: erc20Address,
+        entrypoint: 'transfer',
+        calldata: [toBN(erc20Address).toString(), '10'],
+      },
+      undefined,
+      { nonce }
+    );
+
+    expect(code).toBe('TRANSACTION_RECEIVED');
+    await defaultProvider.waitForTx(transaction_hash);
+  });
+  test('sign and verify offchain message', async () => {
+    const signature = await account.signMessage(typedDataExample);
 
-test('build tx', async () => {
-  const privateKey = '0x1B69B4BE052FAB1';
-  const keyPair = ec.getKeyPair(privateKey);
-  const address = ec.getStarkKey(keyPair);
-
-  expect(address).toBe('0x04024999b9574cb7623679ce049a609db62a95098982c5b28ac61abdebd1c82b');
-
-  const selector = stark.getSelectorFromName('transfer');
-
-  expect(selector).toBe(
-    number.toHex(
-      number.toBN('232670485425082704932579856502088130646006032362877466777181098476241604910')
-    )
-  );
-
-  const msgHash = hash.hashMessage(address, '1', selector, ['6', '7'], '0');
-  expect(number.toBN(msgHash).toString()).toStrictEqual(
-    number
-      .toBN('2154230509011102177917341711834485670139815171447919056633262592518907948680')
-      .toString()
-  );
-
-  const [r, s] = ec.sign(keyPair, msgHash);
-  expect(r.toString()).toBe(
-    '706800951915233622090196542158919402159816118214143837213294331713137614072'
-  );
-  expect(s.toString()).toBe(
-    '1857147121895075123389037565321926580259282654271568123966453051614350474888'
-  );
+    expect(await account.verifyMessage(typedDataExample, signature)).toBe(true);
+  });
 });

package/__tests__/accountContract.test.ts

@@ -0,0 +1,160 @@
+import fs from 'fs';
+
+import {
+  CompiledContract,
+  Contract,
+  compileCalldata,
+  defaultProvider,
+  ec,
+  encode,
+  hash,
+  json,
+  number,
+  stark,
+} from '../src';
+
+describe('getStarkAccountFromPrivateKey()', () => {
+  test('it works with valid privateKey', () => {
+    const privateKey = '0xb696427c0d79c5d28a1fa6f748bae1b98b3f4b86bd1a2505bab144673c856fa9';
+
+    const starkKeyPair = ec.getKeyPair(privateKey);
+    const starkKey = ec.getStarkKey(starkKeyPair);
+
+    expect(starkKey).toBe('0x060d46f8d7ef3d83ed05f3ed9beb91e22f9529289b9d863683fd71eafaf28035');
+  });
+  test('it works with valid privateKey', () => {
+    const privateKey = '0x5f65099e269b080000000000000000000000000000000000000000000000000';
+
+    const starkKeyPair = ec.getKeyPair(privateKey);
+    const starkKey = ec.getStarkKey(starkKeyPair);
+
+    expect(starkKey).toBe('0xf321e59b257a577836d8313150aabd21f412491358c329966218df76bab591');
+  });
+});
+
+const compiledArgentAccount: CompiledContract = json.parse(
+  fs.readFileSync('./__mocks__/ArgentAccount.json').toString('ascii')
+);
+const compiledErc20: CompiledContract = json.parse(
+  fs.readFileSync('./__mocks__/ERC20.json').toString('ascii')
+);
+
+describe('deploy and test Wallet', () => {
+  const privateKey = stark.randomAddress();
+
+  const starkKeyPair = ec.getKeyPair(privateKey);
+  const starkKeyPub = ec.getStarkKey(starkKeyPair);
+  let wallet: Contract;
+  let walletAddress: string;
+  let erc20: Contract;
+  let erc20Address: string;
+  beforeAll(async () => {
+    const { code: codeErc20, address: erc20AddressLocal } = await defaultProvider.deployContract({
+      contract: compiledErc20,
+    });
+    erc20Address = erc20AddressLocal;
+    erc20 = new Contract(compiledErc20.abi, erc20Address);
+
+    expect(codeErc20).toBe('TRANSACTION_RECEIVED');
+
+    const { code, address: walletAddressLocal } = await defaultProvider.deployContract({
+      contract: compiledArgentAccount,
+      constructorCalldata: compileCalldata({
+        signer: starkKeyPub,
+        guardian: '0',
+        L1_address: '0',
+      }),
+      addressSalt: starkKeyPub,
+    });
+    walletAddress = walletAddressLocal;
+    wallet = new Contract(compiledArgentAccount.abi, walletAddress);
+    expect(code).toBe('TRANSACTION_RECEIVED');
+
+    const { code: codeErc20Mint, transaction_hash: txErc20Mint } = await erc20.invoke('mint', {
+      recipient: walletAddress,
+      amount: '1000',
+    });
+
+    expect(codeErc20Mint).toBe('TRANSACTION_RECEIVED');
+
+    await defaultProvider.waitForTx(txErc20Mint);
+  });
+  test('read nonce', async () => {
+    const { nonce } = await wallet.call('get_nonce');
+
+    expect(number.toBN(nonce as string).toString()).toStrictEqual(number.toBN(0).toString());
+  });
+  test('read balance of wallet', async () => {
+    const { res } = await erc20.call('balance_of', {
+      user: walletAddress,
+    });
+
+    expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(1000).toString());
+  });
+  test('execute by wallet owner', async () => {
+    const { nonce } = await wallet.call('get_nonce');
+    const msgHash = encode.addHexPrefix(
+      hash.hashMessage(
+        wallet.connectedTo,
+        erc20Address,
+        stark.getSelectorFromName('transfer'),
+        [erc20Address, '10'],
+        nonce.toString()
+      )
+    );
+
+    const signature = ec.sign(starkKeyPair, msgHash);
+    const { code, transaction_hash } = await wallet.invoke(
+      'execute',
+      {
+        to: erc20Address,
+        selector: stark.getSelectorFromName('transfer'),
+        calldata: [erc20Address, '10'],
+        nonce: nonce.toString(),
+      },
+      signature
+    );
+
+    expect(code).toBe('TRANSACTION_RECEIVED');
+
+    await defaultProvider.waitForTx(transaction_hash);
+  });
+  test('read balance of wallet after transfer', async () => {
+    const { res } = await erc20.call('balance_of', {
+      user: walletAddress,
+    });
+
+    expect(number.toBN(res as string).toString()).toStrictEqual(number.toBN(990).toString());
+  });
+});
+
+test('build tx', async () => {
+  const privateKey = '0x1B69B4BE052FAB1';
+  const keyPair = ec.getKeyPair(privateKey);
+  const address = ec.getStarkKey(keyPair);
+
+  expect(address).toBe('0x04024999b9574cb7623679ce049a609db62a95098982c5b28ac61abdebd1c82b');
+
+  const selector = stark.getSelectorFromName('transfer');
+
+  expect(selector).toBe(
+    number.toHex(
+      number.toBN('232670485425082704932579856502088130646006032362877466777181098476241604910')
+    )
+  );
+
+  const msgHash = hash.hashMessage(address, '1', selector, ['6', '7'], '0');
+  expect(number.toBN(msgHash).toString()).toStrictEqual(
+    number
+      .toBN('2154230509011102177917341711834485670139815171447919056633262592518907948680')
+      .toString()
+  );
+
+  const [r, s] = ec.sign(keyPair, msgHash);
+  expect(r.toString()).toBe(
+    '706800951915233622090196542158919402159816118214143837213294331713137614072'
+  );
+  expect(s.toString()).toBe(
+    '1857147121895075123389037565321926580259282654271568123966453051614350474888'
+  );
+});

package/__tests__/contract.test.ts

@@ -14,7 +14,9 @@ describe('class Contract {}', () => {
       code,
       transaction_hash,
       address: erc20address,
-    } = await defaultProvider.deployContract(compiledERC20, []);
+    } = await defaultProvider.deployContract({
+      contract: compiledERC20,
+    });
 
     contract = new Contract(compiledERC20.abi, erc20address);
 

package/__tests__/jest.setup.ts

@@ -0,0 +1,9 @@
+import axios from 'axios';
+import * as AxiosLogger from 'axios-logger';
+
+jest.setTimeout(50 * 60 * 1000);
+
+if (process.env.DEBUG === 'true') {
+  axios.interceptors.request.use(AxiosLogger.requestLogger, AxiosLogger.errorLogger);
+  axios.interceptors.response.use(AxiosLogger.responseLogger, AxiosLogger.errorLogger);
+}

package/__tests__/provider.test.ts

@@ -76,11 +76,20 @@ describe('defaultProvider', () => {
         )
       ).resolves.not.toThrow();
     });
+
+    test('getTransactionReceipt', async () => {
+      return expect(
+        defaultProvider.getTransactionReceipt({
+          txHash: '0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348',
+        })
+      ).resolves.not.toThrow();
+    });
+
     test('callContract()', () => {
       return expect(
         defaultProvider.callContract({
-          contract_address: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
-          entry_point_selector: stark.getSelectorFromName('balance_of'),
+          contractAddress: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
+          entrypoint: 'balance_of',
           calldata: compileCalldata({
             user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
           }),
@@ -90,45 +99,21 @@ describe('defaultProvider', () => {
   });
 
   describe('addTransaction()', () => {
-    test('type: "DEPLOY"', async () => {
+    test('deployContract()', async () => {
       const inputContract = compiledArgentAccount as unknown as CompiledContract;
 
-      const contractDefinition = {
-        ...inputContract,
-        program: stark.compressProgram(inputContract.program),
-      };
-
-      const response = await defaultProvider.addTransaction({
-        type: 'DEPLOY',
-        contract_address_salt: stark.randomAddress(),
-        constructor_calldata: compileCalldata({
+      const response = await defaultProvider.deployContract({
+        contract: inputContract,
+        constructorCalldata: compileCalldata({
           signer: stark.randomAddress(),
           guardian: '0',
           L1_address: '0',
         }),
-        contract_definition: contractDefinition,
       });
 
       expect(response.code).toBe('TRANSACTION_RECEIVED');
       expect(response.transaction_hash).toBeDefined();
       expect(response.address).toBeDefined();
     });
-
-    test('deployContract()', async () => {
-      const inputContract = compiledArgentAccount as unknown as CompiledContract;
-
-      const response = await defaultProvider.deployContract(
-        inputContract,
-        compileCalldata({
-          signer: stark.randomAddress(),
-          guardian: '0',
-          L1_address: '0',
-        })
-      );
-
-      expect(response.code).toBe('TRANSACTION_RECEIVED');
-      expect(response.transaction_hash).toBeDefined();
-      expect(response.address).toBeDefined();
-    });
   });
 });

package/account/default.d.ts

@@ -0,0 +1,66 @@
+import { Provider } from '../provider';
+import {
+  Abi,
+  AddTransactionResponse,
+  ExecuteInvocation,
+  InvocationsDetails,
+  KeyPair,
+  Signature,
+} from '../types';
+import { BigNumberish } from '../utils/number';
+import { TypedData } from '../utils/typedData';
+import { AccountInterface } from './interface';
+export declare class Account extends Provider implements AccountInterface {
+  address: string;
+  private signer;
+  constructor(provider: Provider, address: string, keyPair: KeyPair);
+  getNonce(): Promise<string>;
+  /**
+   * 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 transaction - transaction to be invoked
+   * @returns a confirmation of invoking a function on the starknet contract
+   */
+  execute(
+    transactions: ExecuteInvocation | ExecuteInvocation[],
+    abis?: Abi[],
+    transactionsDetail?: InvocationsDetails
+  ): 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 JSON object
+   *
+   * @param json - 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 given hash
+   * @warning This method is not recommended, use verifyMessage instead
+   *
+   * @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>;
+}