starknet 4.13.2 → 4.14.0

package/__tests__/fixtures.ts

@@ -1,11 +1,13 @@
 import fs from 'fs';
+import path from 'path';
 
 import { Account, ProviderInterface, RpcProvider, SequencerProvider, ec, json } from '../src';
-import { CompiledContract, DeployContractPayload } from '../src/types';
-import { encodeShortString } from '../src/utils/shortString';
+import { CompiledContract } from '../src/types';
 
 const readContract = (name: string): CompiledContract =>
-  json.parse(fs.readFileSync(`./__mocks__/${name}.json`).toString('ascii'));
+  json.parse(
+    fs.readFileSync(path.resolve(__dirname, `../__mocks__/${name}.json`)).toString('ascii')
+  );
 
 export const compiledOpenZeppelinAccount = readContract('Account');
 export const compiledErc20 = readContract('ERC20');
@@ -14,33 +16,37 @@ export const compiledTypeTransformation = readContract('contract');
 export const compiledMulticall = readContract('multicall');
 export const compiledTestDapp = readContract('TestDapp');
 
-const DEFAULT_TEST_PROVIDER_BASE_URL = 'http://127.0.0.1:5050/';
-const DEFAULT_TEST_ACCOUNT_ADDRESS = // run `starknet-devnet --seed 0` and this will be the first account
+/* Default test config based on run `starknet-devnet --seed 0` */
+const DEFAULT_TEST_PROVIDER_SEQUENCER_URL = 'http://127.0.0.1:5050/';
+const DEFAULT_TEST_ACCOUNT_ADDRESS =
   '0x7e00d496e324876bbc8531f2d9a82bf154d1a04a50218ee74cdd372f75a551a';
 const DEFAULT_TEST_ACCOUNT_PRIVATE_KEY = '0xe3e70682c2094cac629f6fbed82c07cd';
 
-const BASE_URL = process.env.TEST_PROVIDER_BASE_URL || DEFAULT_TEST_PROVIDER_BASE_URL;
+/* User defined config or default one */
+const BASE_URL = process.env.TEST_PROVIDER_BASE_URL || DEFAULT_TEST_PROVIDER_SEQUENCER_URL;
 const RPC_URL = process.env.TEST_RPC_URL;
 
-const IS_RPC = !!RPC_URL;
-const IS_RPC_DEVNET = Boolean(
-  RPC_URL && (RPC_URL.includes('localhost') || RPC_URL.includes('127.0.0.1'))
-);
-const IS_SEQUENCER = !IS_RPC;
-const IS_SEQUENCER_DEVNET = !BASE_URL.includes('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;
+/* Detect user defined node or sequencer, if none default to sequencer if both default to node */
+const PROVIDER_URL = RPC_URL || BASE_URL;
+
+/* Detect is localhost devnet */
+export const IS_LOCALHOST_DEVNET =
+  PROVIDER_URL.includes('localhost') || PROVIDER_URL.includes('127.0.0.1');
+
+/* Definitions */
+export const IS_RPC = !!RPC_URL;
+export const IS_SEQUENCER = !RPC_URL;
 
 export const getTestProvider = (): ProviderInterface => {
   const provider = RPC_URL
     ? new RpcProvider({ nodeUrl: RPC_URL })
     : new SequencerProvider({ baseUrl: BASE_URL });
 
-  if (IS_DEVNET) {
+  if (IS_LOCALHOST_DEVNET) {
     // accelerate the tests when running locally
     const originalWaitForTransaction = provider.waitForTransaction.bind(provider);
     provider.waitForTransaction = (txHash, retryInterval) => {
-      return originalWaitForTransaction(txHash, retryInterval || 1000);
+      return originalWaitForTransaction(txHash, undefined, retryInterval || 1000);
     };
   }
 
@@ -52,11 +58,10 @@ export const getTestAccount = (provider: ProviderInterface) => {
   let testAccountAddress = process.env.TEST_ACCOUNT_ADDRESS;
   let testAccountPrivateKey = process.env.TEST_ACCOUNT_PRIVATE_KEY;
 
-  if (!IS_DEVNET) {
+  if (!IS_LOCALHOST_DEVNET) {
     if (!testAccountPrivateKey) {
       throw new Error('TEST_ACCOUNT_PRIVATE_KEY is not set');
     }
-
     if (!testAccountAddress) {
       throw new Error('TEST_ACCOUNT_ADDRESS is not set');
     }
@@ -69,15 +74,9 @@ export const getTestAccount = (provider: ProviderInterface) => {
 };
 
 const describeIf = (condition: boolean) => (condition ? describe : describe.skip);
-export const describeIfSequencer = describeIf(IS_DEVNET);
+export const describeIfSequencer = describeIf(IS_SEQUENCER);
 export const describeIfRpc = describeIf(IS_RPC);
-export const describeIfNotDevnet = describeIf(!IS_DEVNET);
+export const describeIfNotDevnet = describeIf(!IS_LOCALHOST_DEVNET);
+export const describeIfDevnet = describeIf(IS_LOCALHOST_DEVNET);
 
 export const erc20ClassHash = '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a';
-
-export const getERC20DeployPayload = (recipient: string): DeployContractPayload => {
-  return {
-    contract: compiledErc20,
-    constructorCalldata: [encodeShortString('Token'), encodeShortString('ERC20'), recipient],
-  };
-};

package/__tests__/rpcProvider.test.ts

@@ -2,21 +2,19 @@ import { Account, GetBlockResponse, RpcProvider, ec } from '../src';
 import { StarknetChainId } from '../src/constants';
 import {
   compiledOpenZeppelinAccount,
+  describeIfNotDevnet,
   describeIfRpc,
   getTestAccount,
   getTestProvider,
 } from './fixtures';
 
 describeIfRpc('RPCProvider', () => {
-  let rpcProvider: RpcProvider;
+  const rpcProvider = getTestProvider() as RpcProvider;
+  const account = getTestAccount(rpcProvider);
   let accountPublicKey: string;
 
   beforeAll(async () => {
-    rpcProvider = getTestProvider() as RpcProvider;
-    const account = getTestAccount(rpcProvider);
-
     expect(account).toBeInstanceOf(Account);
-
     const accountKeyPair = ec.genKeyPair();
     accountPublicKey = ec.getStarkKey(accountKeyPair);
   });
@@ -28,11 +26,6 @@ describeIfRpc('RPCProvider', () => {
     );
   });
 
-  test('getPendingTransactions', async () => {
-    const transactions = await rpcProvider.getPendingTransactions();
-    expect(Array.isArray(transactions)).toBe(true);
-  });
-
   test('getTransactionCount', async () => {
     const count = await rpcProvider.getTransactionCount('latest');
     expect(typeof count).toBe('number');
@@ -52,10 +45,17 @@ describeIfRpc('RPCProvider', () => {
     expect(stateUpdate).toHaveProperty('state_diff');
   });
 
-  xtest('getProtocolVersion', async () => {
+  xtest('getProtocolVersion - pathfinder not implement', async () => {
     await rpcProvider.getProtocolVersion();
   });
 
+  describeIfNotDevnet('devnet not implement', () => {
+    test('getPendingTransactions', async () => {
+      const transactions = await rpcProvider.getPendingTransactions();
+      expect(Array.isArray(transactions)).toBe(true);
+    });
+  });
+
   describe('RPC methods', () => {
     let latestBlock: GetBlockResponse;
 
@@ -90,15 +90,18 @@ describeIfRpc('RPCProvider', () => {
       let transaction_hash;
 
       beforeAll(async () => {
-        ({ contract_address, transaction_hash } = await rpcProvider.deployContract({
+        const { deploy } = await account.declareDeploy({
           contract: compiledOpenZeppelinAccount,
+          classHash: '0x03fcbf77b28c96f4f2fb5bd2d176ab083a12a5e123adeb0de955d7ee228c9854',
           constructorCalldata: [accountPublicKey],
-          addressSalt: accountPublicKey,
-        }));
-        await rpcProvider.waitForTransaction(transaction_hash);
+          salt: accountPublicKey,
+        });
+
+        contract_address = deploy.contract_address;
+        transaction_hash = deploy.transaction_hash;
       });
 
-      test('deployContract result', () => {
+      test('declareDeploy()', () => {
         expect(contract_address).toBeTruthy();
         expect(transaction_hash).toBeTruthy();
       });

package/__tests__/sequencerProvider.test.ts

@@ -1,46 +1,35 @@
 import { Contract, Provider, SequencerProvider, stark } from '../src';
 import { toBN } from '../src/utils/number';
+import { encodeShortString } from '../src/utils/shortString';
 import {
-  IS_SEQUENCER_GOERLI,
   compiledErc20,
   compiledL1L2,
+  describeIfDevnet,
   describeIfNotDevnet,
   describeIfSequencer,
-  getERC20DeployPayload,
+  getTestAccount,
   getTestProvider,
 } from './fixtures';
 
-// Run only if Devnet Sequencer
 describeIfSequencer('SequencerProvider', () => {
-  let sequencerProvider: SequencerProvider;
+  const sequencerProvider = getTestProvider() as SequencerProvider;
+  const account = getTestAccount(sequencerProvider);
   let customSequencerProvider: Provider;
   let exampleContractAddress: string;
 
-  beforeAll(async () => {
-    sequencerProvider = getTestProvider() as SequencerProvider;
-    customSequencerProvider = new Provider({
-      sequencer: {
-        baseUrl: 'http://127.0.0.1:5050/',
-        feederGatewayUrl: 'feeder_gateway',
-        gatewayUrl: 'gateway',
-      }, // Similar to arguements used in docs
-    });
-  });
-
   describe('Gateway specific methods', () => {
     let exampleTransactionHash: string;
     const wallet = stark.randomAddress();
 
     beforeAll(async () => {
-      const erc20DeployPayload = getERC20DeployPayload(wallet);
-
-      const { contract_address, transaction_hash } = await sequencerProvider.deployContract(
-        erc20DeployPayload
-      );
+      const { deploy } = await account.declareDeploy({
+        contract: compiledErc20,
+        classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
+        constructorCalldata: [encodeShortString('Token'), encodeShortString('ERC20'), wallet],
+      });
 
-      await sequencerProvider.waitForTransaction(transaction_hash);
-      exampleTransactionHash = transaction_hash;
-      exampleContractAddress = contract_address;
+      exampleTransactionHash = deploy.transaction_hash;
+      exampleContractAddress = deploy.contract_address;
     });
 
     test('getTransactionStatus()', async () => {
@@ -69,43 +58,16 @@ describeIfSequencer('SequencerProvider', () => {
     });
   });
 
-  describe('Test calls with Custom Sequencer Provider', () => {
-    let erc20: Contract;
-    const wallet = stark.randomAddress();
-
-    beforeAll(async () => {
-      const erc20DeployPayload = getERC20DeployPayload(wallet);
-
-      const { contract_address, transaction_hash } = await customSequencerProvider.deployContract(
-        erc20DeployPayload
-      );
-
-      await customSequencerProvider.waitForTransaction(transaction_hash);
-      erc20 = new Contract(compiledErc20.abi, contract_address, customSequencerProvider);
-    });
-
-    test('Check ERC20 balance using Custom Sequencer Provider', async () => {
-      const result = await erc20.balanceOf(wallet);
-      const [res] = result;
-      expect(res.low).toStrictEqual(toBN(1000));
-      expect(res).toStrictEqual(result.balance);
-    });
-  });
-
   describe('Test Estimate message fee', () => {
     const L1_ADDRESS = '0x8359E4B0152ed5A731162D3c7B0D8D56edB165A0';
     let l1l2ContractAddress: string;
 
     beforeAll(async () => {
-      if (IS_SEQUENCER_GOERLI) {
-        l1l2ContractAddress = '0x2863141e0d9a74e9b484c1f5b1e3a2f6cbb6b84df8233c7c1cbe31334d9aed8';
-      } else {
-        const { transaction_hash, contract_address } = await sequencerProvider.deployContract({
-          contract: compiledL1L2,
-        });
-        await sequencerProvider.waitForTransaction(transaction_hash);
-        l1l2ContractAddress = contract_address;
-      }
+      const { deploy } = await account.declareDeploy({
+        contract: compiledL1L2,
+        classHash: '0x028d1671fb74ecb54d848d463cefccffaef6df3ae40db52130e19fe8299a7b43',
+      });
+      l1l2ContractAddress = deploy.contract_address;
     });
 
     test('estimate message fee', async () => {
@@ -128,4 +90,34 @@ describeIfSequencer('SequencerProvider', () => {
       );
     });
   });
+
+  describeIfDevnet('Test calls with Custom Devnet Sequencer Provider', () => {
+    let erc20: Contract;
+    const wallet = stark.randomAddress();
+
+    beforeAll(async () => {
+      customSequencerProvider = new Provider({
+        sequencer: {
+          baseUrl: 'http://127.0.0.1:5050/',
+          feederGatewayUrl: 'feeder_gateway',
+          gatewayUrl: 'gateway',
+        },
+      });
+      const accountCustom = getTestAccount(customSequencerProvider);
+      const { deploy } = await accountCustom.declareDeploy({
+        contract: compiledErc20,
+        classHash: '0x54328a1075b8820eb43caf0caa233923148c983742402dcfc38541dd843d01a',
+        constructorCalldata: [encodeShortString('Token'), encodeShortString('ERC20'), wallet],
+      });
+
+      erc20 = new Contract(compiledErc20.abi, deploy.contract_address, customSequencerProvider);
+    });
+
+    test('Check ERC20 balance using Custom Sequencer Provider', async () => {
+      const result = await erc20.balanceOf(wallet);
+      const [res] = result;
+      expect(res.low).toStrictEqual(toBN(1000));
+      expect(res).toStrictEqual(result.balance);
+    });
+  });
 });

package/__tests__/utils/utils.test.ts

@@ -27,12 +27,21 @@ describe('compressProgram()', () => {
     expect(compressed).toMatchSnapshot();
   });
 });
+
 describe('hexToDecimalString()', () => {
   test('parse 0xa23', () => {
     expect(number.hexToDecimalString('0xa23')).toBe('2595');
   });
 });
 
+describe('cleanHex()', () => {
+  test('parse 0xa23', () => {
+    expect(number.cleanHex('0x023Ab')).toBe('0x23ab');
+    expect(number.cleanHex('0x000023Ab')).toBe('0x23ab');
+    expect(number.cleanHex('0x23Ab')).toBe('0x23ab');
+  });
+});
+
 describe('makeAddress()', () => {
   test('test on eth address', () => {
     const ethAddress = '0xdFD0F27FCe99b50909de0bDD328Aed6eAbe76BC5';
@@ -42,6 +51,7 @@ describe('makeAddress()', () => {
     expect(starkAddress).toBe('0xdfd0f27fce99b50909de0bdd328aed6eabe76bc5');
   });
 });
+
 describe('getSelectorFromName()', () => {
   test('hash works for value="test"', () => {
     expect(hash.getSelectorFromName('test')).toBe(

package/dist/index.d.ts

@@ -9,6 +9,11 @@ declare function toBN(number: BigNumberish, base?: number | 'hex'): BN__default;
 declare function toHex(number: BN__default): string;
 declare function hexToDecimalString(hex: string): string;
 declare function toFelt(num: BigNumberish): string;
+/**
+ * Remove hex string leading zero and lower case '0x01A'.. -> '0x1a..'
+ * @param hex string
+ */
+declare const cleanHex: (hex: string) => string;
 declare function assertInRange(input: BigNumberish, lowerBound: BigNumberish, upperBound: BigNumberish, inputName?: string): void;
 declare function bigNumberishArrayToDecimalStringArray(rawCalldata: BigNumberish[]): string[];
 declare function bigNumberishArrayToHexadecimalStringArray(rawCalldata: BigNumberish[]): string[];
@@ -25,6 +30,7 @@ declare const number_toBN: typeof toBN;
 declare const number_toHex: typeof toHex;
 declare const number_hexToDecimalString: typeof hexToDecimalString;
 declare const number_toFelt: typeof toFelt;
+declare const number_cleanHex: typeof cleanHex;
 declare const number_assertInRange: typeof assertInRange;
 declare const number_bigNumberishArrayToDecimalStringArray: typeof bigNumberishArrayToDecimalStringArray;
 declare const number_bigNumberishArrayToHexadecimalStringArray: typeof bigNumberishArrayToHexadecimalStringArray;
@@ -42,6 +48,7 @@ declare namespace number {
     number_toHex as toHex,
     number_hexToDecimalString as hexToDecimalString,
     number_toFelt as toFelt,
+    number_cleanHex as cleanHex,
     number_assertInRange as assertInRange,
     number_bigNumberishArrayToDecimalStringArray as bigNumberishArrayToDecimalStringArray,
     number_bigNumberishArrayToHexadecimalStringArray as bigNumberishArrayToHexadecimalStringArray,
@@ -686,8 +693,8 @@ interface ContractClass {
 }
 declare type UniversalDeployerContractPayload = {
     classHash: BigNumberish;
-    salt: string;
-    unique: boolean;
+    salt?: string;
+    unique?: boolean;
     constructorCalldata?: RawArgs;
     additionalCalls?: AllowArray<Call>;
 };
@@ -709,6 +716,7 @@ declare type DeclareContractPayload = {
     contract: CompiledContract | string;
     classHash: BigNumberish;
 };
+declare type DeclareDeployContractPayload = DeclareContractPayload & UniversalDeployerContractPayload;
 declare type DeclareContractTransaction = {
     contractDefinition: ContractClass;
     senderAddress: string;
@@ -1013,10 +1021,6 @@ interface EstimateFeeResponse {
 interface InvokeFunctionResponse {
     transaction_hash: string;
 }
-interface DeployContractResponse {
-    contract_address: string;
-    transaction_hash: string;
-}
 interface DeclareContractResponse {
     transaction_hash: string;
     class_hash: string;
@@ -1045,6 +1049,23 @@ interface EstimateFeeDetails {
     nonce?: BigNumberish;
     blockIdentifier?: BlockIdentifier;
 }
+interface DeployContractResponse {
+    contract_address: string;
+    transaction_hash: string;
+}
+interface DeployContractUDCResponse extends DeployContractResponse {
+    address: string;
+    deployer: string;
+    unique: string;
+    classHash: string;
+    calldata_len: string;
+    calldata: Array<string>;
+    salt: string;
+}
+declare type DeclareDeployContractResponse = {
+    declare: DeclareTransactionReceiptResponse;
+    deploy: DeployContractUDCResponse;
+};
 
 declare type GetTransactionStatusResponse = {
     tx_status: Status;
@@ -1413,7 +1434,7 @@ declare abstract class ProviderInterface {
      * @param contractAddress - contract address
      * @returns the hex nonce
      */
-    abstract getNonce(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
+    abstract getNonceForAddress(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     /**
      * Gets the contract's storage variable at a specific key.
      *
@@ -1448,7 +1469,7 @@ declare abstract class ProviderInterface {
      * - address salt
      * @returns a confirmation of sending a transaction on the starknet contract
      */
-    abstract deployContract(payload: DeployContractPayload, details?: InvocationsDetails): Promise<DeployContractResponse>;
+    abstract deployContract(payload: DeployContractPayload | any, details?: InvocationsDetails): Promise<DeployContractResponse>;
     /**
      * Deploys a given compiled Account contract (json) to starknet
      *
@@ -1554,8 +1575,9 @@ declare abstract class ProviderInterface {
      * Wait for the transaction to be accepted
      * @param txHash - transaction hash
      * @param retryInterval - retry interval
+     * @return GetTransactionReceiptResponse
      */
-    abstract waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+    abstract waitForTransaction(txHash: BigNumberish, successStates?: Array<Status>, retryInterval?: number): Promise<GetTransactionReceiptResponse>;
 }
 
 declare type RpcProviderOptions = {
@@ -1579,7 +1601,7 @@ declare class RpcProvider implements ProviderInterface {
     getBlockWithTxHashes(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxHashesResponse>;
     getBlockWithTxs(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxs>;
     getClassHashAt(contractAddress: RPC.ContractAddress, blockIdentifier?: BlockIdentifier): Promise<RPC.Felt>;
-    getNonce(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<RPC.Nonce>;
+    getNonceForAddress(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<RPC.Nonce>;
     getPendingTransactions(): Promise<RPC.PendingTransactions>;
     getProtocolVersion(): Promise<Error>;
     getStateUpdate(blockIdentifier?: BlockIdentifier): Promise<RPC.StateUpdate>;
@@ -1606,7 +1628,7 @@ declare class RpcProvider implements ProviderInterface {
     callContract(call: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
     traceTransaction(transactionHash: RPC.TransactionHash): Promise<RPC.Trace>;
     traceBlockTransactions(blockHash: RPC.BlockHash): Promise<RPC.Traces>;
-    waitForTransaction(txHash: string, retryInterval?: number): Promise<void>;
+    waitForTransaction(txHash: string, successStates?: string[], retryInterval?: number): Promise<any>;
     /**
      * Gets the transaction count from a block.
      *
@@ -1666,7 +1688,7 @@ declare class SequencerProvider implements ProviderInterface {
     getChainId(): Promise<StarknetChainId>;
     callContract({ contractAddress, entrypoint: entryPointSelector, calldata }: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
     getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
-    getNonce(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
+    getNonceForAddress(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
     getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
@@ -1685,7 +1707,7 @@ declare class SequencerProvider implements ProviderInterface {
     getDeclareEstimateFee({ senderAddress, contractDefinition, signature }: DeclareContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
     getDeployAccountEstimateFee({ classHash, addressSalt, constructorCalldata, signature }: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
     getCode(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<Sequencer.GetCodeResponse>;
-    waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+    waitForTransaction(txHash: BigNumberish, successStates?: string[], retryInterval?: number): Promise<GetTransactionReceiptResponse>;
     /**
      * Gets the status of a transaction.
      *
@@ -1728,7 +1750,7 @@ declare class Provider implements ProviderInterface {
     getClassByHash(classHash: string): Promise<ContractClass>;
     getEstimateFee(invocationWithTxType: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
     getInvokeEstimateFee(invocationWithTxType: Invocation, invocationDetails: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
-    getNonce(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
+    getNonceForAddress(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
     getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
@@ -1737,13 +1759,13 @@ declare class Provider implements ProviderInterface {
     /**
      * @deprecated This method won't be supported, use Account.deploy instead
      */
-    deployContract(payload: DeployContractPayload, details: InvocationsDetails): Promise<DeployContractResponse>;
+    deployContract(payload: DeployContractPayload | any, details: InvocationsDetails): Promise<DeployContractResponse>;
     deployAccountContract(payload: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeployContractResponse>;
     declareContract(transaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce): Promise<DeclareContractResponse>;
     getDeclareEstimateFee(transaction: DeclareContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
     getDeployAccountEstimateFee(transaction: DeployAccountContractTransaction, details: InvocationsDetailsWithNonce, blockIdentifier?: BlockIdentifier): Promise<EstimateFeeResponse>;
     getCode(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
-    waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
+    waitForTransaction(txHash: BigNumberish, successStates?: Array<Status>, retryInterval?: number): Promise<any>;
 }
 
 declare class GatewayError extends CustomError {
@@ -2041,7 +2063,6 @@ declare abstract class AccountInterface extends ProviderInterface {
      * @param contractPayload transaction payload to be deployed containing:
     - contract: compiled contract code
     - classHash: computed class hash of compiled contract
-    - signature
      * @param transactionsDetail Invocation Details containing:
     - optional nonce
     - optional version
@@ -2055,16 +2076,72 @@ declare abstract class AccountInterface extends ProviderInterface {
      *
      * @param deployContractPayload containing
      * - classHash: computed class hash of compiled contract
-     * - salt: address salt
-     * - unique: bool if true ensure unique salt
-     * - calldata: constructor calldata
-     * - additionalCalls - optional additional calls array to support multicall
+     * - constructorCalldata: constructor calldata
+     * - optional salt: address salt - default random
+     * - optional unique: bool if true ensure unique salt - default true
+     * - optional additionalCalls - optional additional calls array to support multi-call
      * @param transactionsDetail Invocation Details containing:
      *  - optional nonce
      *  - optional version
      *  - optional maxFee
+     * @returns Promise<InvokeFunctionResponse>
+     *  - transaction_hash
      */
     abstract deploy(deployContractPayload: UniversalDeployerContractPayload, transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
+    /**
+     * Simplify deploy simulating old DeployContract with same response + UDC specific response
+     *
+     * @param payload UniversalDeployerContractPayload
+     *  - classHash: computed class hash of compiled contract
+     *  - constructorCalldata: constructor calldata
+     *  - optional salt: address salt - default random
+     *  - optional unique: bool if true ensure unique salt - default true
+     *  - optional additionalCalls - optional additional calls array to support multi-call
+     * @param details InvocationsDetails
+     *  - optional nonce
+     *  - optional version
+     *  - optional maxFee
+     * @returns Promise<DeployContractUDCResponse>
+     *  - contract_address
+     *  - transaction_hash
+     *  - address
+     *  - deployer
+     *  - unique
+     *  - classHash
+     *  - calldata_len
+     *  - calldata
+     *  - salt
+     */
+    abstract deployContract(payload: UniversalDeployerContractPayload, details: InvocationsDetails): Promise<DeployContractUDCResponse>;
+    /**
+     * Declares and Deploy a given compiled contract (json) to starknet using UDC
+     *
+     * @param declareDeployerContractPayload containing
+     * - contract: compiled contract code
+     * - classHash: computed class hash of compiled contract
+     * - optional constructorCalldata: constructor calldata
+     * - optional salt: address salt - default random
+     * - optional unique: bool if true ensure unique salt - default true
+     * - optional additionalCalls: - optional additional calls array to support multicall
+     * @param details
+     * - optional nonce
+     * - optional version
+     * - optional maxFee
+     * @returns Promise<DeclareDeployContractResponse>
+     * - declare
+     *    - transaction_hash
+     * - deploy
+     *    - contract_address
+     *    - transaction_hash
+     *    - address
+     *    - deployer
+     *    - unique
+     *    - classHash
+     *    - calldata_len
+     *    - calldata
+     *    - salt
+     */
+    abstract declareDeploy(declareDeployerContractPayload: DeclareDeployContractPayload, details?: InvocationsDetails): Promise<DeclareDeployContractResponse>;
     /**
      * Deploy the account on Starknet
      *
@@ -2146,7 +2223,12 @@ declare class Account extends Provider implements AccountInterface {
     estimateDeployFee({ classHash, salt, unique, constructorCalldata, additionalCalls, }: UniversalDeployerContractPayload, transactionsDetail?: InvocationsDetails | undefined): 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, additionalCalls, }: UniversalDeployerContractPayload, transactionsDetail?: InvocationsDetails): Promise<InvokeFunctionResponse>;
+    deploy({ classHash, salt, unique, constructorCalldata, additionalCalls, }: UniversalDeployerContractPayload, invocationsDetails?: InvocationsDetails): Promise<InvokeFunctionResponse>;
+    deployContract(payload: UniversalDeployerContractPayload, details?: InvocationsDetails): Promise<DeployContractUDCResponse>;
+    declareDeploy({ classHash, contract, constructorCalldata }: DeclareDeployContractPayload, details?: InvocationsDetails): Promise<{
+        declare: any;
+        deploy: DeployContractUDCResponse;
+    }>;
     deployAccount({ classHash, constructorCalldata, addressSalt, contractAddress: providedContractAddress, }: DeployAccountContractPayload, transactionsDetail?: InvocationsDetails): Promise<DeployContractResponse>;
     signMessage(typedData: TypedData): Promise<Signature>;
     hashMessage(typedData: TypedData): Promise<string>;
@@ -2338,8 +2420,9 @@ declare class Contract implements ContractInterface {
 declare class ContractFactory {
     abi: Abi;
     compiledContract: CompiledContract;
-    providerOrAccount: ProviderInterface | AccountInterface;
-    constructor(compiledContract: CompiledContract, providerOrAccount?: ProviderInterface | AccountInterface, abi?: Abi);
+    classHash: string;
+    account: AccountInterface;
+    constructor(compiledContract: CompiledContract, classHash: string, account: AccountInterface, abi?: Abi);
     /**
      * Deploys contract and returns new instance of the Contract
      *
@@ -2347,13 +2430,14 @@ declare class ContractFactory {
      * @param addressSalt (optional) - Address Salt for deployment
      * @returns deployed Contract
      */
-    deploy(constructorCalldata?: RawCalldata, addressSalt?: string | undefined): Promise<Contract>;
+    deploy(constructorCalldata?: RawArgs, addressSalt?: string | undefined): Promise<Contract>;
     /**
      * Attaches to new Provider or Account
      *
-     * @param providerOrAccount - new Provider or Account to attach to
+     * @param account - new Provider or Account to attach to
+     * @returns ContractFactory
      */
-    connect(providerOrAccount: ProviderInterface | AccountInterface): ContractFactory;
+    connect(account: AccountInterface): ContractFactory;
     /**
      * Attaches current abi and provider or account to the new address
      *
@@ -2648,4 +2732,4 @@ declare function validateChecksumAddress(address: string): boolean;
 declare function isUrl(s?: string): boolean;
 declare function buildUrl(baseUrl: string, defaultPath: string, urlOrPath?: string): string;
 
-export { Abi, AbiEntry, Account, AccountInterface, AllowArray, Args, AsyncContractFunction, BlockNumber, BlockTag, Call, CallContractResponse, CallDetails, CallL1Handler, Calldata, CommonTransactionReceiptResponse, CommonTransactionResponse, CompiledContract, CompressedCompiledContract, CompressedProgram, Contract, ContractClass, ContractEntryPoint, ContractFactory, ContractFunction, ContractInterface, DeclareContractPayload, DeclareContractResponse, DeclareContractTransaction, DeclareSignerDetails, DeclareTransactionReceiptResponse, DeclareTransactionResponse, DeployAccountContractPayload, DeployAccountContractTransaction, DeployAccountSignerDetails, DeployContractPayload, DeployContractResponse, EntryPointType, EntryPointsByType, EstimateFee, EstimateFeeAction, EstimateFeeDetails, EstimateFeeResponse, Event, ExecutionResources, FunctionAbi, FunctionInvocation, GatewayError, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionReceiptResponse, GetTransactionResponse, GetTransactionStatusResponse, GetTransactionTraceResponse, HttpError, Invocation, InvocationsDetails, InvocationsDetailsWithNonce, InvocationsSignerDetails, InvokeFunctionResponse, InvokeTransactionReceiptResponse, InvokeTransactionResponse, KeyPair, MessageToL1, MessageToL2, Overrides, ParsedStruct, Program, Provider, ProviderInterface, ProviderOptions, RPC, RawArgs, RawCalldata, Result, RpcProvider, RpcProviderOptions, Sequencer, SequencerProvider, SequencerProviderOptions, Signature, Signer, SignerInterface, Status, Struct, StructAbi, TransactionStatus, TransactionType, UniversalDeployerContractPayload, addAddressPadding, buildUrl, constants, defaultProvider, ellipticCurve as ec, encode, getChecksumAddress, hash, isUrl, json, merkle, number, shortString, stark, transaction, index as typedData, uint256, validateAndParseAddress, validateChecksumAddress };
+export { Abi, AbiEntry, Account, AccountInterface, AllowArray, Args, AsyncContractFunction, BlockNumber, BlockTag, Call, CallContractResponse, CallDetails, CallL1Handler, Calldata, CommonTransactionReceiptResponse, CommonTransactionResponse, CompiledContract, CompressedCompiledContract, CompressedProgram, Contract, ContractClass, ContractEntryPoint, ContractFactory, ContractFunction, ContractInterface, DeclareContractPayload, DeclareContractResponse, DeclareContractTransaction, DeclareDeployContractPayload, DeclareDeployContractResponse, DeclareSignerDetails, DeclareTransactionReceiptResponse, DeclareTransactionResponse, DeployAccountContractPayload, DeployAccountContractTransaction, DeployAccountSignerDetails, DeployContractPayload, DeployContractResponse, DeployContractUDCResponse, EntryPointType, EntryPointsByType, EstimateFee, EstimateFeeAction, EstimateFeeDetails, EstimateFeeResponse, Event, ExecutionResources, FunctionAbi, FunctionInvocation, GatewayError, GetBlockResponse, GetCodeResponse, GetContractAddressesResponse, GetTransactionReceiptResponse, GetTransactionResponse, GetTransactionStatusResponse, GetTransactionTraceResponse, HttpError, Invocation, InvocationsDetails, InvocationsDetailsWithNonce, InvocationsSignerDetails, InvokeFunctionResponse, InvokeTransactionReceiptResponse, InvokeTransactionResponse, KeyPair, MessageToL1, MessageToL2, Overrides, ParsedStruct, Program, Provider, ProviderInterface, ProviderOptions, RPC, RawArgs, RawCalldata, Result, RpcProvider, RpcProviderOptions, Sequencer, SequencerProvider, SequencerProviderOptions, Signature, Signer, SignerInterface, Status, Struct, StructAbi, TransactionStatus, TransactionType, UniversalDeployerContractPayload, addAddressPadding, buildUrl, constants, defaultProvider, ellipticCurve as ec, encode, getChecksumAddress, hash, isUrl, json, merkle, number, shortString, stark, transaction, index as typedData, uint256, validateAndParseAddress, validateChecksumAddress };