starknet 4.4.2 → 4.6.0

package/CHANGELOG.md

@@ -1,3 +1,29 @@
+# [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
+
+- prevent undefined rpc chainId in account ([9f69229](https://github.com/0xs34n/starknet.js/commit/9f69229fcb5205bb3fd1fcc7eb7c627faa300561))
+- repair chain fix ([d7758a6](https://github.com/0xs34n/starknet.js/commit/d7758a6d180cd1af89f8aefb37bce077b92c5fd5))
+
+### Features
+
+- optional abi field for deploy and declare rpc transactions ([ce62648](https://github.com/0xs34n/starknet.js/commit/ce626481cb6bc3dea77963482820ae6f50c82566))
+
 ## [4.4.2](https://github.com/0xs34n/starknet.js/compare/v4.4.1...v4.4.2) (2022-09-07)
 
 ### 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__/defaultProvider.test.ts

@@ -139,10 +139,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 +154,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 +166,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');

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__/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.js

@@ -99,7 +99,7 @@ var Account = /** @class */ (function (_super) {
     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, signerDetails, signature, calldata, response, suggestedMaxFee;
+            var transactions, nonce, _c, version, chainId, signerDetails, signature, calldata, response, suggestedMaxFee;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
@@ -114,19 +114,22 @@ var Account = /** @class */ (function (_super) {
                     case 3:
                         nonce = _c;
                         version = (0, number_1.toBN)(hash_1.feeTransactionVersion);
+                        return [4 /*yield*/, this.getChainId()];
+                    case 4:
+                        chainId = _d.sent();
                         signerDetails = {
                             walletAddress: this.address,
                             nonce: (0, number_1.toBN)(nonce),
                             maxFee: constants_1.ZERO,
                             version: version,
-                            chainId: this.chainId,
+                            chainId: chainId,
                         };
                         return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails)];
-                    case 4:
+                    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 })];
-                    case 5:
+                    case 6:
                         response = _d.sent();
                         suggestedMaxFee = (0, stark_1.estimatedFeeToMaxFee)(response.overall_fee);
                         return [2 /*return*/, __assign(__assign({}, response), { suggestedMaxFee: suggestedMaxFee })];
@@ -149,7 +152,7 @@ var Account = /** @class */ (function (_super) {
         if (abis === void 0) { abis = undefined; }
         if (transactionsDetail === void 0) { transactionsDetail = {}; }
         return __awaiter(this, void 0, void 0, function () {
-            var transactions, nonce, _b, _c, maxFee, suggestedMaxFee, version, signerDetails, signature, calldata;
+            var transactions, nonce, _b, _c, maxFee, suggestedMaxFee, version, chainId, signerDetails, signature, calldata;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
@@ -175,15 +178,18 @@ var Account = /** @class */ (function (_super) {
                         _d.label = 6;
                     case 6:
                         version = (0, number_1.toBN)(hash_1.transactionVersion);
+                        return [4 /*yield*/, this.getChainId()];
+                    case 7:
+                        chainId = _d.sent();
                         signerDetails = {
                             walletAddress: this.address,
                             nonce: nonce,
                             maxFee: maxFee,
                             version: version,
-                            chainId: this.chainId,
+                            chainId: chainId,
                         };
                         return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails, abis)];
-                    case 7:
+                    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 }, {

package/dist/account/default.js

@@ -99,7 +99,7 @@ var Account = /** @class */ (function (_super) {
     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, signerDetails, signature, calldata, response, suggestedMaxFee;
+            var transactions, nonce, _c, version, chainId, signerDetails, signature, calldata, response, suggestedMaxFee;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
@@ -114,19 +114,22 @@ var Account = /** @class */ (function (_super) {
                     case 3:
                         nonce = _c;
                         version = (0, number_1.toBN)(hash_1.feeTransactionVersion);
+                        return [4 /*yield*/, this.getChainId()];
+                    case 4:
+                        chainId = _d.sent();
                         signerDetails = {
                             walletAddress: this.address,
                             nonce: (0, number_1.toBN)(nonce),
                             maxFee: constants_1.ZERO,
                             version: version,
-                            chainId: this.chainId,
+                            chainId: chainId,
                         };
                         return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails)];
-                    case 4:
+                    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 })];
-                    case 5:
+                    case 6:
                         response = _d.sent();
                         suggestedMaxFee = (0, stark_1.estimatedFeeToMaxFee)(response.overall_fee);
                         return [2 /*return*/, __assign(__assign({}, response), { suggestedMaxFee: suggestedMaxFee })];
@@ -149,7 +152,7 @@ var Account = /** @class */ (function (_super) {
         if (abis === void 0) { abis = undefined; }
         if (transactionsDetail === void 0) { transactionsDetail = {}; }
         return __awaiter(this, void 0, void 0, function () {
-            var transactions, nonce, _b, _c, maxFee, suggestedMaxFee, version, signerDetails, signature, calldata;
+            var transactions, nonce, _b, _c, maxFee, suggestedMaxFee, version, chainId, signerDetails, signature, calldata;
             return __generator(this, function (_d) {
                 switch (_d.label) {
                     case 0:
@@ -175,15 +178,18 @@ var Account = /** @class */ (function (_super) {
                         _d.label = 6;
                     case 6:
                         version = (0, number_1.toBN)(hash_1.transactionVersion);
+                        return [4 /*yield*/, this.getChainId()];
+                    case 7:
+                        chainId = _d.sent();
                         signerDetails = {
                             walletAddress: this.address,
                             nonce: nonce,
                             maxFee: maxFee,
                             version: version,
-                            chainId: this.chainId,
+                            chainId: chainId,
                         };
                         return [4 /*yield*/, this.signer.signTransaction(transactions, signerDetails, abis)];
-                    case 7:
+                    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 }, {

package/dist/provider/default.d.ts

@@ -13,6 +13,7 @@ export declare class Provider implements ProviderInterface {
     private provider;
     constructor(providerOrOptions?: ProviderOptions | ProviderInterface);
     get chainId(): StarknetChainId;
+    getChainId(): Promise<StarknetChainId>;
     getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
     getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;
     getEstimateFee(invocation: Invocation, blockIdentifier?: BlockIdentifier, invocationDetails?: InvocationsDetails): Promise<EstimateFeeResponse>;

package/dist/provider/default.js

@@ -61,6 +61,13 @@ var Provider = /** @class */ (function () {
         enumerable: false,
         configurable: true
     });
+    Provider.prototype.getChainId = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.provider.getChainId()];
+            });
+        });
+    };
     Provider.prototype.getBlock = function (blockIdentifier) {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {

package/dist/provider/interface.d.ts

@@ -4,6 +4,12 @@ import type { BigNumberish } from '../utils/number';
 import { BlockIdentifier } from './utils';
 export declare abstract class ProviderInterface {
     abstract chainId: StarknetChainId;
+    /**
+     * Gets the Starknet chain Id
+     *
+     * @returns the chain Id
+     */
+    abstract getChainId(): Promise<StarknetChainId>;
     /**
      * Calls a function on the StarkNet contract.
      *

package/dist/provider/rpc.d.ts

@@ -12,24 +12,34 @@ export declare class RpcProvider implements ProviderInterface {
     chainId: StarknetChainId;
     private responseParser;
     constructor(optionsOrProvider: RpcProviderOptions);
+    fetch(method: any, params: any): Promise<any>;
+    protected errorHandler(error: any): void;
     protected fetchEndpoint<T extends keyof RPC.Methods>(method: T, request?: RPC.Methods[T]['REQUEST']): Promise<RPC.Methods[T]['RESPONSE']>;
-    getChainId(): Promise<StarknetChainId>;
+    getChainId(): Promise<any>;
     getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
+    getBlockHashAndNumber(): Promise<RPC.BlockHashAndNumber>;
     getBlockWithTxHashes(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxHashesResponse>;
     getBlockWithTxs(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxs>;
+    getClassHashAt(blockIdentifier: BlockIdentifier, contractAddress: RPC.ContractAddress): Promise<RPC.Felt>;
     getNonce(contractAddress: string): Promise<any>;
+    getPendingTransactions(): Promise<RPC.PendingTransactions>;
+    getProtocolVersion(): Promise<Error>;
+    getStateUpdate(blockIdentifier: BlockIdentifier): Promise<RPC.StateUpdate>;
     getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
     getTransactionByHash(txHash: BigNumberish): Promise<RPC.GetTransactionByHashResponse>;
     getTransactionByBlockIdAndIndex(blockIdentifier: BlockIdentifier, index: number): Promise<RPC.GetTransactionByBlockIdAndIndex>;
     getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
+    getClass(classHash: RPC.Felt): Promise<RPC.ContractClass>;
     getClassAt(contractAddress: string, blockIdentifier: BlockIdentifier): Promise<any>;
+    getCode(_contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
     getEstimateFee(invocation: Invocation, blockIdentifier?: BlockIdentifier, invocationDetails?: InvocationsDetails): Promise<EstimateFeeResponse>;
     declareContract({ contract, version, }: DeclareContractPayload): Promise<DeclareContractResponse>;
     deployContract({ contract, constructorCalldata, addressSalt, }: DeployContractPayload): Promise<DeployContractResponse>;
     invokeFunction(functionInvocation: Invocation, details: InvocationsDetails): Promise<InvokeFunctionResponse>;
     callContract(call: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
-    getCode(_contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
+    traceTransaction(transactionHash: RPC.TransactionHash): Promise<RPC.Trace>;
+    traceBlockTransactions(blockHash: RPC.BlockHash): Promise<RPC.Traces>;
     waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
     /**
      * Gets the transaction count from a block.