starknet 4.15.0 → 4.16.0

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+# [4.16.0](https://github.com/0xs34n/starknet.js/compare/v4.15.1...v4.16.0) (2022-12-12)
+
+### Bug Fixes
+
+- blockIdentifier null on call from constructed function ([c88fbf0](https://github.com/0xs34n/starknet.js/commit/c88fbf0cdfc57e1150275a34c15900d6c81802d3))
+- default pathfinder does't have pending block ([4619188](https://github.com/0xs34n/starknet.js/commit/4619188e21e5cc9a811c59bcf2923c4382661635))
+- sequencer defaults, remove defaultProvider default blockIdentifier, spelling, class ([555a9a3](https://github.com/0xs34n/starknet.js/commit/555a9a3982bc1a742776119df5dee5d701209a0d))
+
+### Features
+
+- multi deploy reimplemented ([10e609a](https://github.com/0xs34n/starknet.js/commit/10e609a1af584df65942477b264ad7809b5c70c9))
+- return precalculated address from deploy ([5e40224](https://github.com/0xs34n/starknet.js/commit/5e402246841bdf9117a9ee96799833fc6f68d16b))
+
+## [4.15.1](https://github.com/0xs34n/starknet.js/compare/v4.15.0...v4.15.1) (2022-12-07)
+
+### Bug Fixes
+
+- add testnet 2 compatibility to test ([b83f35b](https://github.com/0xs34n/starknet.js/commit/b83f35bbfc0c2a6c84318a473ca816cc053f5806))
+- delete only on test ([e13db57](https://github.com/0xs34n/starknet.js/commit/e13db577b7d40073707d78e57f63e65b6472c446))
+- lib chainid test ([e820572](https://github.com/0xs34n/starknet.js/commit/e820572a9eafe732dae3d1bbde5f63279c000be7))
+
 # [4.15.0](https://github.com/0xs34n/starknet.js/compare/v4.14.0...v4.15.0) (2022-12-05)
 
 ### Bug Fixes

package/__tests__/account.test.ts

@@ -1,9 +1,11 @@
 import { isBN } from 'bn.js';
 
 import typedDataExample from '../__mocks__/typedDataExample.json';
-import { Account, Contract, DeployContractPayload, Provider, number, stark } from '../src';
-import { feeTransactionVersion } from '../src/utils/hash';
-import { hexToDecimalString, toBN } from '../src/utils/number';
+import { Account, Contract, Provider, number, stark } from '../src';
+import { getKeyPair, sign } from '../src/utils/ellipticCurve';
+import { parseUDCEvent } from '../src/utils/events';
+import { feeTransactionVersion, pedersen } from '../src/utils/hash';
+import { cleanHex, hexToDecimalString, toBN } from '../src/utils/number';
 import { encodeShortString } from '../src/utils/shortString';
 import { randomAddress } from '../src/utils/stark';
 import {
@@ -169,14 +171,30 @@ describe('deploy and test Wallet', () => {
 
     test('Get the stark name of the account and account from stark name (using starknet.id)', async () => {
       // Deploy naming contract
-      const namingPlayLoad: DeployContractPayload = { contract: compiledNamingContract };
-      const namingResponse = await provider.deployContract(namingPlayLoad);
-      const namingAddress = namingResponse.contract_address;
+      const namingResponse = await account.declareDeploy({
+        contract: compiledNamingContract,
+        classHash: '0x3f2f8c80ab2d404bcfb4182e8528708e4efa2c646dd711bdd7b721ecc6111f7',
+      });
+      const namingAddress = namingResponse.deploy.contract_address;
 
       // Deploy Starknet id contract
-      const idPlayLoad: DeployContractPayload = { contract: compiledStarknetId };
-      const idResponse = await provider.deployContract(idPlayLoad);
-      const idAddress = idResponse.contract_address;
+      const idResponse = await account.declareDeploy({
+        contract: compiledStarknetId,
+        classHash: '0x1eb5a8308760d82321cb3ee8967581bb1d38348c7d2f082a07580040c52217c',
+      });
+      const idAddress = idResponse.deploy.contract_address;
+
+      // Create signature from private key
+      const whitelistingPublicKey =
+        '1893860513534673656759973582609638731665558071107553163765293299136715951024';
+      const whitelistingPrivateKey =
+        '301579081698031303837612923223391524790804435085778862878979120159194507372';
+      const hashed = pedersen([
+        pedersen([toBN('18925'), toBN('1922775124')]),
+        toBN(hexToDecimalString(account.address)),
+      ]);
+      const keyPair = getKeyPair(toBN(whitelistingPrivateKey));
+      const signed = sign(keyPair, hashed);
 
       const { transaction_hash } = await account.execute([
         {
@@ -186,7 +204,7 @@ describe('deploy and test Wallet', () => {
             idAddress, // starknetid_contract_addr
             '0', // pricing_contract_addr
             account.address, // admin
-            '1576987121283045618657875225183003300580199140020787494777499595331436496159', // whitelisting_key
+            whitelistingPublicKey, // whitelisting_key
             '0', // l1_contract
           ],
         },
@@ -200,11 +218,11 @@ describe('deploy and test Wallet', () => {
           entrypoint: 'whitelisted_mint',
           calldata: [
             '18925', // Domain encoded "ben"
-            '1697380617', // Expiry
+            '1922775124', // Expiry
             '1', // Starknet id linked
             account.address, // receiver_address
-            '1249449923402095645023546949816521361907869702415870903008894560968474148064', // sig 0 for whitelist
-            '543901326374961504443808953662149863005450004831659662383974986108355067943', // sig 1 for whitelist
+            signed[0], // sig 0 for whitelist
+            signed[1], // sig 1 for whitelist
           ],
         },
         {
@@ -261,7 +279,7 @@ describe('deploy and test Wallet', () => {
       expect(deployResponse.salt).toBeDefined();
     });
 
-    test('UDC Deploy', async () => {
+    test('UDC Deploy unique', async () => {
       const salt = randomAddress(); // use random salt
 
       const deployment = await account.deploy({
@@ -272,12 +290,54 @@ describe('deploy and test Wallet', () => {
           account.address,
         ],
         salt,
-        unique: true, // Using true here so as not to clash with normal erc20 deploy in account and provider test
+        unique: true,
       });
+      expect(deployment).toHaveProperty('transaction_hash');
 
-      await provider.waitForTransaction(deployment.transaction_hash);
+      // check pre-calculated address
+      const txReceipt = await provider.waitForTransaction(deployment.transaction_hash);
+      const udcEvent = parseUDCEvent(txReceipt);
+      expect(cleanHex(deployment.contract_address[0])).toBe(cleanHex(udcEvent.contract_address));
+    });
+
+    test('UDC Deploy non-unique', async () => {
+      const salt = randomAddress(); // use random salt
 
+      const deployment = await account.deploy({
+        classHash: erc20ClassHash,
+        constructorCalldata: [
+          encodeShortString('Token'),
+          encodeShortString('ERC20'),
+          account.address,
+        ],
+        salt,
+        unique: false,
+      });
       expect(deployment).toHaveProperty('transaction_hash');
+
+      // check pre-calculated address
+      const txReceipt = await provider.waitForTransaction(deployment.transaction_hash);
+      const udcEvent = parseUDCEvent(txReceipt);
+      expect(cleanHex(deployment.contract_address[0])).toBe(cleanHex(udcEvent.contract_address));
+    });
+
+    test('UDC multi Deploy', async () => {
+      const deployments = await account.deploy([
+        {
+          classHash: '0x04367b26fbb92235e8d1137d19c080e6e650a6889ded726d00658411cc1046f5',
+        },
+        {
+          classHash: erc20ClassHash,
+          constructorCalldata: [
+            encodeShortString('Token'),
+            encodeShortString('ERC20'),
+            account.address,
+          ],
+        },
+      ]);
+      expect(deployments).toHaveProperty('transaction_hash');
+      expect(deployments.contract_address[0]).toBeDefined();
+      expect(deployments.contract_address[1]).toBeDefined();
     });
   });
 });

package/__tests__/contract.test.ts

@@ -13,227 +13,225 @@ import {
   getTestProvider,
 } from './fixtures';
 
-const provider = getTestProvider();
-
-describe('class Contract {}', () => {
+describe('contract module', () => {
+  let erc20Address: string;
+  const provider = getTestProvider();
   const wallet = stark.randomAddress();
   const account = getTestAccount(provider);
+  const constructorCalldata = [encodeShortString('Token'), encodeShortString('ERC20'), wallet];
+  const classHash = '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a';
 
-  describe('Basic Interaction', () => {
-    let erc20Contract: Contract;
-    let multicallContract: Contract;
+  describe('class Contract {}', () => {
+    describe('Basic Interaction', () => {
+      let erc20Contract: Contract;
+      let multicallContract: Contract;
 
-    beforeAll(async () => {
-      const { deploy } = await account.declareDeploy({
-        contract: compiledErc20,
-        classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
-        constructorCalldata: [encodeShortString('Token'), encodeShortString('ERC20'), wallet],
-      });
+      beforeAll(async () => {
+        const { deploy } = await account.declareDeploy({
+          contract: compiledErc20,
+          classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
+          constructorCalldata: [encodeShortString('Token'), encodeShortString('ERC20'), wallet],
+        });
 
-      erc20Contract = new Contract(compiledErc20.abi, deploy.contract_address!, provider);
+        erc20Contract = new Contract(compiledErc20.abi, deploy.contract_address!, provider);
 
-      const { deploy: multicallDeploy } = await account.declareDeploy({
-        contract: compiledMulticall,
-        classHash: '0x06f94f3229a8d9c1d51cb84f1f5ec306c8552a805e307540727dda53c4936b43',
+        const { deploy: multicallDeploy } = await account.declareDeploy({
+          contract: compiledMulticall,
+          classHash: '0x06f94f3229a8d9c1d51cb84f1f5ec306c8552a805e307540727dda53c4936b43',
+        });
+
+        multicallContract = new Contract(
+          compiledMulticall.abi,
+          multicallDeploy.contract_address!,
+          provider
+        );
       });
 
-      multicallContract = new Contract(
-        compiledMulticall.abi,
-        multicallDeploy.contract_address!,
-        provider
-      );
-    });
+      test('populate transaction for initial balance of that account', async () => {
+        const res = await erc20Contract.populateTransaction.balanceOf(wallet);
+        expect(res).toHaveProperty('contractAddress');
+        expect(res).toHaveProperty('entrypoint');
+        expect(res).toHaveProperty('calldata');
+      });
 
-    test('populate transaction for initial balance of that account', async () => {
-      const res = await erc20Contract.populateTransaction.balanceOf(wallet);
-      expect(res).toHaveProperty('contractAddress');
-      expect(res).toHaveProperty('entrypoint');
-      expect(res).toHaveProperty('calldata');
-    });
+      test('estimate gas fee for `mint` should fail when connected to the provider', async () => {
+        expect(erc20Contract.estimateFee.mint(wallet, ['10', '0'])).rejects.toThrow();
+      });
 
-    test('estimate gas fee for `mint` should fail when connected to the provider', async () => {
-      expect(erc20Contract.estimateFee.mint(wallet, ['10', '0'])).rejects.toThrow();
+      test('read initial balance of that account', async () => {
+        const result = await erc20Contract.balanceOf(wallet);
+        const [res] = result;
+        expect(res.low).toStrictEqual(toBN(1000));
+        expect(res).toStrictEqual(result.balance);
+      });
+
+      test('read balance in a multicall', async () => {
+        const args1 = { user: wallet };
+        const args2 = {};
+        const calls = [
+          erc20Contract.address,
+          getSelectorFromName('balanceOf'),
+          Object.keys(args1).length,
+          ...compileCalldata(args1),
+
+          erc20Contract.address,
+          getSelectorFromName('decimals'),
+          Object.keys(args2).length,
+          ...compileCalldata(args2),
+        ];
+        const result = await multicallContract.aggregate(calls);
+        const [block_number, res] = result;
+        expect(isBN(block_number));
+        expect(Array.isArray(res));
+        (res as BigNumberish[]).forEach((el) => expect(isBN(el)));
+        expect(block_number).toStrictEqual(result.block_number);
+        expect(res).toStrictEqual(result.result);
+      });
     });
 
-    test('read initial balance of that account', async () => {
-      const result = await erc20Contract.balanceOf(wallet);
-      const [res] = result;
-      expect(res.low).toStrictEqual(toBN(1000));
-      expect(res).toStrictEqual(result.balance);
-    });
+    describe('Type Transformation', () => {
+      let typeTransformedContract: Contract;
 
-    test('read balance in a multicall', async () => {
-      const args1 = { user: wallet };
-      const args2 = {};
-      const calls = [
-        erc20Contract.address,
-        getSelectorFromName('balanceOf'),
-        Object.keys(args1).length,
-        ...compileCalldata(args1),
-
-        erc20Contract.address,
-        getSelectorFromName('decimals'),
-        Object.keys(args2).length,
-        ...compileCalldata(args2),
-      ];
-      const result = await multicallContract.aggregate(calls);
-      const [block_number, res] = result;
-      expect(isBN(block_number));
-      expect(Array.isArray(res));
-      (res as BigNumberish[]).forEach((el) => expect(isBN(el)));
-      expect(block_number).toStrictEqual(result.block_number);
-      expect(res).toStrictEqual(result.result);
-    });
-  });
-
-  describe('Type Transformation', () => {
-    let typeTransformedContract: Contract;
+      beforeAll(async () => {
+        const { deploy } = await account.declareDeploy({
+          contract: compiledTypeTransformation,
+          classHash: '0x022a0e662b13d18a2aaa3ee54ae290de6569621b549022c18169c6e7893809ea',
+        });
 
-    beforeAll(async () => {
-      const { deploy } = await account.declareDeploy({
-        contract: compiledTypeTransformation,
-        classHash: '0x022a0e662b13d18a2aaa3ee54ae290de6569621b549022c18169c6e7893809ea',
+        typeTransformedContract = new Contract(
+          compiledTypeTransformation.abi,
+          deploy.contract_address!,
+          provider
+        );
       });
 
-      typeTransformedContract = new Contract(
-        compiledTypeTransformation.abi,
-        deploy.contract_address!,
-        provider
-      );
-    });
-
-    describe('Request Type Transformation', () => {
-      test('Parsing the felt in request', async () => {
-        return expect(typeTransformedContract.request_felt(3)).resolves.not.toThrow();
-      });
+      describe('Request Type Transformation', () => {
+        test('Parsing the felt in request', async () => {
+          return expect(typeTransformedContract.request_felt(3)).resolves.not.toThrow();
+        });
 
-      test('Parsing the array of felt in request', async () => {
-        return expect(
-          typeTransformedContract.request_array_of_felts([1, 2])
-        ).resolves.not.toThrow();
-      });
+        test('Parsing the array of felt in request', async () => {
+          return expect(
+            typeTransformedContract.request_array_of_felts([1, 2])
+          ).resolves.not.toThrow();
+        });
 
-      test('Parsing the struct in request', async () => {
-        return expect(
-          typeTransformedContract.request_struct({ x: 1, y: 2 })
-        ).resolves.not.toThrow();
-      });
+        test('Parsing the struct in request', async () => {
+          return expect(
+            typeTransformedContract.request_struct({ x: 1, y: 2 })
+          ).resolves.not.toThrow();
+        });
 
-      test('Parsing the array of structs in request', async () => {
-        return expect(
-          typeTransformedContract.request_array_of_structs([{ x: 1, y: 2 }])
-        ).resolves.not.toThrow();
-      });
+        test('Parsing the array of structs in request', async () => {
+          return expect(
+            typeTransformedContract.request_array_of_structs([{ x: 1, y: 2 }])
+          ).resolves.not.toThrow();
+        });
 
-      test('Parsing the nested structs in request', async () => {
-        return expect(
-          typeTransformedContract.request_nested_structs({
-            p1: { x: 1, y: 2 },
-            p2: { x: 3, y: 4 },
-            extra: 5,
-          })
-        ).resolves.not.toThrow();
-      });
+        test('Parsing the nested structs in request', async () => {
+          return expect(
+            typeTransformedContract.request_nested_structs({
+              p1: { x: 1, y: 2 },
+              p2: { x: 3, y: 4 },
+              extra: 5,
+            })
+          ).resolves.not.toThrow();
+        });
 
-      test('Parsing the tuple in request', async () => {
-        return expect(typeTransformedContract.request_tuple([1, 2])).resolves.not.toThrow();
-      });
+        test('Parsing the tuple in request', async () => {
+          return expect(typeTransformedContract.request_tuple([1, 2])).resolves.not.toThrow();
+        });
 
-      test('Parsing the multiple types in request', async () => {
-        return expect(
-          typeTransformedContract.request_mixed_types(2, { x: 1, y: 2 }, [1])
-        ).resolves.not.toThrow();
+        test('Parsing the multiple types in request', async () => {
+          return expect(
+            typeTransformedContract.request_mixed_types(2, { x: 1, y: 2 }, [1])
+          ).resolves.not.toThrow();
+        });
       });
-    });
 
-    describe('Response Type Transformation', () => {
-      test('Parsing the felt in response', async () => {
-        const { res } = await typeTransformedContract.get_felt();
-        expect(res).toStrictEqual(toBN(4));
-      });
+      describe('Response Type Transformation', () => {
+        test('Parsing the felt in response', async () => {
+          const { res } = await typeTransformedContract.get_felt();
+          expect(res).toStrictEqual(toBN(4));
+        });
 
-      test('Parsing the array of felt in response', async () => {
-        const result = await typeTransformedContract.get_array_of_felts();
-        const [res] = result;
-        expect(res).toStrictEqual([toBN(4), toBN(5)]);
-        expect(res).toStrictEqual(result.res);
-      });
+        test('Parsing the array of felt in response', async () => {
+          const result = await typeTransformedContract.get_array_of_felts();
+          const [res] = result;
+          expect(res).toStrictEqual([toBN(4), toBN(5)]);
+          expect(res).toStrictEqual(result.res);
+        });
 
-      test('Parsing the array of structs in response', async () => {
-        const result = await typeTransformedContract.get_struct();
-        const [res] = result;
-        expect(res).toStrictEqual({ x: toBN(1), y: toBN(2) });
-        expect(res).toStrictEqual(result.res);
-      });
+        test('Parsing the array of structs in response', async () => {
+          const result = await typeTransformedContract.get_struct();
+          const [res] = result;
+          expect(res).toStrictEqual({ x: toBN(1), y: toBN(2) });
+          expect(res).toStrictEqual(result.res);
+        });
 
-      test('Parsing the array of structs in response', async () => {
-        const result = await typeTransformedContract.get_array_of_structs();
-        const [res] = result;
-        expect(res).toStrictEqual([{ x: toBN(1), y: toBN(2) }]);
-        expect(res).toStrictEqual(result.res);
-      });
+        test('Parsing the array of structs in response', async () => {
+          const result = await typeTransformedContract.get_array_of_structs();
+          const [res] = result;
+          expect(res).toStrictEqual([{ x: toBN(1), y: toBN(2) }]);
+          expect(res).toStrictEqual(result.res);
+        });
 
-      test('Parsing the nested structs in response', async () => {
-        const result = await typeTransformedContract.get_nested_structs();
-        const [res] = result;
-        expect(res).toStrictEqual({
-          p1: { x: toBN(1), y: toBN(2) },
-          p2: { x: toBN(3), y: toBN(4) },
-          extra: toBN(5),
+        test('Parsing the nested structs in response', async () => {
+          const result = await typeTransformedContract.get_nested_structs();
+          const [res] = result;
+          expect(res).toStrictEqual({
+            p1: { x: toBN(1), y: toBN(2) },
+            p2: { x: toBN(3), y: toBN(4) },
+            extra: toBN(5),
+          });
+          expect(res).toStrictEqual(result.res);
         });
-        expect(res).toStrictEqual(result.res);
-      });
 
-      test('Parsing the tuple in response', async () => {
-        const result = await typeTransformedContract.get_tuple();
-        const [res] = result;
-        expect(res).toStrictEqual([toBN(1), toBN(2), toBN(3)]);
-        expect(res).toStrictEqual(result.res);
-      });
+        test('Parsing the tuple in response', async () => {
+          const result = await typeTransformedContract.get_tuple();
+          const [res] = result;
+          expect(res).toStrictEqual([toBN(1), toBN(2), toBN(3)]);
+          expect(res).toStrictEqual(result.res);
+        });
 
-      test('Parsing the multiple types in response', async () => {
-        const result = await typeTransformedContract.get_mixed_types();
-        const [tuple, number, array, point] = result;
-        expect(tuple).toStrictEqual([toBN(1), toBN(2)]);
-        expect(number).toStrictEqual(toBN(3));
-        expect(array).toStrictEqual([toBN(4)]);
-        expect(point).toStrictEqual({ x: toBN(1), y: toBN(2) });
-        expect(tuple).toStrictEqual(result.tuple);
-        expect(number).toStrictEqual(result.number);
-        expect(array).toStrictEqual(result.array);
-        expect(point).toStrictEqual(result.point);
+        test('Parsing the multiple types in response', async () => {
+          const result = await typeTransformedContract.get_mixed_types();
+          const [tuple, number, array, point] = result;
+          expect(tuple).toStrictEqual([toBN(1), toBN(2)]);
+          expect(number).toStrictEqual(toBN(3));
+          expect(array).toStrictEqual([toBN(4)]);
+          expect(point).toStrictEqual({ x: toBN(1), y: toBN(2) });
+          expect(tuple).toStrictEqual(result.tuple);
+          expect(number).toStrictEqual(result.number);
+          expect(array).toStrictEqual(result.array);
+          expect(point).toStrictEqual(result.point);
+        });
       });
     });
   });
-});
 
-describe('class ContractFactory {}', () => {
-  let erc20Address: string;
-  const wallet = stark.randomAddress();
-  const account = getTestAccount(provider);
-  const constructorCalldata = [encodeShortString('Token'), encodeShortString('ERC20'), wallet];
-  const classHash = '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a';
-
-  beforeAll(async () => {
-    await account.declareDeploy({
-      contract: compiledErc20,
-      classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
-      constructorCalldata,
+  describe('class ContractFactory {}', () => {
+    beforeAll(async () => {
+      await account.declareDeploy({
+        contract: compiledErc20,
+        classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
+        constructorCalldata,
+      });
+    });
+    test('deployment of new contract', async () => {
+      const factory = new ContractFactory(compiledErc20, classHash, account);
+      const erc20 = await factory.deploy(constructorCalldata);
+      expect(erc20 instanceof Contract);
+    });
+    test('wait for deployment transaction', async () => {
+      const factory = new ContractFactory(compiledErc20, classHash, account);
+      const contract = await factory.deploy(constructorCalldata);
+      expect(contract.deployed()).resolves.not.toThrow();
+    });
+    test('attach new contract', async () => {
+      const factory = new ContractFactory(compiledErc20, classHash, account);
+      const erc20 = factory.attach(erc20Address);
+      expect(erc20 instanceof Contract);
     });
-  });
-  test('deployment of new contract', async () => {
-    const factory = new ContractFactory(compiledErc20, classHash, account);
-    const erc20 = await factory.deploy(constructorCalldata);
-    expect(erc20 instanceof Contract);
-  });
-  test('wait for deployment transaction', async () => {
-    const factory = new ContractFactory(compiledErc20, classHash, account);
-    const contract = await factory.deploy(constructorCalldata);
-    expect(contract.deployed()).resolves.not.toThrow();
-  });
-  test('attach new contract', async () => {
-    const factory = new ContractFactory(compiledErc20, classHash, account);
-    const erc20 = factory.attach(erc20Address);
-    expect(erc20 instanceof Contract);
   });
 });