Merge pull request #166 from 0xs34n/feature/new-hash-formular-for-accounts

Author: janek26

__mocks__/ArgentAccount.json

@@ -1,4 +1,11 @@
 import { Contract, defaultProvider, ec, hash, number, stark } from '../src';
+import { StarknetChainId } from '../src/constants';
+import {
+  calculcateTransactionHash,
+  getSelectorFromName,
+  transactionVersion,
+} from '../src/utils/hash';
+import { fromCallsToExecuteCalldataWithNonce } from '../src/utils/transaction';
 import { compiledArgentAccount, compiledErc20 } from './fixtures';
 
 describe('getStarkAccountFromPrivateKey()', () => {
@@ -20,6 +27,41 @@ describe('getStarkAccountFromPrivateKey()', () => {
   });
 });
 
+test('build tx', async () => {
+  const privateKey = '0x1B69B4BE052FAB1';
+  const keyPair = ec.getKeyPair(privateKey);
+  const address = ec.getStarkKey(keyPair);
+
+  expect(address).toBe('0x04024999b9574cb7623679ce049a609db62a95098982c5b28ac61abdebd1c82b');
+
+  const selector = hash.getSelectorFromName('transfer');
+
+  expect(selector).toMatchInlineSnapshot();
+
+  const calls = [{ contractAddress: '1', entrypoint: 'transfer', calldata: ['6', '7'] }];
+  const calldata = fromCallsToExecuteCalldataWithNonce(calls, 0);
+
+  const msgHash = calculcateTransactionHash(
+    address,
+    transactionVersion,
+    getSelectorFromName('__execute__'),
+    calldata,
+    0,
+    StarknetChainId.TESTNET
+  );
+  expect(number.toBN(msgHash).toString()).toMatchInlineSnapshot(
+    `"235855380881994314533025886817815774848495061484535023348790852315407085619"`
+  );
+
+  const [r, s] = ec.sign(keyPair, msgHash);
+  expect(r.toString()).toMatchInlineSnapshot(
+    `"181489288548431284937202760565682158657883789985879744111612429574110648095"`
+  );
+  expect(s.toString()).toMatchInlineSnapshot(
+    `"2055384802167699202203509702082340762385659879831017273872106910763470114538"`
+  );
+});
+
 describe('deploy and test Wallet', () => {
   const privateKey = stark.randomAddress();
 
@@ -64,35 +106,3 @@ describe('deploy and test Wallet', () => {
     expect(res).toStrictEqual(number.toBN(1000));
   });
 });
-
-test('build tx', async () => {
-  const privateKey = '0x1B69B4BE052FAB1';
-  const keyPair = ec.getKeyPair(privateKey);
-  const address = ec.getStarkKey(keyPair);
-
-  expect(address).toBe('0x04024999b9574cb7623679ce049a609db62a95098982c5b28ac61abdebd1c82b');
-
-  const selector = hash.getSelectorFromName('transfer');
-
-  expect(selector).toBe(
-    number.toHex(
-      number.toBN('232670485425082704932579856502088130646006032362877466777181098476241604910')
-    )
-  );
-
-  const calls = [{ contractAddress: '1', entrypoint: 'transfer', calldata: ['6', '7'] }];
-  const msgHash = hash.hashMulticall(address, calls, '0', '0');
-  expect(number.toBN(msgHash).toString()).toStrictEqual(
-    number
-      .toBN('533725737276146993132325070982049323585915612981489962412873515411469143806')
-      .toString()
-  );
-
-  const [r, s] = ec.sign(keyPair, msgHash);
-  expect(r.toString()).toBe(
-    '3081830197073374427897814075820860503521735760640862828374253887454357679197'
-  );
-  expect(s.toString()).toBe(
-    '384293936273611705317490990661155378189310283917528660618713929845936492551'
-  );
-});

__tests__/accountContract.test.ts

@@ -4,8 +4,12 @@ import { Account, Contract, ContractFactory, Provider, defaultProvider, ec, star
 import { getSelectorFromName } from '../src/utils/hash';
 import { BigNumberish, toBN } from '../src/utils/number';
 import { compileCalldata } from '../src/utils/stark';
-import { ACCOUNT_ADDRESS, PRIVATE_KEY } from './constancts';
-import { compiledErc20, compiledMulticall, compiledTypeTransformation } from './fixtures';
+import {
+  compiledArgentAccount,
+  compiledErc20,
+  compiledMulticall,
+  compiledTypeTransformation,
+} from './fixtures';
 
 describe('class Contract {}', () => {
   const wallet = stark.randomAddress();
@@ -204,21 +208,29 @@ describe('class Contract {}', () => {
   });
 
   describe('Contract interaction with Account', () => {
-    const starkKeyPair = ec.getKeyPair(PRIVATE_KEY);
     let account: Account;
     let erc20: Contract;
     let erc20Address: string;
 
     beforeAll(async () => {
-      account = new Account(defaultProvider, ACCOUNT_ADDRESS, starkKeyPair);
+      const starkKeyPair = ec.genKeyPair();
+      const starkKeyPub = ec.getStarkKey(starkKeyPair);
+      const { address } = await defaultProvider.deployContract({
+        contract: compiledArgentAccount,
+        addressSalt: starkKeyPub,
+      });
+      expect(address).toBeDefined();
+      account = new Account(defaultProvider, address, starkKeyPair);
+      const accountContract = new Contract(compiledArgentAccount.abi, address);
+      await accountContract.initialize(starkKeyPub, '0');
 
       const erc20Response = await defaultProvider.deployContract({
         contract: compiledErc20,
       });
       erc20Address = erc20Response.address;
       erc20 = new Contract(compiledErc20.abi, erc20Address, defaultProvider);
-      await defaultProvider.waitForTransaction(erc20Response.transaction_hash);
       expect(erc20Response.code).toBe('TRANSACTION_RECEIVED');
+      await defaultProvider.waitForTransaction(erc20Response.transaction_hash);
 
       const mintResponse = await erc20.mint(account.address, '1000');
 
@@ -251,7 +263,9 @@ describe('class Contract {}', () => {
     });
 
     test('invoke contract by wallet owner', async () => {
-      const { transaction_hash, code } = await erc20.transfer(toBN(erc20Address).toString(), 10);
+      const { transaction_hash, code } = await erc20.transfer(erc20Address, 10, {
+        maxFee: 0,
+      });
       expect(code).toBe('TRANSACTION_RECEIVED');
       await defaultProvider.waitForTransaction(transaction_hash);
       const { res } = await erc20.balance_of(account.address);

__tests__/constancts.ts

@@ -1,7 +1,15 @@
+import { StarknetChainId } from '../../src/constants';
 import { ec, getKeyPair, getStarkKey, sign, verify } from '../../src/utils/ellipticCurve';
 import { removeHexPrefix } from '../../src/utils/encode';
-import { computeHashOnElements, hashMulticall, pedersen } from '../../src/utils/hash';
+import {
+  calculcateTransactionHash,
+  computeHashOnElements,
+  getSelectorFromName,
+  pedersen,
+  transactionVersion,
+} from '../../src/utils/hash';
 import { toBN, toHex } from '../../src/utils/number';
+import { fromCallsToExecuteCalldataWithNonce } from '../../src/utils/transaction';
 
 test('getKeyPair()', () => {
   const privateKey = '0x019800ea6a9a73f94aee6a3d2edf018fc770443e90c7ba121e8303ec6b349279';
@@ -42,17 +50,27 @@ test('hashMessage()', () => {
   ];
   const nonce = '3';
   const maxFee = '0';
-  const hashMsg = hashMulticall(account, transactions, nonce, maxFee);
-  expect(hashMsg).toBe(
-    toHex(toBN('1608351043472325350463069815257733118091727529101532499046754244230898025592'))
+  const calldata = fromCallsToExecuteCalldataWithNonce(transactions, nonce);
+
+  const hashMsg = calculcateTransactionHash(
+    account,
+    transactionVersion,
+    getSelectorFromName('__execute__'),
+    calldata,
+    maxFee,
+    StarknetChainId.TESTNET
+  );
+
+  expect(hashMsg).toMatchInlineSnapshot(
+    `"0x4c337c6bf32b2cf2b8ae54064e4b982c214660e8d0423b431a3fde10b9b9c02"`
   );
   const keyPair = getKeyPair(privateKey);
   const [r, s] = sign(keyPair, removeHexPrefix(hashMsg));
-  expect(r.toString()).toStrictEqual(
-    toBN('1079537730825246752292590270213864261175133133352510235773017189606850691611').toString()
+  expect(r.toString()).toMatchInlineSnapshot(
+    `"1944132633844378384908742523072599391732300777648030785844673145513474741467"`
   );
-  expect(s.toString()).toStrictEqual(
-    toBN('2904560423220491364719171767721067837294296476624248675613584621502231297000').toString()
+  expect(s.toString()).toMatchInlineSnapshot(
+    `"1067771353159635307522498807851959257107695451405842425488451092336556917559"`
   );
 });
 

__tests__/contract.test.ts

@@ -0,0 +1,17 @@
+import { StarknetChainId, TransactionHashPrefix } from '../../src/constants';
+import { calculateTransactionHashCommon } from '../../src/utils/hash';
+
+describe('calculateTransactionHashCommon()', () => {
+  test('should match most simple python output', () => {
+    const result = calculateTransactionHashCommon(
+      TransactionHashPrefix.INVOKE,
+      '0x0',
+      '0x2a',
+      '0x64',
+      [],
+      '0x0',
+      StarknetChainId.TESTNET
+    );
+    expect(result).toBe('0x7d260744de9d8c55e7675a34512d1951a7b262c79e685d26599edd2948de959');
+  });
+});

__tests__/utils/__snapshots__/utils.browser.test.ts.snap

@@ -1,5 +1,6 @@
 import assert from 'minimalistic-assert';
 
+import { ZERO } from '../constants';
 import { Provider } from '../provider';
 import { BlockIdentifier } from '../provider/utils';
 import { Signer, SignerInterface } from '../signer';
@@ -9,6 +10,7 @@ import {
   Call,
   EstimateFeeResponse,
   InvocationsDetails,
+  InvocationsSignerDetails,
   InvokeFunctionTransaction,
   KeyPair,
   Signature,
@@ -19,12 +21,12 @@ import {
   computeHashOnElements,
   feeTransactionVersion,
   getSelectorFromName,
-  transactionPrefix,
   transactionVersion,
 } from '../utils/hash';
 import { BigNumberish, bigNumberishArrayToDecimalStringArray, toBN, toHex } from '../utils/number';
+import { encodeShortString } from '../utils/shortString';
 import { compileCalldata, estimatedFeeToMaxFee } from '../utils/stark';
-import { fromCallsToExecuteCalldata } from '../utils/transaction';
+import { fromCallsToExecuteCalldataWithNonce } from '../utils/transaction';
 import { TypedData, getMessageHash } from '../utils/typedData';
 import { AccountInterface } from './interface';
 
@@ -58,15 +60,18 @@ export class Account extends Provider implements AccountInterface {
     const transactions = Array.isArray(calls) ? calls : [calls];
     const nonce = providedNonce ?? (await this.getNonce());
     const version = toBN(feeTransactionVersion);
-    const signerDetails = {
+
+    const signerDetails: InvocationsSignerDetails = {
       walletAddress: this.address,
       nonce: toBN(nonce),
-      maxFee: toBN('0'),
+      maxFee: ZERO,
       version,
+      chainId: this.chainId,
     };
+
     const signature = await this.signer.signTransaction(transactions, signerDetails);
 
-    const calldata = [...fromCallsToExecuteCalldata(transactions), signerDetails.nonce.toString()];
+    const calldata = fromCallsToExecuteCalldataWithNonce(transactions, nonce);
     return this.fetchEndpoint(
       'estimate_fee',
       { blockIdentifier },
@@ -96,22 +101,24 @@ export class Account extends Provider implements AccountInterface {
     const transactions = Array.isArray(calls) ? calls : [calls];
     const nonce = toBN(transactionsDetail.nonce ?? (await this.getNonce()));
     let maxFee: BigNumberish = '0';
-    if (transactionsDetail.maxFee) {
+    if (transactionsDetail.maxFee || transactionsDetail.maxFee === 0) {
       maxFee = transactionsDetail.maxFee;
     } else {
       const estimatedFee = (await this.estimateFee(transactions, { nonce })).amount;
       maxFee = estimatedFeeToMaxFee(estimatedFee).toString();
     }
-    const signerDetails = {
+
+    const signerDetails: InvocationsSignerDetails = {
       walletAddress: this.address,
       nonce,
       maxFee,
       version: toBN(transactionVersion),
+      chainId: this.chainId,
     };
 
     const signature = await this.signer.signTransaction(transactions, signerDetails, abis);
 
-    const calldata = [...fromCallsToExecuteCalldata(transactions), signerDetails.nonce.toString()];
+    const calldata = fromCallsToExecuteCalldataWithNonce(transactions, nonce);
     return this.fetchEndpoint('add_transaction', undefined, {
       type: 'INVOKE_FUNCTION',
       contract_address: this.address,
@@ -161,7 +168,7 @@ export class Account extends Provider implements AccountInterface {
         .map(computeHashOnElements);
 
       return computeHashOnElements([
-        transactionPrefix,
+        encodeShortString('StarkNet Transaction'),
         account,
         computeHashOnElements(hashArray),
         nonce,