starknet 4.5.0 → 4.7.0

package/CHANGELOG.md

@@ -1,3 +1,43 @@
+# [4.7.0](https://github.com/0xs34n/starknet.js/compare/v4.6.0...v4.7.0) (2022-09-22)
+
+### Bug Fixes
+
+- add blockIdentifier for getNonce ([7f2edab](https://github.com/0xs34n/starknet.js/commit/7f2edab5099eb9679744140bfe80328801a621ab))
+- addressSalt from BigNumberish to string | undefined ([f77784c](https://github.com/0xs34n/starknet.js/commit/f77784c98d1827a8fd64dd1c543beea4284af7b3))
+- block_id identifier cleanup ([24c24e8](https://github.com/0xs34n/starknet.js/commit/24c24e8060b76f6a300b21c3148a15183b802fcb))
+- **ci:** use correct devnet image for release pipeline ([fc2fcbb](https://github.com/0xs34n/starknet.js/commit/fc2fcbb57e48b4cec9197c59120a574b018a54af))
+- cleanup pr.yml ([263e296](https://github.com/0xs34n/starknet.js/commit/263e29658c30e2c80fe1795f89d4c334777fef5e))
+- fix tests for starknet 0.10 ([c2da26d](https://github.com/0xs34n/starknet.js/commit/c2da26d4b92221fdd54fdd8ff37c437529616b21))
+- get_nonce response type ([f0c30bd](https://github.com/0xs34n/starknet.js/commit/f0c30bd4376eb7c70098d77ff2918ea80418a8af))
+- throw error only when nonce is not provided with contract.invoke ([c6bba65](https://github.com/0xs34n/starknet.js/commit/c6bba6517054b5221f227732750092d0c11b566d))
+- ts types fixes and block_id ([bad0b85](https://github.com/0xs34n/starknet.js/commit/bad0b851765b9af70af3a784aeb1ae5adbe29816))
+
+### Features
+
+- add getNonce method on account ([8e935eb](https://github.com/0xs34n/starknet.js/commit/8e935ebaa251279b83fab65397687ef0380358ac))
+- getNonce endpoint for sequencer ([add4900](https://github.com/0xs34n/starknet.js/commit/add4900ad86f40390b68f6f2158cfbb588fe21d6))
+- is_valid_signature -> isValidSignature ([f704f3e](https://github.com/0xs34n/starknet.js/commit/f704f3e9a3aec0744c155fc3bded079fac7284b5))
+- rpc options, methods, fetch with prop types, imp. types, clenup responseParser ([0ab5769](https://github.com/0xs34n/starknet.js/commit/0ab576957b3e193a68ae6f3ceb15d0b042d39b14))
+- rpc optionsOrProvider extend with retries ([46f9634](https://github.com/0xs34n/starknet.js/commit/46f96342be05252de306fba28da74e634e8b9c3f))
+- transaction v1 changes ([e928478](https://github.com/0xs34n/starknet.js/commit/e92847848166170c7d63394993cd74ae79c14a67))
+- update tests ([1af16f4](https://github.com/0xs34n/starknet.js/commit/1af16f475813a15c78d3b049b7453c19023fe53a))
+- use starknet-devnet 0.3.1 ([83e5dd7](https://github.com/0xs34n/starknet.js/commit/83e5dd7f3bfc5d8d492b3761da6e9fe15669d03c))
+
+# [4.6.0](https://github.com/0xs34n/starknet.js/compare/v4.5.0...v4.6.0) (2022-09-15)
+
+### Bug Fixes
+
+- add test getTransactionCount [skip ci] ([342755a](https://github.com/0xs34n/starknet.js/commit/342755aa99dda016d7aa394a0023b3f2e5d5e963))
+- estimateFee and call block id ([ef1645f](https://github.com/0xs34n/starknet.js/commit/ef1645f740e7c29edea6b091bec9949ec713953f))
+- rpc test update, comepleted rpc to openrpc mapping, rpc provider methods ([8b41e0f](https://github.com/0xs34n/starknet.js/commit/8b41e0fcf36b34b20dfaba356cfc0131f02d7d69))
+
+### Features
+
+- new Block utility object, rpc fetch clenup, open rpc fetch api ([0d381c8](https://github.com/0xs34n/starknet.js/commit/0d381c89fe655b2628f02e67095ef03cb1721398))
+- read, write and trace api ([d488ab2](https://github.com/0xs34n/starknet.js/commit/d488ab2513b88fdeb4e27b6ec2b7226ffd359445))
+- retry rpc wait for transaction 200 times instead of 100 ([3bc9118](https://github.com/0xs34n/starknet.js/commit/3bc9118cae86fba21e1c85667079079662ba0b7b))
+- updated rpc tests with new methods ([e369d95](https://github.com/0xs34n/starknet.js/commit/e369d95d72f3b39b3e8b8baa99867b94c1d5d1c1))
+
 # [4.5.0](https://github.com/0xs34n/starknet.js/compare/v4.4.2...v4.5.0) (2022-09-09)
 
 ### Bug Fixes

package/README.md

@@ -39,8 +39,10 @@
 Install starknet with `npm`
 
 ```bash
+# latest official release (main branch)
 $ npm install starknet
-# or for starknet.js v4:
+
+# or for latest pre-release version (develop branch):
 $ npm install starknet@next
 ```
 

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();
@@ -139,10 +144,11 @@ describe('defaultProvider', () => {
 
   describeIfNotDevnet('Provider', () => {
     const provider = getTestProvider();
+    let latestBlock;
     describe(`Provider methods if not devnet`, () => {
       describe('getBlock', () => {
-        test('pending', async () => {
-          const latestBlock = await provider.getBlock();
+        test('getBlock by tag pending', async () => {
+          latestBlock = await provider.getBlock();
           expect(latestBlock).toHaveProperty('block_hash');
           expect(latestBlock).toHaveProperty('parent_hash');
           expect(latestBlock).toHaveProperty('block_number');
@@ -153,11 +159,8 @@ describe('defaultProvider', () => {
           expect(Array.isArray(latestBlock.transactions)).toBe(true);
         });
 
-        test('Block Hash 0x8a30a1212d142cb0053fe9921e1dbf64f651d328565bd2e7ac24059c270f43', async () => {
-          const block = await provider.getBlock(
-            '0x8a30a1212d142cb0053fe9921e1dbf64f651d328565bd2e7ac24059c270f43'
-          );
-
+        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');
@@ -168,8 +171,8 @@ describe('defaultProvider', () => {
           expect(Array.isArray(block.transactions)).toBe(true);
         });
 
-        test('Block Number 102634', async () => {
-          const block = await provider.getBlock(102634);
+        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');
@@ -218,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();
         });
@@ -258,6 +260,10 @@ describe('defaultProvider', () => {
 
         beforeAll(async () => {
           deployResponse = await provider.deployContract({ contract: compiledErc20 });
+          console.log(
+            '🚀 ~ file: defaultProvider.test.ts ~ line 264 ~ beforeAll ~ deployResponse',
+            deployResponse
+          );
           contractAddress = deployResponse.contract_address;
           declareResponse = await provider.declareContract({ contract: compiledErc20 });
           await Promise.all([

package/__tests__/rpcProvider.test.ts

@@ -1,5 +1,6 @@
-import { Account, RpcProvider, ec } from '../src';
+import { Account, GetBlockResponse, RpcProvider, ec } from '../src';
 import {
+  compiledErc20,
   compiledOpenZeppelinAccount,
   describeIfRpc,
   getTestAccount,
@@ -20,21 +21,115 @@ describeIfRpc('RPCProvider', () => {
     accountPublicKey = ec.getStarkKey(accountKeyPair);
   });
 
+  test('getChainId', async () => {
+    const chainId = await rpcProvider.getChainId();
+    expect(chainId).toBe('0x534e5f474f45524c49');
+  });
+
+  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');
+  });
+
+  test('getBlockHashAndNumber', async () => {
+    const blockHashAndNumber = await rpcProvider.getBlockHashAndNumber();
+    expect(blockHashAndNumber).toHaveProperty('block_hash');
+    expect(blockHashAndNumber).toHaveProperty('block_number');
+  });
+
+  test('getStateUpdate', async () => {
+    const stateUpdate = await rpcProvider.getStateUpdate('latest');
+    expect(stateUpdate).toHaveProperty('block_hash');
+    expect(stateUpdate).toHaveProperty('new_root');
+    expect(stateUpdate).toHaveProperty('old_root');
+    expect(stateUpdate).toHaveProperty('state_diff');
+  });
+
+  xtest('getProtocolVersion', async () => {
+    await rpcProvider.getProtocolVersion();
+  });
+
   describe('RPC methods', () => {
-    test('getChainId', async () => {
-      const chainId = await rpcProvider.getChainId();
-      expect(chainId).toBe('0x534e5f474f45524c49');
+    let latestBlock: GetBlockResponse;
+
+    beforeAll(async () => {
+      latestBlock = await rpcProvider.getBlock('latest');
+    });
+
+    test('getBlockWithTxHashes', async () => {
+      const blockResponse = await rpcProvider.getBlockWithTxHashes(latestBlock.block_number);
+      expect(blockResponse).toHaveProperty('transactions');
+    });
+
+    test('getBlockWithTxs', async () => {
+      const blockResponse = await rpcProvider.getBlockWithTxs(latestBlock.block_number);
+      expect(blockResponse).toHaveProperty('transactions');
+    });
+
+    test('getTransactionByBlockIdAndIndex', async () => {
+      const transaction = await rpcProvider.getTransactionByBlockIdAndIndex(
+        latestBlock.block_number,
+        0
+      );
+      expect(transaction).toHaveProperty('transaction_hash');
+    });
+
+    xtest('traceBlockTransactions', async () => {
+      await rpcProvider.traceBlockTransactions(latestBlock.block_hash);
+    });
+
+    describe('deploy contract related tests', () => {
+      let contract_address;
+      let transaction_hash;
+
+      beforeAll(async () => {
+        ({ contract_address, transaction_hash } = await rpcProvider.deployContract({
+          contract: compiledOpenZeppelinAccount,
+          constructorCalldata: [accountPublicKey],
+          addressSalt: accountPublicKey,
+        }));
+        await rpcProvider.waitForTransaction(transaction_hash);
+      });
+
+      test('deployContract result', () => {
+        expect(contract_address).toBeTruthy();
+        expect(transaction_hash).toBeTruthy();
+      });
+
+      test('getTransactionByHash', async () => {
+        const transaction = await rpcProvider.getTransactionByHash(transaction_hash);
+        expect(transaction).toHaveProperty('transaction_hash');
+      });
+
+      test('getClassHashAt', async () => {
+        const classHash = await rpcProvider.getClassHashAt('latest', contract_address);
+        expect(typeof classHash).toBe('string');
+      });
+
+      xtest('traceTransaction', async () => {
+        await rpcProvider.traceTransaction(transaction_hash);
+      });
     });
 
-    test('deployContract', async () => {
-      const { contract_address, transaction_hash } = await rpcProvider.deployContract({
-        contract: compiledOpenZeppelinAccount,
-        constructorCalldata: [accountPublicKey],
-        addressSalt: accountPublicKey,
+    describe('declare contract related tests', () => {
+      let class_hash;
+
+      beforeAll(async () => {
+        ({ class_hash } = await rpcProvider.declareContract({
+          contract: compiledErc20,
+        }));
+      });
+
+      test('getClass', async () => {
+        const contractClass = await rpcProvider.getClass(class_hash);
+        expect(contractClass).toHaveProperty('program');
+        expect(contractClass).toHaveProperty('entry_points_by_type');
       });
-      await rpcProvider.waitForTransaction(transaction_hash);
-      expect(contract_address).toBeTruthy();
-      expect(transaction_hash).toBeTruthy();
     });
 
     test.todo('getEstimateFee');

package/__tests__/sequencerProvider.test.ts

@@ -9,12 +9,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 +28,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);
+      const transactionTrace = await sequencerProvider.getTransactionTrace(exampleTransactionHash);
       expect(transactionTrace).toHaveProperty('function_invocation');
       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');
       });

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/utils.test.ts

@@ -1,6 +1,7 @@
 import fs from 'fs';
 
 import { constants, hash, json, number, stark } from '../../src';
+import { Block } from '../../src/provider/utils';
 import { pedersen } from '../../src/utils/hash';
 
 const { IS_BROWSER } = constants;
@@ -112,3 +113,19 @@ describe('calculateContractAddressFromHash()', () => {
     );
   });
 });
+
+describe('new Block()', () => {
+  test('Block identifier and queryIdentifier', () => {
+    const blockA = new Block(0);
+    expect(blockA.identifier).toMatchObject({ block_number: 0 });
+    expect(blockA.queryIdentifier).toBe('blockNumber=0');
+
+    const blockB = new Block('latest');
+    expect(blockB.identifier).toBe('latest');
+    expect(blockB.queryIdentifier).toBe('blockNumber=latest');
+
+    const blockC = new Block('0x01');
+    expect(blockC.identifier).toMatchObject({ block_hash: '0x01' });
+    expect(blockC.queryIdentifier).toBe('blockHash=0x01');
+  });
+});

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