feat: wip

__tests__/ec.test.ts

@@ -0,0 +1,51 @@
+import { pedersen as pedersenReal } from '@authereum/starkware-crypto';
+import { BigNumber } from '@ethersproject/bignumber';
+import { ensure0x, ensureNo0x, hashCalldata, hashMessage } from '../src';
+import { getKeyPair, getStarkKey, pedersen, sign } from '../src/ec';
+
+test('does work with package', () => {
+ const pk = '0x019800ea6a9a73f94aee6a3d2edf018fc770443e90c7ba121e8303ec6b349279';
+ const pair = getKeyPair(pk);
+ // somehow needed, returns error else
+ expect(BigNumber.from(getStarkKey(pair)).toHexString()).toBe(
+ '0x033f45f07e1bd1a51b45fc24ec8c8c9908db9e42191be9e169bfcac0c0d99745'
+ );
+});
+
+test('pedersen', () => {
+ const real = ensure0x(pedersenReal(['0x12773', '0x872362']));
+ const own = pedersen(['0x12773', '0x872362']);
+ // somehow needed, returns error else
+ expect(own).toBe(real);
+});
+
+test('hashCalldata()', () => {
+ const array = ['1', '2', '3', '4'];
+ expect(hashCalldata(array)).toBe(
+ '0x1439c58e1c389a2ac51f8462ecc0a4ec7f812be1c04e3b82ce2af1c2cf959ef'
+ );
+ expect(array).toStrictEqual(['1', '2', '3', '4']);
+
+ expect(hashCalldata(['1', '2'])).toBe(
+ '0x2ab889bd35e684623df9b4ea4a4a1f6d9e0ef39b67c1293b8a89dd17e351235'
+ );
+});
+test('hashMessage()', () => {
+ const pk = '0x019800ea6a9a73f94aee6a3d2edf018fc770443e90c7ba121e8303ec6b349279';
+ const hashMsg = hashMessage(
+ '0x33f45f07e1bd1a51b45fc24ec8c8c9908db9e42191be9e169bfcac0c0d99745',
+ '5',
+ '6',
+ ['1', '2'],
+ '2'
+ );
+ expect(hashMsg).toBe('0xf7ec4a68876819eed838be83b5d5dc337081f4a5fb8e421f3d9bdef7c69e9b');
+ const keyPair = getKeyPair(pk);
+ const { r, s } = sign(keyPair, ensureNo0x(hashMsg));
+ expect(BigNumber.from(ensure0x(r.toString('hex')))).toStrictEqual(
+ BigNumber.from('2699852629692218907583414128365108566181098618321049245303767746418549764831')
+ );
+ expect(BigNumber.from(ensure0x(s.toString('hex')))).toStrictEqual(
+ BigNumber.from('2362979021721299440845279407227912881357338080403308888611869245024056250189')
+ );
+});

__tests__/math.test.ts

@@ -0,0 +1,54 @@
+import { getKeyPair, getStarkKey, getStarkPublicKey } from '@authereum/starkware-crypto';
+import { BigNumber } from '@ethersproject/bignumber';
+import { ensure0x, ensureNo0x } from '../src';
+import { ecAdd, igcdex, privateToStarkKey } from '../src/math';
+
+describe('igcdex()', () => {
+ test('works with (0, 0)', () => {
+ const result = igcdex(BigNumber.from(0), BigNumber.from(0));
+
+ expect(result).toStrictEqual([BigNumber.from(0), BigNumber.from(1), BigNumber.from(0)]);
+ });
+ test('works with (0, 2004)', () => {
+ const result = igcdex(BigNumber.from(0), BigNumber.from(2004));
+
+ expect(result).toStrictEqual([BigNumber.from(0), BigNumber.from(1), BigNumber.from(2004)]);
+ });
+ test('works with (100, 0)', () => {
+ const result = igcdex(BigNumber.from(100), BigNumber.from(0));
+
+ expect(result).toStrictEqual([BigNumber.from(1), BigNumber.from(0), BigNumber.from(100)]);
+ });
+ test('works with (100, 2004)', () => {
+ const result = igcdex(BigNumber.from(100), BigNumber.from(2004));
+
+ expect(result).toStrictEqual([BigNumber.from(-20), BigNumber.from(1), BigNumber.from(4)]);
+ });
+});
+describe('ecAdd()', () => {
+ test('works with ([10,20], [21,32], 5)', () => {
+ const result = ecAdd(
+ [BigNumber.from(10), BigNumber.from(20)],
+ [BigNumber.from(21), BigNumber.from(32)],
+ BigNumber.from(5)
+ );
+ expect(result).toStrictEqual([BigNumber.from(3), BigNumber.from(4)]);
+ });
+});
+describe('privateToStarkKey()', () => {
+ test('works with valid pk', () => {
+ const pk = '0x019800ea6a9a73f94aee6a3d2edf018fc770443e90c7ba121e8303ec6b349279';
+ const pub = privateToStarkKey(pk);
+
+ expect(pub).toBe('0x033f45f07e1bd1a51b45fc24ec8c8c9908db9e42191be9e169bfcac0c0d99745');
+ });
+ test('doesnt work with package', () => {
+ const pk = ensureNo0x('0x019800ea6a9a73f94aee6a3d2edf018fc770443e90c7ba121e8303ec6b349279');
+ const pair = getKeyPair(pk);
+ // somehow needed, returns error else
+ getStarkPublicKey(pair);
+ expect(BigNumber.from(ensure0x(getStarkKey(pair))).toHexString()).toBe(
+ '0x033f45f07e1bd1a51b45fc24ec8c8c9908db9e42191be9e169bfcac0c0d99745'
+ );
+ });
+});

__tests__/wallet.test.ts

@@ -0,0 +1,169 @@
+import { BigNumber } from '@ethersproject/bignumber';
+
+import fs from 'fs';
+import {
+ hashMessage,
+ CompiledContract,
+ Contract,
+ deployContract,
+ JsonParser,
+ waitForTx,
+ randomAddress,
+ getSelectorFromName,
+ ensure0x,
+ getStarkKey,
+ getKeyPair,
+ sign,
+} from '../src';
+
+describe('getStarkAccountFromPk()', () => {
+ test('it works with valid pk', () => {
+ const pk = '0xb696427c0d79c5d28a1fa6f748bae1b98b3f4b86bd1a2505bab144673c856fa9';
+
+ const starkKeyPair = getKeyPair(pk);
+ const starkKey = getStarkKey(starkKeyPair);
+
+ expect(starkKey).toBe('0x060d46f8d7ef3d83ed05f3ed9beb91e22f9529289b9d863683fd71eafaf28035');
+ });
+ test('it works with valid pk', () => {
+ const pk = '0x5f65099e269b080000000000000000000000000000000000000000000000000';
+
+ const starkKeyPair = getKeyPair(pk);
+ const starkKey = getStarkKey(starkKeyPair);
+
+ expect(starkKey).toBe('0xf321e59b257a577836d8313150aabd21f412491358c329966218df76bab591');
+ });
+});
+
+const compiledArgentAccount: CompiledContract = JsonParser.parse(
+ fs.readFileSync('./__mocks__/ArgentAccount.json').toString('ascii')
+);
+const compiledErc20: CompiledContract = JsonParser.parse(
+ fs.readFileSync('./__mocks__/ERC20.json').toString('ascii')
+);
+
+describe('deploy and test Wallet', () => {
+ const pk = randomAddress();
+
+ // eslint-disable-next-line no-console
+ console.log('PK:', pk);
+
+ const starkKeyPair = getKeyPair(pk);
+ const walletAddress = getStarkKey(starkKeyPair);
+ const wallet = new Contract(compiledArgentAccount.abi, walletAddress);
+ const erc20Address = getStarkKey(getKeyPair(randomAddress()));
+ const erc20 = new Contract(compiledErc20.abi, erc20Address);
+ beforeAll(async () => {
+ const { code: codeErc20, tx_id: txErc20 } = await deployContract(compiledErc20, erc20Address);
+ // I want to show the tx number to the tester, so he/she can trace the transaction in the explorer.
+ // eslint-disable-next-line no-console
+ console.log('deployed erc20', txErc20);
+ expect(codeErc20).toBe('TRANSACTION_RECEIVED');
+
+ const { code, tx_id } = await deployContract(compiledArgentAccount, walletAddress);
+ // I want to show the tx number to the tester, so he/she can trace the transaction in the explorer.
+ // eslint-disable-next-line no-console
+ console.log('deployed wallet', tx_id);
+ expect(code).toBe('TRANSACTION_RECEIVED');
+
+ const { code: code2, tx_id: txId2 } = await wallet.invoke('initialize', {
+ signer: walletAddress,
+ guardian: '0',
+ L1_address: '0',
+ self_address: walletAddress,
+ });
+
+ // I want to show the tx number to the tester, so he/she can trace the transaction in the explorer.
+ // eslint-disable-next-line no-console
+ console.log('initialized wallet', txId2);
+ expect(code2).toBe('TRANSACTION_RECEIVED');
+
+ const { code: codeErc20Mint, tx_id: txErc20Mint } = await erc20.invoke('mint', {
+ recipient: walletAddress,
+ amount: '1000',
+ });
+
+ // I want to show the tx number to the tester, so he/she can trace the transaction in the explorer.
+ // eslint-disable-next-line no-console
+ console.log('mint erc20', txErc20Mint);
+ expect(codeErc20Mint).toBe('TRANSACTION_RECEIVED');
+
+ await waitForTx(txErc20Mint);
+ });
+ test('read nonce', async () => {
+ const { nonce } = await wallet.call('get_current_nonce');
+
+ expect(BigNumber.from(nonce)).toStrictEqual(BigNumber.from(0));
+ });
+ test('read balance of wallet', async () => {
+ const { res } = await erc20.call('balance_of', {
+ user: walletAddress,
+ });
+
+ expect(BigNumber.from(res)).toStrictEqual(BigNumber.from(1000));
+ });
+ test('execute by wallet owner', async () => {
+ const { nonce } = await wallet.call('get_current_nonce');
+ const msgHash = ensure0x(
+ hashMessage(
+ walletAddress,
+ erc20Address,
+ getSelectorFromName('transfer'),
+ [erc20Address, '10'],
+ nonce.toString()
+ )
+ );
+ console.log(msgHash);
+ const { r, s } = sign(starkKeyPair, msgHash);
+ const { code, tx_id } = await wallet.invoke('execute', {
+ to: erc20Address,
+ selector: getSelectorFromName('transfer'),
+ calldata: [erc20Address, '10'],
+ nonce: nonce.toString(),
+ sig: [ensure0x(r.toString('hex')), ensure0x(s.toString('hex'))],
+ });
+
+ // I want to show the tx number to the tester, so he/she can trace the transaction in the explorer.
+ // eslint-disable-next-line no-console
+ console.log('transfer erc20 using wallet execute', tx_id);
+ expect(code).toBe('TRANSACTION_RECEIVED');
+
+ await waitForTx(tx_id);
+ });
+ test('read balance of wallet after transfer', async () => {
+ const { res } = await erc20.call('balance_of', {
+ user: walletAddress,
+ });
+
+ expect(BigNumber.from(res)).toStrictEqual(BigNumber.from(990));
+ });
+});
+
+test('build tx', async () => {
+ const pk = '0x1B69B4BE052FAB1';
+ const keyPair = getKeyPair(pk);
+ const address = getStarkKey(keyPair);
+
+ expect(address).toBe('0x04024999b9574cb7623679ce049a609db62a95098982c5b28ac61abdebd1c82b');
+
+ const selector = getSelectorFromName('transfer');
+
+ expect(selector).toBe(
+ BigNumber.from(
+ '232670485425082704932579856502088130646006032362877466777181098476241604910'
+ ).toHexString()
+ );
+
+ const msgHash = hashMessage(address, '1', selector, ['6', '7'], '0');
+ expect(BigNumber.from(msgHash)).toStrictEqual(
+ BigNumber.from('2221651675559331189881349481637314109810712322791057846116415219218634672652')
+ );
+
+ const { r, s } = sign(keyPair, msgHash);
+ expect(r.toString()).toBe(
+ '2220702546012141050051149396887481489960265709213083422658245644097500180866'
+ );
+ expect(s.toString()).toBe(
+ '1542316446019190634489932498001415389924394685441251344076931639569381539117'
+ );
+});