starknet 4.9.0 → 4.11.0

package/CHANGELOG.md

@@ -1,3 +1,46 @@
+# [4.11.0](https://github.com/0xs34n/starknet.js/compare/v4.10.0...v4.11.0) (2022-11-14)
+
+### Bug Fixes
+
+- change txn version for estimate fee apis to be feeTransactionVersion ([4d255c5](https://github.com/0xs34n/starknet.js/commit/4d255c5cf4adceb16a7f9ac61904a6e5d8020cbd))
+- lib FunctionAbiType and EventAbi shallow ([7088dc6](https://github.com/0xs34n/starknet.js/commit/7088dc6828f9f4fd29922323e63183a2e11f7340))
+- remove deprecated function ([0a9f84f](https://github.com/0xs34n/starknet.js/commit/0a9f84f86aabaa49ab78faa3331cac0ca98ace61))
+- removed fixed params swap ([57c01f6](https://github.com/0xs34n/starknet.js/commit/57c01f6418771d8ceaa3f393d54cad8bfff94b56))
+- rpcProvider tests ([4b0fd20](https://github.com/0xs34n/starknet.js/commit/4b0fd20a8ce235e0e069521f7dca50a4696120a4))
+
+### Features
+
+- fill in sequencer class methods ([83c0a29](https://github.com/0xs34n/starknet.js/commit/83c0a296bced3128a0ca9dd5246b376816a0be63))
+- implement rpc-0.2.1rc1 types ([2b1b71e](https://github.com/0xs34n/starknet.js/commit/2b1b71ebedfa709aab4fa652bd98a8efc2d3e39a))
+- rpc 0.2.0 plane implementation ([35a880c](https://github.com/0xs34n/starknet.js/commit/35a880ce4f8438e78143f7c0997ccfe6de680d80))
+- rpc 0.2.0 type implementation ([866dda7](https://github.com/0xs34n/starknet.js/commit/866dda76fc35ef656a9e21b8b8674f73729c9a50))
+- rpc 0.2.0 types spec ([25b2d29](https://github.com/0xs34n/starknet.js/commit/25b2d293a1a570b6fc68ea3877bfe6c3e898e3a6))
+- rpc 0.2.1 ([ed17f63](https://github.com/0xs34n/starknet.js/commit/ed17f6380d2b1ab1432d5426c7395ab18c6dc793))
+- rpc v0.2 endpoint, default identifiers, getClassHashAt flip parameters ([f0a0d6c](https://github.com/0xs34n/starknet.js/commit/f0a0d6c49e33442b603dcc9c9c119867c1ed32cc))
+- rpc0.2.1 definition migration comlete ([35c5a06](https://github.com/0xs34n/starknet.js/commit/35c5a0645dafe061080c2c2ced6a9a4a9882207c))
+
+# [4.10.0](https://github.com/0xs34n/starknet.js/compare/v4.9.0...v4.10.0) (2022-11-10)
+
+### Bug Fixes
+
+- ci ([9b38cd8](https://github.com/0xs34n/starknet.js/commit/9b38cd8a2e23b71a1490c168ae83b64f479d3da9))
+- deploy return type in interface ([6a663d4](https://github.com/0xs34n/starknet.js/commit/6a663d492751b0cd8493af6d4ee9a5cf5524ed19))
+- path rpc test to release ([a1dafad](https://github.com/0xs34n/starknet.js/commit/a1dafad7056fb2e52849a8d5d533872254c62293))
+- remove multiple RawArgs declaration ([b65dc65](https://github.com/0xs34n/starknet.js/commit/b65dc651bbd86708d4f88b7445813dab7dfea639))
+- return type and rename calldata ([67fe081](https://github.com/0xs34n/starknet.js/commit/67fe081a24ca9eb64669ed9b0c2726898c68a34c))
+- update readme ([7859cb1](https://github.com/0xs34n/starknet.js/commit/7859cb1d2b6e4e924f8bb21a1bbb9ada1a46a308))
+- wait for declare and deploy, use random salt ([8dbd3c1](https://github.com/0xs34n/starknet.js/commit/8dbd3c183413f298307f2b22941c6981191a62b2))
+
+### Features
+
+- add multicall support ([4b99f4a](https://github.com/0xs34n/starknet.js/commit/4b99f4a7b09a03990e2ba9ea00de2d0206f93ce0))
+- enable custom providers headers option ([f2e9b1a](https://github.com/0xs34n/starknet.js/commit/f2e9b1a439908179bad1f4bb0e0632180b7b658f))
+- fix and add proper UDC tests ([d96cc53](https://github.com/0xs34n/starknet.js/commit/d96cc531786738de7d8ec285ccdaa39e76a94de3))
+- provider docs update ([e5d0376](https://github.com/0xs34n/starknet.js/commit/e5d0376dd281b04c486c58786709c42ea1e3a5a7))
+- testnet2 ([8a054d0](https://github.com/0xs34n/starknet.js/commit/8a054d0ceb312efc0b6d303cad73b9bb39ba4304))
+- udc demo ([27b402b](https://github.com/0xs34n/starknet.js/commit/27b402b6eed4c2bec67bfbf7ee27c9636ca4ae2b))
+- udc working example ([5c4452a](https://github.com/0xs34n/starknet.js/commit/5c4452aa2e6b50768438f1117794dce430984ff8))
+
 # [4.9.0](https://github.com/0xs34n/starknet.js/compare/v4.8.0...v4.9.0) (2022-10-19)
 
 ### Bug Fixes

package/README.md

@@ -72,12 +72,10 @@ If you consider to contribute to this project please read [CONTRIBUTING.md](http
 
 Special thanks to all the [contributors](https://github.com/0xs34n/starknet.js/graphs/contributors), especially to:
 
-Janek ([@janek26](https://github.com/janek26)) and Axel ([@delaaxe](https://github.com/delaaxe)) from [Argent](https://github.com/argentlabs)
+Janek ([@janek26](https://github.com/janek26)), Axel ([@delaaxe](https://github.com/delaaxe)) and Dhruv ([@dhruvkelawala](https://github.com/dhruvkelawala)) from [Argent](https://github.com/argentlabs)
 
 Miljan ([@MilGard91](https://github.com/MilGard91)) from [Shard Labs](https://shardlabs.io/)
 
-Dhruv ([@dhruvkelawala](https://github.com/dhruvkelawala)) from [Jedi Swap](https://twitter.com/jediswap)
-
 and of course the [StarkWare](https://starkware.co/) team for their dedicated support!
 
 This library would not be possible without these rockstars.

package/__tests__/account.test.ts

@@ -2,6 +2,7 @@ import { isBN } from 'bn.js';
 
 import typedDataExample from '../__mocks__/typedDataExample.json';
 import { Account, Contract, Provider, number, stark } from '../src';
+import { feeTransactionVersion } from '../src/utils/hash';
 import { toBN } from '../src/utils/number';
 import {
   compiledErc20,
@@ -43,12 +44,15 @@ describe('deploy and test Wallet', () => {
   });
 
   test('estimate fee', async () => {
+    const innerInvokeEstFeeSpy = jest.spyOn(account.signer, 'signTransaction');
     const { overall_fee } = await account.estimateInvokeFee({
       contractAddress: erc20Address,
       entrypoint: 'transfer',
       calldata: [erc20.address, '10', '0'],
     });
     expect(isBN(overall_fee)).toBe(true);
+    expect(innerInvokeEstFeeSpy.mock.calls[0][1].version).toBe(feeTransactionVersion);
+    innerInvokeEstFeeSpy.mockClear();
   });
 
   test('read balance of wallet', async () => {
@@ -145,7 +149,7 @@ describe('deploy and test Wallet', () => {
       expect(res).toHaveProperty('overall_fee');
     });
 
-    test('Declare Account contract', async () => {
+    test('Declare ERC20 contract', async () => {
       const declareTx = await account.declare({
         contract: compiledErc20,
         classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',

package/__tests__/defaultProvider.test.ts

@@ -1,11 +1,6 @@
-import { BlockNumber, DeployContractResponse, GetBlockResponse, stark } from '../src';
+import { BlockNumber, GetBlockResponse, stark } from '../src';
 import { toBN } from '../src/utils/number';
-import {
-  compiledOpenZeppelinAccount,
-  describeIfNotDevnet,
-  getERC20DeployPayload,
-  getTestProvider,
-} from './fixtures';
+import { getERC20DeployPayload, getTestProvider } from './fixtures';
 
 const { compileCalldata } = stark;
 
@@ -36,27 +31,47 @@ describe('defaultProvider', () => {
   });
 
   describe('endpoints', () => {
-    test(`getBlock(blockHash=undefined, blockNumber=${exampleBlockNumber})`, () => {
-      return expect(testProvider.getBlock(exampleBlockNumber)).resolves.not.toThrow();
+    test('deployContract()', () => {
+      expect(exampleContractAddress).toBeTruthy();
+      expect(exampleTransactionHash).toBeTruthy();
     });
 
-    test(`getBlock(blockHash=${exampleBlockHash}, blockNumber=undefined)`, () => {
-      return expect(testProvider.getBlock(exampleBlockHash)).resolves.not.toThrow();
-    });
-
-    test('getBlock(blockIdentifier=latest)', async () => {
-      expect(exampleBlock).not.toBeNull();
-
-      const { block_number, timestamp } = exampleBlock;
+    describe('getBlock', () => {
+      test('getBlock(blockIdentifier=latest)', async () => {
+        expect(exampleBlock).not.toBeNull();
+        const { block_number, timestamp } = exampleBlock;
+        expect(typeof block_number).toEqual('number');
+        return expect(typeof timestamp).toEqual('number');
+      });
 
-      expect(typeof block_number).toEqual('number');
+      test(`getBlock(blockHash=undefined, blockNumber=${exampleBlockNumber})`, async () => {
+        const block = await testProvider.getBlock(exampleBlockNumber);
+        expect(block).toHaveProperty('block_hash');
+        expect(block).toHaveProperty('parent_hash');
+        expect(block).toHaveProperty('block_number');
+        expect(block).toHaveProperty('status');
+        expect(block).toHaveProperty('new_root');
+        expect(block).toHaveProperty('timestamp');
+        expect(block).toHaveProperty('transactions');
+        expect(Array.isArray(block.transactions)).toBe(true);
+      });
 
-      return expect(typeof timestamp).toEqual('number');
-    });
+      test(`getBlock(blockHash=${exampleBlockHash}, blockNumber=undefined)`, async () => {
+        const block = await testProvider.getBlock(exampleBlockHash);
+        expect(block).toHaveProperty('block_hash');
+        expect(block).toHaveProperty('parent_hash');
+        expect(block).toHaveProperty('block_number');
+        expect(block).toHaveProperty('status');
+        expect(block).toHaveProperty('new_root');
+        expect(block).toHaveProperty('timestamp');
+        expect(block).toHaveProperty('transactions');
+        expect(Array.isArray(block.transactions)).toBe(true);
+      });
 
-    test('getBlock() -> { blockNumber }', async () => {
-      const block = await testProvider.getBlock('latest');
-      return expect(block).toHaveProperty('block_number');
+      test('getBlock() -> { blockNumber }', async () => {
+        const block = await testProvider.getBlock('latest');
+        return expect(block).toHaveProperty('block_number');
+      });
     });
 
     test('getNonce()', async () => {
@@ -64,6 +79,25 @@ describe('defaultProvider', () => {
       return expect(nonce).toEqual('0x0');
     });
 
+    test('getClassAt(contractAddress, blockNumber="latest")', async () => {
+      const classResponse = await testProvider.getClassAt(exampleContractAddress);
+
+      expect(classResponse).toHaveProperty('program');
+      expect(classResponse).toHaveProperty('entry_points_by_type');
+    });
+
+    // TODO see if feasible to split
+    describe('getClassHashAt & GetClass', () => {
+      test('responses', async () => {
+        const classHash = await testProvider.getClassHashAt(exampleContractAddress);
+        expect(typeof classHash).toBe('string');
+
+        const classResponse = await testProvider.getClass(classHash);
+        expect(classResponse).toHaveProperty('program');
+        expect(classResponse).toHaveProperty('entry_points_by_type');
+      });
+    });
+
     describe('getStorageAt', () => {
       test('with "key" type of number', () => {
         return expect(testProvider.getStorageAt(exampleContractAddress, 0)).resolves.not.toThrow();
@@ -82,7 +116,7 @@ describe('defaultProvider', () => {
       });
     });
 
-    test('getTransaction() - successful transaction', async () => {
+    test('getTransaction() - successful deploy transaction', async () => {
       const transaction = await testProvider.getTransaction(exampleTransactionHash);
 
       expect(transaction).toHaveProperty('transaction_hash');
@@ -91,198 +125,51 @@ describe('defaultProvider', () => {
     test('getTransactionReceipt() - successful transaction', async () => {
       const transactionReceipt = await testProvider.getTransactionReceipt(exampleTransactionHash);
 
-      return expect(transactionReceipt).toHaveProperty('actual_fee');
-    });
-
-    test('callContract()', () => {
-      return expect(
-        testProvider.callContract({
-          contractAddress: exampleContractAddress,
-          entrypoint: 'balanceOf',
-          calldata: compileCalldata({
-            user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
-          }),
-        })
-      ).resolves.not.toThrow();
-    });
-
-    test('callContract() - gateway error', async () => {
-      return expect(
-        testProvider.callContract({
-          contractAddress: exampleContractAddress,
-          entrypoint: 'non_existent_entrypoint',
-          calldata: compileCalldata({
-            user: '0xdeadbeef',
-          }),
-        })
-      ).rejects.toThrowError();
+      expect(transactionReceipt).toHaveProperty('actual_fee');
+      expect(transactionReceipt).toHaveProperty('transaction_hash');
+      expect(transactionReceipt).toHaveProperty('status');
+      expect(transactionReceipt).toHaveProperty('actual_fee');
     });
-  });
-
-  describe('addTransaction()', () => {
-    test('deployContract()', async () => {
-      const response = await testProvider.deployContract({
-        contract: compiledOpenZeppelinAccount,
-      });
 
-      expect(response.transaction_hash).toBeDefined();
-      expect(response.contract_address).toBeDefined();
-    });
-  });
-
-  describeIfNotDevnet('Provider', () => {
-    const provider = getTestProvider();
-    let latestBlock;
-    describe(`Provider methods if not devnet`, () => {
-      describe('getBlock', () => {
-        test('getBlock by tag latest', async () => {
-          latestBlock = await provider.getBlock('latest');
-          expect(latestBlock).toHaveProperty('block_hash');
-          expect(latestBlock).toHaveProperty('parent_hash');
-          expect(latestBlock).toHaveProperty('block_number');
-          expect(latestBlock).toHaveProperty('status');
-          expect(latestBlock).toHaveProperty('new_root');
-          expect(latestBlock).toHaveProperty('timestamp');
-          expect(latestBlock).toHaveProperty('transactions');
-          expect(Array.isArray(latestBlock.transactions)).toBe(true);
-        });
-
-        test('getBlock by Hash', async () => {
-          const block = await provider.getBlock(latestBlock.block_hash);
-          expect(block).toHaveProperty('block_hash');
-          expect(block).toHaveProperty('parent_hash');
-          expect(block).toHaveProperty('block_number');
-          expect(block).toHaveProperty('status');
-          expect(block).toHaveProperty('new_root');
-          expect(block).toHaveProperty('timestamp');
-          expect(block).toHaveProperty('transactions');
-          expect(Array.isArray(block.transactions)).toBe(true);
-        });
-
-        test('getBlock by Number', async () => {
-          const block = await provider.getBlock(latestBlock.block_number);
-          expect(block).toHaveProperty('block_hash');
-          expect(block).toHaveProperty('parent_hash');
-          expect(block).toHaveProperty('block_number');
-          expect(block).toHaveProperty('status');
-          expect(block).toHaveProperty('new_root');
-          expect(block).toHaveProperty('timestamp');
-          expect(block).toHaveProperty('transactions');
-          expect(Array.isArray(block.transactions)).toBe(true);
-        });
-      });
-
-      describe('getStorageAt', () => {
-        test('pending', async () => {
-          const storage = await provider.getStorageAt(
-            '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
-            '0'
-          );
-          expect(typeof storage).toBe('string');
-        });
-
-        test('Block Hash 0x7104702055c2a5773a870ceada9552ec659d69c18053b14078983f07527dea8', async () => {
-          const storage = await provider.getStorageAt(
-            '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
-            '0',
-            '0x7225762c7ff5e7e5f0867f0a8e73594df4f44f05a65375339a76398e8ae3e64'
-          );
-          expect(typeof storage).toBe('string');
-        });
-      });
-
-      describe('getTransaction', () => {
-        test('Deploy Transaction Hash 0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348', async () => {
-          const transaction = await provider.getTransaction(
-            '0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348'
-          );
-
-          expect(transaction.transaction_hash).toBeTruthy();
-          expect(transaction.contract_address).toBeTruthy();
-        });
-
-        test('Invoke Transaction Hash 0x2a56c636f45761c99a67ecdf0f185a6d5fe5239924ed9a4886fddbfaf3227b', async () => {
-          const transaction = await provider.getTransaction(
-            '0x2a56c636f45761c99a67ecdf0f185a6d5fe5239924ed9a4886fddbfaf3227b'
-          );
-
-          expect(transaction.transaction_hash).toBeTruthy();
-          expect(transaction.contract_address).toBeTruthy();
-          expect(Array.isArray(transaction.calldata)).toBe(true);
-          // expect(transaction.entry_point_selector).toBeTruthy();
-          expect(Array.isArray(transaction.signature)).toBe(true);
-          expect(transaction.max_fee).toBeTruthy();
-        });
-
-        test('Declare Transaction Hash 0x79b130f2e808db6ab4b83f0182f016a128d73752b849e5b0221c2b3a35a87ea', async () => {
-          const transaction = await provider.getTransaction(
-            '0x79b130f2e808db6ab4b83f0182f016a128d73752b849e5b0221c2b3a35a87ea'
-          );
-
-          expect(transaction.max_fee).toBeTruthy();
-          expect(transaction.transaction_hash).toBeTruthy();
-          expect(transaction).toHaveProperty('nonce');
-          expect(transaction).toHaveProperty('version');
-        });
+    describe('callContract()', () => {
+      test('callContract()', () => {
+        return expect(
+          testProvider.callContract({
+            contractAddress: exampleContractAddress,
+            entrypoint: 'balanceOf',
+            calldata: compileCalldata({
+              user: '0x9ff64f4ab0e1fe88df4465ade98d1ea99d5732761c39279b8e1374fa943e9b',
+            }),
+          })
+        ).resolves.not.toThrow();
       });
 
-      describe('getTransactionReceipt', () => {
-        test('Transaction Hash 0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348', async () => {
-          const receipt = await provider.getTransactionReceipt(
-            '0x37013e1cb9c133e6fe51b4b371b76b317a480f56d80576730754c1662582348'
-          );
-          expect(receipt).toHaveProperty('transaction_hash');
-          expect(receipt).toHaveProperty('status');
-          expect(receipt).toHaveProperty('actual_fee');
-        });
+      test('callContract() - user wallet', () => {
+        return expect(
+          testProvider
+            .callContract({
+              contractAddress: exampleContractAddress,
+              entrypoint: 'balanceOf',
+              calldata: compileCalldata({
+                user: wallet,
+              }),
+            })
+            .then((res) => {
+              expect(Array.isArray(res.result)).toBe(true);
+            })
+        ).resolves.not.toThrow();
       });
 
-      describe('Contract methods', () => {
-        let contractAddress: string;
-        let deployResponse: DeployContractResponse;
-        let blockNumber: BlockNumber;
-
-        beforeAll(async () => {
-          const erc20DeployPayload = getERC20DeployPayload(wallet);
-          deployResponse = await provider.deployContract(erc20DeployPayload);
-          contractAddress = deployResponse.contract_address;
-          await provider.waitForTransaction(deployResponse.transaction_hash);
-          ({ block_number: blockNumber } = await provider.getBlock('latest'));
-        });
-
-        describe('deployContract', () => {
-          test('response', () => {
-            expect(deployResponse.contract_address).toBeTruthy();
-            expect(deployResponse.transaction_hash).toBeTruthy();
-          });
-        });
-
-        describe('getClassAt', () => {
-          test('response', async () => {
-            const classResponse = await provider.getClassAt(contractAddress, blockNumber);
-
-            expect(classResponse).toHaveProperty('program');
-            expect(classResponse).toHaveProperty('entry_points_by_type');
-          });
-        });
-
-        describe('callContract', () => {
-          test('result', () => {
-            return expect(
-              provider
-                .callContract({
-                  contractAddress: deployResponse.contract_address,
-                  entrypoint: 'balanceOf',
-                  calldata: compileCalldata({
-                    user: wallet,
-                  }),
-                })
-                .then((res) => {
-                  expect(Array.isArray(res.result)).toBe(true);
-                })
-            ).resolves.not.toThrow();
-          });
-        });
+      test('callContract() - gateway error', async () => {
+        return expect(
+          testProvider.callContract({
+            contractAddress: exampleContractAddress,
+            entrypoint: 'non_existent_entrypoint',
+            calldata: compileCalldata({
+              user: '0xdeadbeef',
+            }),
+          })
+        ).rejects.toThrowError();
       });
     });
   });

package/__tests__/fixtures.ts

@@ -28,10 +28,10 @@ const IS_RPC_DEVNET = Boolean(
 );
 const IS_SEQUENCER = !IS_RPC;
 const IS_SEQUENCER_DEVNET = !BASE_URL.includes('starknet.io');
-export const IS_SEQUENCER_GOERLI = BASE_URL === 'https://alpha4.starknet.io';
+export const IS_SEQUENCER_GOERLI = BASE_URL === 'https://alpha4-2.starknet.io';
 export const IS_DEVNET = IS_SEQUENCER ? IS_SEQUENCER_DEVNET : IS_RPC_DEVNET;
 
-export const getTestProvider = () => {
+export const getTestProvider = (): ProviderInterface => {
   const provider = RPC_URL
     ? new RpcProvider({ nodeUrl: RPC_URL })
     : new SequencerProvider({ baseUrl: BASE_URL });

package/__tests__/rpcProvider.test.ts

@@ -1,4 +1,5 @@
 import { Account, GetBlockResponse, RpcProvider, ec } from '../src';
+import { StarknetChainId } from '../src/constants';
 import {
   compiledOpenZeppelinAccount,
   describeIfRpc,
@@ -22,7 +23,9 @@ describeIfRpc('RPCProvider', () => {
 
   test('getChainId', async () => {
     const chainId = await rpcProvider.getChainId();
-    expect(chainId).toBe('0x534e5f474f45524c49');
+    expect([StarknetChainId.TESTNET2, StarknetChainId.MAINNET, StarknetChainId.TESTNET]).toContain(
+      chainId
+    );
   });
 
   test('getPendingTransactions', async () => {
@@ -106,7 +109,7 @@ describeIfRpc('RPCProvider', () => {
       });
 
       test('getClassHashAt', async () => {
-        const classHash = await rpcProvider.getClassHashAt('latest', contract_address);
+        const classHash = await rpcProvider.getClassHashAt(contract_address);
         expect(typeof classHash).toBe('string');
       });
 
@@ -115,9 +118,9 @@ describeIfRpc('RPCProvider', () => {
       });
     });
 
-    test('getClass classHash 0x0733734fa0dab1158bccdfe0df7b0becf3827f908971fac8d39cc73d99ad8645', async () => {
+    test('getClass classHash 0x03fcbf77b28c96f4f2fb5bd2d176ab083a12a5e123adeb0de955d7ee228c9854', async () => {
       const contractClass = await rpcProvider.getClass(
-        '0x0733734fa0dab1158bccdfe0df7b0becf3827f908971fac8d39cc73d99ad8645'
+        '0x03fcbf77b28c96f4f2fb5bd2d176ab083a12a5e123adeb0de955d7ee228c9854'
       );
       expect(contractClass).toHaveProperty('program');
       expect(contractClass).toHaveProperty('entry_points_by_type');

package/__tests__/udc.test.ts

@@ -0,0 +1,41 @@
+import { encodeShortString } from '../src/utils/shortString';
+import { randomAddress } from '../src/utils/stark';
+import { IS_DEVNET, compiledErc20, getTestAccount, getTestProvider } from './fixtures';
+
+describe('Declare and UDC Deploy Flow', () => {
+  const provider = getTestProvider();
+  const account = getTestAccount(provider);
+  const erc20ClassHash = '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a';
+
+  test('ERC20 Declare', async () => {
+    const declareTx = await account.declare({
+      classHash: erc20ClassHash,
+      contract: compiledErc20,
+    });
+
+    await provider.waitForTransaction(declareTx.transaction_hash);
+
+    expect(declareTx).toHaveProperty('class_hash');
+    expect(declareTx.class_hash).toEqual(erc20ClassHash);
+  });
+
+  test('UDC Deploy', async () => {
+    const salt = randomAddress(); // use random salt
+
+    const deployment = await account.deploy({
+      classHash: erc20ClassHash,
+      constructorCalldata: [
+        encodeShortString('Token'),
+        encodeShortString('ERC20'),
+        account.address,
+      ],
+      salt,
+      unique: true, // Using true here so as not to clash with normal erc20 deploy in account and provider test
+      isDevnet: IS_DEVNET,
+    });
+
+    await provider.waitForTransaction(deployment.transaction_hash);
+
+    expect(deployment).toHaveProperty('transaction_hash');
+  });
+});

package/account/default.d.ts

@@ -4,7 +4,7 @@ import { BlockIdentifier } from '../provider/utils';
 import { SignerInterface } from '../signer';
 import { Abi, Call, DeclareContractResponse, DeployContractResponse, EstimateFeeAction, InvocationsDetails, InvokeFunctionResponse, KeyPair, Signature } from '../types';
 import { EstimateFee, EstimateFeeDetails } from '../types/account';
-import { AllowArray, DeclareContractPayload, DeployAccountContractPayload } from '../types/lib';
+import { AllowArray, DeclareContractPayload, DeployAccountContractPayload, UniversalDeployerContractPayload } from '../types/lib';
 import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData';
 import { AccountInterface } from './interface';
@@ -19,6 +19,8 @@ export declare class Account extends Provider implements AccountInterface {
     estimateAccountDeployFee({ classHash, addressSalt, constructorCalldata, contractAddress: providedContractAddress, }: DeployAccountContractPayload, { blockIdentifier, nonce: providedNonce }?: EstimateFeeDetails): Promise<EstimateFee>;
     execute(calls: AllowArray<Call>, abis?: Abi[] | undefined, transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
     declare({ classHash, contract }: DeclareContractPayload, transactionsDetail?: InvocationsDetails): Promise<DeclareContractResponse>;
+    deploy({ classHash, salt, unique, constructorCalldata, isDevnet, }: UniversalDeployerContractPayload, additionalCalls?: AllowArray<Call>, // support multicall
+    transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
     deployAccount({ classHash, constructorCalldata, addressSalt, contractAddress: providedContractAddress, }: DeployAccountContractPayload, transactionsDetail?: InvocationsDetails): Promise<DeployContractResponse>;
     signMessage(typedData: TypedData): Promise<Signature>;
     hashMessage(typedData: TypedData): Promise<string>;

package/account/default.js

@@ -61,6 +61,31 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Account = void 0;
 var constants_1 = require("../constants");
@@ -113,7 +138,7 @@ var Account = /** @class */ (function (_super) {
                         _e.label = 3;
                     case 3:
                         nonce = _c.apply(void 0, [_d]);
-                        version = (0, number_1.toBN)(hash_1.transactionVersion);
+                        version = (0, number_1.toBN)(hash_1.feeTransactionVersion);
                         return [4 /*yield*/, this.getChainId()];
                     case 4:
                         chainId = _e.sent();
@@ -155,7 +180,7 @@ var Account = /** @class */ (function (_super) {
                         _f.label = 3;
                     case 3:
                         nonce = _d.apply(void 0, [_e]);
-                        version = (0, number_1.toBN)(hash_1.transactionVersion);
+                        version = (0, number_1.toBN)(hash_1.feeTransactionVersion);
                         return [4 /*yield*/, this.getChainId()];
                     case 4:
                         chainId = _f.sent();
@@ -197,7 +222,7 @@ var Account = /** @class */ (function (_super) {
                         _h.label = 3;
                     case 3:
                         nonce = _f.apply(void 0, [_g]);
-                        version = (0, number_1.toBN)(hash_1.transactionVersion);
+                        version = (0, number_1.toBN)(hash_1.feeTransactionVersion);
                         return [4 /*yield*/, this.getChainId()];
                     case 4:
                         chainId = _h.sent();
@@ -328,6 +353,31 @@ var Account = /** @class */ (function (_super) {
             });
         });
     };
+    Account.prototype.deploy = function (_a, additionalCalls, // support multicall
+    transactionsDetail) {
+        var classHash = _a.classHash, salt = _a.salt, _b = _a.unique, unique = _b === void 0 ? true : _b, _c = _a.constructorCalldata, constructorCalldata = _c === void 0 ? [] : _c, _d = _a.isDevnet, isDevnet = _d === void 0 ? false : _d;
+        if (additionalCalls === void 0) { additionalCalls = []; }
+        if (transactionsDetail === void 0) { transactionsDetail = {}; }
+        return __awaiter(this, void 0, void 0, function () {
+            var compiledConstructorCallData, callsArray;
+            return __generator(this, function (_e) {
+                compiledConstructorCallData = (0, stark_1.compileCalldata)(constructorCalldata);
+                callsArray = Array.isArray(additionalCalls) ? additionalCalls : [additionalCalls];
+                return [2 /*return*/, this.execute(__spreadArray([
+                        {
+                            contractAddress: isDevnet ? constants_1.UDC.ADDRESS_DEVNET : constants_1.UDC.ADDRESS,
+                            entrypoint: constants_1.UDC.ENTRYPOINT,
+                            calldata: __spreadArray([
+                                classHash,
+                                salt,
+                                (0, number_1.toCairoBool)(unique),
+                                compiledConstructorCallData.length
+                            ], __read(compiledConstructorCallData), false),
+                        }
+                    ], __read(callsArray), false), undefined, transactionsDetail)];
+            });
+        });
+    };
     Account.prototype.deployAccount = function (_a, transactionsDetail) {
         var _b, _c;
         var classHash = _a.classHash, _d = _a.constructorCalldata, constructorCalldata = _d === void 0 ? [] : _d, _e = _a.addressSalt, addressSalt = _e === void 0 ? 0 : _e, providedContractAddress = _a.contractAddress;