starknet 4.6.0 → 4.8.0

package/__tests__/account.test.ts

@@ -76,11 +76,8 @@ describe('deploy and test Wallet', () => {
   });
 
   test('execute with custom nonce', async () => {
-    const { result } = await account.callContract({
-      contractAddress: account.address,
-      entrypoint: 'get_nonce',
-    });
-    const nonce = toBN(result[0]).toNumber();
+    const result = await account.getNonce();
+    const nonce = toBN(result).toNumber();
     const { transaction_hash } = await account.execute(
       {
         contractAddress: erc20Address,

package/__tests__/contract.test.ts

@@ -43,7 +43,6 @@ describe('class Contract {}', () => {
       expect(res).toHaveProperty('contractAddress');
       expect(res).toHaveProperty('entrypoint');
       expect(res).toHaveProperty('calldata');
-      expect(res).toHaveProperty('signature');
     });
 
     test('estimate gas fee for `mint` should fail when connected to the provider', async () => {

package/__tests__/defaultProvider.test.ts

@@ -62,6 +62,11 @@ describe('defaultProvider', () => {
       return expect(block).toHaveProperty('block_number');
     });
 
+    test('getNonce()', async () => {
+      const nonce = await testProvider.getNonce(exampleContractAddress);
+      return expect(nonce).toEqual('0x0');
+    });
+
     describe('getStorageAt', () => {
       test('with "key" type of number', () => {
         return expect(testProvider.getStorageAt(exampleContractAddress, 0)).resolves.not.toThrow();
@@ -216,7 +221,6 @@ describe('defaultProvider', () => {
           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();
         });
@@ -241,9 +245,7 @@ describe('defaultProvider', () => {
 
           expect(receipt).toHaveProperty('transaction_hash');
           expect(receipt).toHaveProperty('status');
-          expect(receipt).toHaveProperty('status_data');
           expect(receipt).toHaveProperty('messages_sent');
-          expect(receipt).toHaveProperty('l1_origin_message');
           expect(receipt).toHaveProperty('events');
         });
       });

package/__tests__/fixtures.ts

@@ -8,6 +8,7 @@ const readContract = (name: string): CompiledContract =>
 
 export const compiledOpenZeppelinAccount = readContract('Account');
 export const compiledErc20 = readContract('ERC20');
+export const compiledL1L2 = readContract('l1l2_compiled');
 export const compiledTypeTransformation = readContract('contract');
 export const compiledMulticall = readContract('multicall');
 export const compiledTestDapp = readContract('TestDapp');
@@ -26,6 +27,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_DEVNET = IS_SEQUENCER ? IS_SEQUENCER_DEVNET : IS_RPC_DEVNET;
 
 export const getTestProvider = () => {

package/__tests__/sequencerProvider.test.ts

@@ -1,7 +1,9 @@
 import { Contract, Provider, SequencerProvider, stark } from '../src';
 import { toBN } from '../src/utils/number';
 import {
+  IS_SEQUENCER_GOERLI,
   compiledErc20,
+  compiledL1L2,
   describeIfNotDevnet,
   describeIfSequencer,
   getTestProvider,
@@ -9,12 +11,12 @@ import {
 
 // Run only if Devnet Sequencer
 describeIfSequencer('SequencerProvider', () => {
-  let provider: SequencerProvider;
+  let sequencerProvider: SequencerProvider;
   let customSequencerProvider: Provider;
   let exampleContractAddress: string;
 
   beforeAll(async () => {
-    provider = getTestProvider() as SequencerProvider;
+    sequencerProvider = getTestProvider() as SequencerProvider;
     customSequencerProvider = new Provider({
       sequencer: {
         baseUrl: 'https://alpha4.starknet.io',
@@ -28,32 +30,34 @@ describeIfSequencer('SequencerProvider', () => {
     let exampleTransactionHash: string;
 
     beforeAll(async () => {
-      const { transaction_hash, contract_address } = await provider.deployContract({
+      const { transaction_hash, contract_address } = await sequencerProvider.deployContract({
         contract: compiledErc20,
       });
-      await provider.waitForTransaction(transaction_hash);
+      await sequencerProvider.waitForTransaction(transaction_hash);
       exampleTransactionHash = transaction_hash;
       exampleContractAddress = contract_address;
     });
 
     test('getTransactionStatus()', async () => {
-      return expect(provider.getTransactionStatus(exampleTransactionHash)).resolves.not.toThrow();
+      return expect(
+        sequencerProvider.getTransactionStatus(exampleTransactionHash)
+      ).resolves.not.toThrow();
     });
 
     test('transaction trace', async () => {
-      const transactionTrace = await provider.getTransactionTrace(exampleTransactionHash);
-      expect(transactionTrace).toHaveProperty('function_invocation');
+      const transactionTrace = await sequencerProvider.getTransactionTrace(exampleTransactionHash);
+      // TODO test optional properties
       expect(transactionTrace).toHaveProperty('signature');
     });
 
     test('getCode() -> { bytecode }', async () => {
-      const code = await provider.getCode(exampleContractAddress);
+      const code = await sequencerProvider.getCode(exampleContractAddress);
       return expect(Array.isArray(code.bytecode)).toBe(true);
     });
 
     describeIfNotDevnet('which are not available on devnet', () => {
       test('getContractAddresses()', async () => {
-        const { GpsStatementVerifier, Starknet } = await provider.getContractAddresses();
+        const { GpsStatementVerifier, Starknet } = await sequencerProvider.getContractAddresses();
         expect(typeof GpsStatementVerifier).toBe('string');
         expect(typeof Starknet).toBe('string');
       });
@@ -80,4 +84,41 @@ describeIfSequencer('SequencerProvider', () => {
       expect(res).toStrictEqual(result.res);
     });
   });
+
+  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;
+      }
+    });
+
+    test('estimate message fee', async () => {
+      const estimation = await sequencerProvider.estimateMessageFee(
+        {
+          from_address: L1_ADDRESS,
+          to_address: l1l2ContractAddress,
+          entry_point_selector: 'deposit',
+          payload: ['556', '123'],
+        },
+        'latest'
+      );
+      expect(estimation).toEqual(
+        expect.objectContaining({
+          overall_fee: expect.anything(),
+          gas_price: expect.anything(),
+          gas_usage: expect.anything(),
+          unit: 'wei',
+        })
+      );
+    });
+  });
 });

package/__tests__/utils/ellipticalCurve.test.ts

@@ -2,9 +2,8 @@ import { StarknetChainId } from '../../src/constants';
 import { ec, getKeyPair, getStarkKey, sign, verify } from '../../src/utils/ellipticCurve';
 import { removeHexPrefix } from '../../src/utils/encode';
 import {
-  calculcateTransactionHash,
+  calculateTransactionHash,
   computeHashOnElements,
-  getSelectorFromName,
   pedersen,
   transactionVersion,
 } from '../../src/utils/hash';
@@ -57,25 +56,25 @@ test('hashMessage()', () => {
   const maxFee = '0';
   const calldata = fromCallsToExecuteCalldataWithNonce(transactions, nonce);
 
-  const hashMsg = calculcateTransactionHash(
+  const hashMsg = calculateTransactionHash(
     account,
     transactionVersion,
-    getSelectorFromName('__execute__'),
     calldata,
     maxFee,
-    StarknetChainId.TESTNET
+    StarknetChainId.TESTNET,
+    nonce
   );
 
   expect(hashMsg).toMatchInlineSnapshot(
-    `"0x4c337c6bf32b2cf2b8ae54064e4b982c214660e8d0423b431a3fde10b9b9c02"`
+    `"0x6d1706bd3d1ba7c517be2a2a335996f63d4738e2f182144d078a1dd9997062e"`
   );
   const keyPair = getKeyPair(privateKey);
   const [r, s] = sign(keyPair, removeHexPrefix(hashMsg));
   expect(r.toString()).toMatchInlineSnapshot(
-    `"1944132633844378384908742523072599391732300777648030785844673145513474741467"`
+    `"1427981024487605678086498726488552139932400435436186597196374630267616399345"`
   );
   expect(s.toString()).toMatchInlineSnapshot(
-    `"1067771353159635307522498807851959257107695451405842425488451092336556917559"`
+    `"1853664302719670721837677288395394946745467311923401353018029119631574115563"`
   );
 });
 

package/__tests__/utils/merkle.test.ts

@@ -1,6 +1,21 @@
+import { pedersen } from '../../src/utils/hash';
 import { MerkleTree, proofMerklePath } from '../../src/utils/merkle';
+import { toBN } from '../../src/utils/number';
 
 describe('MerkleTree class', () => {
+  describe('calculate hashes', () => {
+    test('should generate hash with sorted arguments', async () => {
+      let leaves = ['0x12', '0xa']; // 18, 10
+      let merkleHash = MerkleTree.hash(leaves[0], leaves[1]);
+      let rawHash = pedersen([toBN(leaves[1]), toBN(leaves[0])]);
+      expect(merkleHash).toBe(rawHash);
+
+      leaves = ['0x5bb9440e27889a364bcb678b1f679ecd1347acdedcbf36e83494f857cc58026', '0x3'];
+      merkleHash = MerkleTree.hash(leaves[0], leaves[1]);
+      rawHash = pedersen([toBN(leaves[1]), toBN(leaves[0])]);
+      expect(merkleHash).toBe(rawHash);
+    });
+  });
   describe('generate roots', () => {
     test('should generate valid root for 1 elements', async () => {
       const leaves = ['0x1'];

package/account/default.d.ts

@@ -1,5 +1,6 @@
 import { ProviderInterface, ProviderOptions } from '../provider';
 import { Provider } from '../provider/default';
+import { BlockIdentifier } from '../provider/utils';
 import { SignerInterface } from '../signer';
 import { Abi, Call, InvocationsDetails, InvokeFunctionResponse, KeyPair, Signature } from '../types';
 import { EstimateFee, EstimateFeeDetails } from '../types/account';
@@ -7,10 +8,10 @@ import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData';
 import { AccountInterface } from './interface';
 export declare class Account extends Provider implements AccountInterface {
-    address: string;
     signer: SignerInterface;
+    address: string;
     constructor(providerOrOptions: ProviderOptions | ProviderInterface, address: string, keyPairOrSigner: KeyPair | SignerInterface);
-    getNonce(): Promise<string>;
+    getNonce(blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     estimateFee(calls: Call | Call[], { nonce: providedNonce, blockIdentifier }?: EstimateFeeDetails): Promise<EstimateFee>;
     /**
      * Invoke execute function in account contract

package/account/default.js

@@ -75,62 +75,54 @@ var Account = /** @class */ (function (_super) {
     __extends(Account, _super);
     function Account(providerOrOptions, address, keyPairOrSigner) {
         var _this = _super.call(this, providerOrOptions) || this;
-        _this.address = address;
+        _this.address = address.toLowerCase();
         _this.signer =
             'getPubKey' in keyPairOrSigner ? keyPairOrSigner : new signer_1.Signer(keyPairOrSigner);
         return _this;
     }
-    Account.prototype.getNonce = function () {
+    Account.prototype.getNonce = function (blockIdentifier) {
         return __awaiter(this, void 0, void 0, function () {
-            var result;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.callContract({
-                            contractAddress: this.address,
-                            entrypoint: 'get_nonce',
-                        })];
-                    case 1:
-                        result = (_a.sent()).result;
-                        return [2 /*return*/, (0, number_1.toHex)((0, number_1.toBN)(result[0]))];
-                }
+                return [2 /*return*/, _super.prototype.getNonce.call(this, this.address, blockIdentifier)];
             });
         });
     };
     Account.prototype.estimateFee = function (calls, _a) {
         var _b = _a === void 0 ? {} : _a, providedNonce = _b.nonce, blockIdentifier = _b.blockIdentifier;
         return __awaiter(this, void 0, void 0, function () {
-            var transactions, nonce, _c, version, chainId, signerDetails, signature, calldata, response, suggestedMaxFee;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var transactions, nonce, _c, _d, version, chainId, signerDetails, signature, calldata, response, suggestedMaxFee;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
                         transactions = Array.isArray(calls) ? calls : [calls];
+                        _c = number_1.toBN;
                         if (!(providedNonce !== null && providedNonce !== void 0)) return [3 /*break*/, 1];
-                        _c = providedNonce;
+                        _d = providedNonce;
                         return [3 /*break*/, 3];
                     case 1: return [4 /*yield*/, this.getNonce()];
                     case 2:
-                        _c = (_d.sent());
-                        _d.label = 3;
+                        _d = (_e.sent());
+                        _e.label = 3;
                     case 3:
-                        nonce = _c;
-                        version = (0, number_1.toBN)(hash_1.feeTransactionVersion);
+                        nonce = _c.apply(void 0, [_d]);
+                        version = (0, number_1.toBN)(hash_1.transactionVersion);
                         return [4 /*yield*/, this.getChainId()];
                     case 4:
-                        chainId = _d.sent();
+                        chainId = _e.sent();
                         signerDetails = {
                             walletAddress: this.address,
-                            nonce: (0, number_1.toBN)(nonce),
+                            nonce: nonce,
                             maxFee: constants_1.ZERO,
                             version: version,
                             chainId: chainId,
                         };
                         return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails)];
                     case 5:
-                        signature = _d.sent();
-                        calldata = (0, transaction_1.fromCallsToExecuteCalldataWithNonce)(transactions, nonce);
-                        return [4 /*yield*/, _super.prototype.getEstimateFee.call(this, { contractAddress: this.address, entrypoint: '__execute__', calldata: calldata, signature: signature }, blockIdentifier, { version: version })];
+                        signature = _e.sent();
+                        calldata = (0, transaction_1.fromCallsToExecuteCalldata)(transactions);
+                        return [4 /*yield*/, _super.prototype.getEstimateFee.call(this, { contractAddress: this.address, calldata: calldata, signature: signature }, { version: version, nonce: nonce }, blockIdentifier)];
                     case 6:
-                        response = _d.sent();
+                        response = _e.sent();
                         suggestedMaxFee = (0, stark_1.estimatedFeeToMaxFee)(response.overall_fee);
                         return [2 /*return*/, __assign(__assign({}, response), { suggestedMaxFee: suggestedMaxFee })];
                 }
@@ -191,8 +183,9 @@ var Account = /** @class */ (function (_super) {
                         return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails, abis)];
                     case 8:
                         signature = _d.sent();
-                        calldata = (0, transaction_1.fromCallsToExecuteCalldataWithNonce)(transactions, nonce);
-                        return [2 /*return*/, this.invokeFunction({ contractAddress: this.address, entrypoint: '__execute__', calldata: calldata, signature: signature }, {
+                        calldata = (0, transaction_1.fromCallsToExecuteCalldata)(transactions);
+                        return [2 /*return*/, this.invokeFunction({ contractAddress: this.address, calldata: calldata, signature: signature }, {
+                                nonce: nonce,
                                 maxFee: maxFee,
                                 version: version,
                             })];
@@ -246,7 +239,7 @@ var Account = /** @class */ (function (_super) {
                         _b.trys.push([0, 2, , 3]);
                         return [4 /*yield*/, this.callContract({
                                 contractAddress: this.address,
-                                entrypoint: 'is_valid_signature',
+                                entrypoint: 'isValidSignature',
                                 calldata: (0, stark_1.compileCalldata)({
                                     hash: (0, number_1.toBN)(hash).toString(),
                                     signature: signature.map(function (x) { return (0, number_1.toBN)(x).toString(); }),

package/account/interface.d.ts

@@ -1,4 +1,5 @@
 import { ProviderInterface } from '../provider';
+import { BlockIdentifier } from '../provider/utils';
 import { SignerInterface } from '../signer';
 import { Abi, Call, EstimateFeeDetails, EstimateFeeResponse, InvocationsDetails, InvokeFunctionResponse, Signature } from '../types';
 import { BigNumberish } from '../utils/number';
@@ -68,5 +69,5 @@ export declare abstract class AccountInterface extends ProviderInterface {
      * @throws {Error} if the signature is not a valid signature
      */
     abstract verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
-    abstract getNonce(): Promise<string>;
+    abstract getNonce(blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
 }

package/contract/contractFactory.d.ts

@@ -1,7 +1,6 @@
 import { AccountInterface } from '../account';
 import { ProviderInterface } from '../provider';
 import { Abi, CompiledContract, RawCalldata } from '../types';
-import { BigNumberish } from '../utils/number';
 import { Contract } from './default';
 export declare class ContractFactory {
     abi: Abi;
@@ -15,7 +14,7 @@ export declare class ContractFactory {
      * @param addressSalt (optional) - Address Salt for deployment
      * @returns deployed Contract
      */
-    deploy(constructorCalldata?: RawCalldata, addressSalt?: BigNumberish): Promise<Contract>;
+    deploy(constructorCalldata?: RawCalldata, addressSalt?: string | undefined): Promise<Contract>;
     /**
      * Attaches to new Provider or Account
      *

package/contract/default.d.ts

@@ -1,7 +1,7 @@
 import { AccountInterface } from '../account';
 import { ProviderInterface } from '../provider';
 import { BlockIdentifier } from '../provider/utils';
-import { Abi, AbiEntry, Args, AsyncContractFunction, Calldata, ContractFunction, Invocation, InvokeFunctionResponse, Overrides, ParsedStruct, Result, StructAbi } from '../types';
+import { Abi, AbiEntry, Args, AsyncContractFunction, Call, Calldata, ContractFunction, InvokeFunctionResponse, Overrides, ParsedStruct, Result, StructAbi } from '../types';
 import { BigNumberish } from '../utils/number';
 import { ContractInterface } from './interface';
 export declare class Contract implements ContractInterface {
@@ -120,5 +120,5 @@ export declare class Contract implements ContractInterface {
         blockIdentifier?: BlockIdentifier;
     }): Promise<Result>;
     estimate(method: string, args?: Array<any>): Promise<import("../types").EstimateFeeResponse>;
-    populate(method: string, args?: Array<any>): Invocation;
+    populate(method: string, args?: Array<any>): Call;
 }

package/contract/default.js

@@ -181,7 +181,7 @@ var Contract = /** @class */ (function () {
     function Contract(abi, address, providerOrAccount) {
         if (providerOrAccount === void 0) { providerOrAccount = provider_1.defaultProvider; }
         var _this = this;
-        this.address = address;
+        this.address = address.toLowerCase();
         this.providerOrAccount = providerOrAccount;
         this.abi = abi;
         this.structs = abi
@@ -592,9 +592,14 @@ var Contract = /** @class */ (function () {
                 nonce: options.nonce,
             });
         }
+        if (!options.nonce) {
+            throw new Error("Nonce is required when invoking a function without an account");
+        }
         // eslint-disable-next-line no-console
         console.warn("Invoking ".concat(method, " without an account. This will not work on a public node."));
-        return this.providerOrAccount.invokeFunction(__assign(__assign({}, invocation), { signature: options.signature || [] }));
+        return this.providerOrAccount.invokeFunction(__assign(__assign({}, invocation), { signature: options.signature || [] }), {
+            nonce: options.nonce,
+        });
     };
     Contract.prototype.call = function (method, args, _a) {
         if (args === void 0) { args = []; }
@@ -644,7 +649,6 @@ var Contract = /** @class */ (function () {
             contractAddress: this.address,
             entrypoint: method,
             calldata: this.compileCalldata(args, inputs),
-            signature: [],
         };
     };
     return Contract;

package/dist/account/default.d.ts

@@ -1,5 +1,6 @@
 import { ProviderInterface, ProviderOptions } from '../provider';
 import { Provider } from '../provider/default';
+import { BlockIdentifier } from '../provider/utils';
 import { SignerInterface } from '../signer';
 import { Abi, Call, InvocationsDetails, InvokeFunctionResponse, KeyPair, Signature } from '../types';
 import { EstimateFee, EstimateFeeDetails } from '../types/account';
@@ -7,10 +8,10 @@ import { BigNumberish } from '../utils/number';
 import { TypedData } from '../utils/typedData';
 import { AccountInterface } from './interface';
 export declare class Account extends Provider implements AccountInterface {
-    address: string;
     signer: SignerInterface;
+    address: string;
     constructor(providerOrOptions: ProviderOptions | ProviderInterface, address: string, keyPairOrSigner: KeyPair | SignerInterface);
-    getNonce(): Promise<string>;
+    getNonce(blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     estimateFee(calls: Call | Call[], { nonce: providedNonce, blockIdentifier }?: EstimateFeeDetails): Promise<EstimateFee>;
     /**
      * Invoke execute function in account contract

package/dist/account/default.js

@@ -75,62 +75,54 @@ var Account = /** @class */ (function (_super) {
     __extends(Account, _super);
     function Account(providerOrOptions, address, keyPairOrSigner) {
         var _this = _super.call(this, providerOrOptions) || this;
-        _this.address = address;
+        _this.address = address.toLowerCase();
         _this.signer =
             'getPubKey' in keyPairOrSigner ? keyPairOrSigner : new signer_1.Signer(keyPairOrSigner);
         return _this;
     }
-    Account.prototype.getNonce = function () {
+    Account.prototype.getNonce = function (blockIdentifier) {
         return __awaiter(this, void 0, void 0, function () {
-            var result;
             return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.callContract({
-                            contractAddress: this.address,
-                            entrypoint: 'get_nonce',
-                        })];
-                    case 1:
-                        result = (_a.sent()).result;
-                        return [2 /*return*/, (0, number_1.toHex)((0, number_1.toBN)(result[0]))];
-                }
+                return [2 /*return*/, _super.prototype.getNonce.call(this, this.address, blockIdentifier)];
             });
         });
     };
     Account.prototype.estimateFee = function (calls, _a) {
         var _b = _a === void 0 ? {} : _a, providedNonce = _b.nonce, blockIdentifier = _b.blockIdentifier;
         return __awaiter(this, void 0, void 0, function () {
-            var transactions, nonce, _c, version, chainId, signerDetails, signature, calldata, response, suggestedMaxFee;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
+            var transactions, nonce, _c, _d, version, chainId, signerDetails, signature, calldata, response, suggestedMaxFee;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
                     case 0:
                         transactions = Array.isArray(calls) ? calls : [calls];
+                        _c = number_1.toBN;
                         if (!(providedNonce !== null && providedNonce !== void 0)) return [3 /*break*/, 1];
-                        _c = providedNonce;
+                        _d = providedNonce;
                         return [3 /*break*/, 3];
                     case 1: return [4 /*yield*/, this.getNonce()];
                     case 2:
-                        _c = (_d.sent());
-                        _d.label = 3;
+                        _d = (_e.sent());
+                        _e.label = 3;
                     case 3:
-                        nonce = _c;
-                        version = (0, number_1.toBN)(hash_1.feeTransactionVersion);
+                        nonce = _c.apply(void 0, [_d]);
+                        version = (0, number_1.toBN)(hash_1.transactionVersion);
                         return [4 /*yield*/, this.getChainId()];
                     case 4:
-                        chainId = _d.sent();
+                        chainId = _e.sent();
                         signerDetails = {
                             walletAddress: this.address,
-                            nonce: (0, number_1.toBN)(nonce),
+                            nonce: nonce,
                             maxFee: constants_1.ZERO,
                             version: version,
                             chainId: chainId,
                         };
                         return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails)];
                     case 5:
-                        signature = _d.sent();
-                        calldata = (0, transaction_1.fromCallsToExecuteCalldataWithNonce)(transactions, nonce);
-                        return [4 /*yield*/, _super.prototype.getEstimateFee.call(this, { contractAddress: this.address, entrypoint: '__execute__', calldata: calldata, signature: signature }, blockIdentifier, { version: version })];
+                        signature = _e.sent();
+                        calldata = (0, transaction_1.fromCallsToExecuteCalldata)(transactions);
+                        return [4 /*yield*/, _super.prototype.getEstimateFee.call(this, { contractAddress: this.address, calldata: calldata, signature: signature }, { version: version, nonce: nonce }, blockIdentifier)];
                     case 6:
-                        response = _d.sent();
+                        response = _e.sent();
                         suggestedMaxFee = (0, stark_1.estimatedFeeToMaxFee)(response.overall_fee);
                         return [2 /*return*/, __assign(__assign({}, response), { suggestedMaxFee: suggestedMaxFee })];
                 }
@@ -191,8 +183,9 @@ var Account = /** @class */ (function (_super) {
                         return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails, abis)];
                     case 8:
                         signature = _d.sent();
-                        calldata = (0, transaction_1.fromCallsToExecuteCalldataWithNonce)(transactions, nonce);
-                        return [2 /*return*/, this.invokeFunction({ contractAddress: this.address, entrypoint: '__execute__', calldata: calldata, signature: signature }, {
+                        calldata = (0, transaction_1.fromCallsToExecuteCalldata)(transactions);
+                        return [2 /*return*/, this.invokeFunction({ contractAddress: this.address, calldata: calldata, signature: signature }, {
+                                nonce: nonce,
                                 maxFee: maxFee,
                                 version: version,
                             })];
@@ -246,7 +239,7 @@ var Account = /** @class */ (function (_super) {
                         _b.trys.push([0, 2, , 3]);
                         return [4 /*yield*/, this.callContract({
                                 contractAddress: this.address,
-                                entrypoint: 'is_valid_signature',
+                                entrypoint: 'isValidSignature',
                                 calldata: (0, stark_1.compileCalldata)({
                                     hash: (0, number_1.toBN)(hash).toString(),
                                     signature: signature.map(function (x) { return (0, number_1.toBN)(x).toString(); }),

package/dist/account/interface.d.ts

@@ -1,4 +1,5 @@
 import { ProviderInterface } from '../provider';
+import { BlockIdentifier } from '../provider/utils';
 import { SignerInterface } from '../signer';
 import { Abi, Call, EstimateFeeDetails, EstimateFeeResponse, InvocationsDetails, InvokeFunctionResponse, Signature } from '../types';
 import { BigNumberish } from '../utils/number';
@@ -68,5 +69,5 @@ export declare abstract class AccountInterface extends ProviderInterface {
      * @throws {Error} if the signature is not a valid signature
      */
     abstract verifyMessageHash(hash: BigNumberish, signature: Signature): Promise<boolean>;
-    abstract getNonce(): Promise<string>;
+    abstract getNonce(blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
 }

package/dist/contract/contractFactory.d.ts

@@ -1,7 +1,6 @@
 import { AccountInterface } from '../account';
 import { ProviderInterface } from '../provider';
 import { Abi, CompiledContract, RawCalldata } from '../types';
-import { BigNumberish } from '../utils/number';
 import { Contract } from './default';
 export declare class ContractFactory {
     abi: Abi;
@@ -15,7 +14,7 @@ export declare class ContractFactory {
      * @param addressSalt (optional) - Address Salt for deployment
      * @returns deployed Contract
      */
-    deploy(constructorCalldata?: RawCalldata, addressSalt?: BigNumberish): Promise<Contract>;
+    deploy(constructorCalldata?: RawCalldata, addressSalt?: string | undefined): Promise<Contract>;
     /**
      * Attaches to new Provider or Account
      *

package/dist/contract/default.d.ts

@@ -1,7 +1,7 @@
 import { AccountInterface } from '../account';
 import { ProviderInterface } from '../provider';
 import { BlockIdentifier } from '../provider/utils';
-import { Abi, AbiEntry, Args, AsyncContractFunction, Calldata, ContractFunction, Invocation, InvokeFunctionResponse, Overrides, ParsedStruct, Result, StructAbi } from '../types';
+import { Abi, AbiEntry, Args, AsyncContractFunction, Call, Calldata, ContractFunction, InvokeFunctionResponse, Overrides, ParsedStruct, Result, StructAbi } from '../types';
 import { BigNumberish } from '../utils/number';
 import { ContractInterface } from './interface';
 export declare class Contract implements ContractInterface {
@@ -120,5 +120,5 @@ export declare class Contract implements ContractInterface {
         blockIdentifier?: BlockIdentifier;
     }): Promise<Result>;
     estimate(method: string, args?: Array<any>): Promise<import("../types").EstimateFeeResponse>;
-    populate(method: string, args?: Array<any>): Invocation;
+    populate(method: string, args?: Array<any>): Call;
 }