starknet 4.9.0 → 4.10.0

package/CHANGELOG.md

@@ -1,3 +1,25 @@
+# [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

@@ -145,7 +145,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,13 @@ 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');
+    });
+
     describe('getStorageAt', () => {
       test('with "key" type of number', () => {
         return expect(testProvider.getStorageAt(exampleContractAddress, 0)).resolves.not.toThrow();
@@ -82,7 +104,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 +113,51 @@ describe('defaultProvider', () => {
     test('getTransactionReceipt() - successful transaction', async () => {
       const transactionReceipt = await testProvider.getTransactionReceipt(exampleTransactionHash);
 
-      return expect(transactionReceipt).toHaveProperty('actual_fee');
+      expect(transactionReceipt).toHaveProperty('actual_fee');
+      expect(transactionReceipt).toHaveProperty('transaction_hash');
+      expect(transactionReceipt).toHaveProperty('status');
+      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();
-    });
-  });
-
-  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,7 +28,7 @@ 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 = () => {

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,7 @@ describeIfRpc('RPCProvider', () => {
 
   test('getChainId', async () => {
     const chainId = await rpcProvider.getChainId();
-    expect(chainId).toBe('0x534e5f474f45524c49');
+    expect(chainId).toBe(StarknetChainId.TESTNET2);
   });
 
   test('getPendingTransactions', async () => {
@@ -115,9 +116,9 @@ describeIfRpc('RPCProvider', () => {
       });
     });
 
-    test('getClass classHash 0x0733734fa0dab1158bccdfe0df7b0becf3827f908971fac8d39cc73d99ad8645', async () => {
+    test('getClass classHash 0x00808396477a4296946bf6574afb2e14723f8d9a37bba25a1e104315ca89b1f7', async () => {
       const contractClass = await rpcProvider.getClass(
-        '0x0733734fa0dab1158bccdfe0df7b0becf3827f908971fac8d39cc73d99ad8645'
+        '0x00808396477a4296946bf6574afb2e14723f8d9a37bba25a1e104315ca89b1f7'
       );
       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");
@@ -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;

package/account/interface.d.ts

@@ -2,7 +2,7 @@ import { ProviderInterface } from '../provider';
 import { BlockIdentifier } from '../provider/utils';
 import { SignerInterface } from '../signer';
 import { Abi, Call, DeclareContractResponse, DeployContractResponse, EstimateFeeAction, EstimateFeeDetails, EstimateFeeResponse, InvocationsDetails, InvokeFunctionResponse, Signature } from '../types';
-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/types';
 export declare abstract class AccountInterface extends ProviderInterface {
@@ -45,7 +45,7 @@ export declare abstract class AccountInterface extends ProviderInterface {
      * Estimate Fee for executing a DEPLOY_ACCOUNT transaction on starknet
      *
      * @param contractPayload the payload object containing:
-     * - contract - the compiled contract to be declared
+     * - contract - the compiled contract to be deployed
      * - classHash - the class hash of the compiled contract. This can be obtained by using starknet-cli.
      *
      * @returns response from estimate_fee
@@ -66,6 +66,7 @@ export declare abstract class AccountInterface extends ProviderInterface {
     abstract execute(transactions: AllowArray<Call>, abis?: Abi[], transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
     /**
      * Declares a given compiled contract (json) to starknet
+     *
      * @param contractPayload transaction payload to be deployed containing:
     - contract: compiled contract code
     - classHash: computed class hash of compiled contract
@@ -77,13 +78,27 @@ export declare abstract class AccountInterface extends ProviderInterface {
      * @returns a confirmation of sending a transaction on the starknet contract
      */
     abstract declare(contractPayload: DeclareContractPayload, transactionsDetail?: InvocationsDetails): Promise<DeclareContractResponse>;
+    /**
+     * @param deployContractPayload containing
+     * - classHash: computed class hash of compiled contract
+     * - salt: address salt
+     * - unique: bool if true ensure unique salt
+     * - calldata: constructor calldata
+     * @param additionalCalls - optional additional calls array to support multicall
+     * @param transactionsDetail Invocation Details containing:
+     *  - optional nonce
+     *  - optional version
+     *  - optional maxFee
+     */
+    abstract deploy(deployContractPayload: UniversalDeployerContractPayload, additionalCalls?: AllowArray<Call>, transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
     /**
      * Deploy the account on Starknet
+     *
      * @param contractPayload transaction payload to be deployed containing:
-     * - classHash: computed class hash of compiled contract
-     * - constructor calldata
-     * - address salt
-    - signature
+    - classHash: computed class hash of compiled contract
+    - optional constructor calldata
+    - optional address salt
+    - optional contractAddress
      * @param transactionsDetail Invocation Details containing:
     - optional nonce
     - optional version
@@ -112,7 +127,7 @@ export declare abstract class AccountInterface extends ProviderInterface {
     /**
      * Verify a signature of a JSON object
      *
-     * @param json - JSON object to be verified
+     * @param typedData - 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
@@ -130,12 +145,14 @@ export declare abstract class AccountInterface extends ProviderInterface {
     abstract verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
     /**
      * Gets the nonce of the account with respect to a specific block
+     *
      * @param  {BlockIdentifier} blockIdentifier - optional blockIdentifier. Defaults to 'pending'
      * @returns nonce of the account
      */
     abstract getNonce(blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     /**
      * Gets Suggested Max Fee based on the transaction type
+     *
      * @param  {EstimateFeeAction} estimateFeeAction
      * @param  {EstimateFeeDetails} details
      * @returns suggestedMaxFee

package/constants.d.ts

@@ -7,7 +7,8 @@ export declare const MASK_250: import("bn.js");
 export declare const MASK_251: import("bn.js");
 export declare enum StarknetChainId {
     MAINNET = "0x534e5f4d41494e",
-    TESTNET = "0x534e5f474f45524c49"
+    TESTNET = "0x534e5f474f45524c49",
+    TESTNET2 = "0x534e5f474f45524c4932"
 }
 export declare enum TransactionHashPrefix {
     DECLARE = "0x6465636c617265",
@@ -16,6 +17,11 @@ export declare enum TransactionHashPrefix {
     INVOKE = "0x696e766f6b65",
     L1_HANDLER = "0x6c315f68616e646c6572"
 }
+export declare const UDC: {
+    ADDRESS: string;
+    ENTRYPOINT: string;
+    ADDRESS_DEVNET: string;
+};
 /**
  * The following is taken from https://github.com/starkware-libs/starkex-resources/blob/master/crypto/starkware/crypto/signature/pedersen_params.json but converted to hex, because JS is very bad handling big integers by default
  * Please do not edit until the JSON changes.