starknet 4.3.0 → 4.4.1

package/dist/utils/typedData/index.js

@@ -39,8 +39,9 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getMessageHash = exports.getStructHash = exports.encodeData = exports.getTypeHash = exports.encodeType = exports.getDependencies = void 0;
+exports.getMessageHash = exports.getStructHash = exports.encodeData = exports.encodeValue = exports.getTypeHash = exports.encodeType = exports.getDependencies = exports.isMerkleTreeType = exports.prepareSelector = void 0;
 var hash_1 = require("../hash");
+var merkle_1 = require("../merkle");
 var number_1 = require("../number");
 var shortString_1 = require("../shortString");
 var utils_1 = require("./utils");
@@ -56,6 +57,14 @@ function getHex(value) {
         throw new Error("Invalid BigNumberish: ".concat(value));
     }
 }
+function prepareSelector(selector) {
+    return (0, number_1.isHex)(selector) ? selector : (0, hash_1.getSelectorFromName)(selector);
+}
+exports.prepareSelector = prepareSelector;
+function isMerkleTreeType(type) {
+    return type.type === 'merkletree';
+}
+exports.isMerkleTreeType = isMerkleTreeType;
 /**
  * Get the dependencies of a struct type. If a struct has the same dependency multiple times, it's only included once
  * in the resulting array.
@@ -65,12 +74,8 @@ function getHex(value) {
  * @param {string[]} [dependencies]
  * @return {string[]}
  */
-var getDependencies = function (typedData, type, dependencies) {
+var getDependencies = function (types, type, dependencies) {
     if (dependencies === void 0) { dependencies = []; }
-    // `getDependencies` is called by most other functions, so we validate the JSON schema here
-    if (!(0, utils_1.validateTypedData)(typedData)) {
-        throw new Error('Typed data does not match JSON schema');
-    }
     // Include pointers (struct arrays)
     if (type[type.length - 1] === '*') {
         // eslint-disable-next-line no-param-reassign
@@ -79,14 +84,29 @@ var getDependencies = function (typedData, type, dependencies) {
     if (dependencies.includes(type)) {
         return dependencies;
     }
-    if (!typedData.types[type]) {
+    if (!types[type]) {
         return dependencies;
     }
     return __spreadArray([
         type
-    ], __read(typedData.types[type].reduce(function (previous, t) { return __spreadArray(__spreadArray([], __read(previous), false), __read((0, exports.getDependencies)(typedData, t.type, previous).filter(function (dependency) { return !previous.includes(dependency); })), false); }, [])), false);
+    ], __read(types[type].reduce(function (previous, t) { return __spreadArray(__spreadArray([], __read(previous), false), __read((0, exports.getDependencies)(types, t.type, previous).filter(function (dependency) { return !previous.includes(dependency); })), false); }, [])), false);
 };
 exports.getDependencies = getDependencies;
+function getMerkleTreeType(types, ctx) {
+    if (ctx.parent && ctx.key) {
+        var parentType = types[ctx.parent];
+        var merkleType = parentType.find(function (t) { return t.name === ctx.key; });
+        var isMerkleTree = isMerkleTreeType(merkleType);
+        if (!isMerkleTree) {
+            throw new Error("".concat(ctx.key, " is not a merkle tree"));
+        }
+        if (merkleType.contains.endsWith('*')) {
+            throw new Error("Merkle tree contain property must not be an array but was given ".concat(ctx.key));
+        }
+        return merkleType.contains;
+    }
+    return 'raw';
+}
 /**
  * Encode a type to a string. All dependant types are alphabetically sorted.
  *
@@ -94,12 +114,12 @@ exports.getDependencies = getDependencies;
  * @param {string} type
  * @return {string}
  */
-var encodeType = function (typedData, type) {
-    var _a = __read((0, exports.getDependencies)(typedData, type)), primary = _a[0], dependencies = _a.slice(1);
-    var types = __spreadArray([primary], __read(dependencies.sort()), false);
-    return types
+var encodeType = function (types, type) {
+    var _a = __read((0, exports.getDependencies)(types, type)), primary = _a[0], dependencies = _a.slice(1);
+    var newTypes = !primary ? [] : __spreadArray([primary], __read(dependencies.sort()), false);
+    return newTypes
         .map(function (dependency) {
-        return "".concat(dependency, "(").concat(typedData.types[dependency].map(function (t) { return "".concat(t.name, ":").concat(t.type); }), ")");
+        return "".concat(dependency, "(").concat(types[dependency].map(function (t) { return "".concat(t.name, ":").concat(t.type); }), ")");
     })
         .join('');
 };
@@ -111,8 +131,8 @@ exports.encodeType = encodeType;
  * @param {string} type
  * @return {string}
  */
-var getTypeHash = function (typedData, type) {
-    return (0, hash_1.getSelectorFromName)((0, exports.encodeType)(typedData, type));
+var getTypeHash = function (types, type) {
+    return (0, hash_1.getSelectorFromName)((0, exports.encodeType)(types, type));
 };
 exports.getTypeHash = getTypeHash;
 /**
@@ -124,25 +144,39 @@ exports.getTypeHash = getTypeHash;
  * @param {any} data
  * @returns {[string, string]}
  */
-var encodeValue = function (typedData, type, data) {
-    if (typedData.types[type]) {
+var encodeValue = function (types, type, data, ctx) {
+    if (ctx === void 0) { ctx = {}; }
+    if (types[type]) {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        return [type, (0, exports.getStructHash)(typedData, type, data)];
+        return [type, (0, exports.getStructHash)(types, type, data)];
     }
-    if (Object.keys(typedData.types)
+    if (Object.keys(types)
         .map(function (x) { return "".concat(x, "*"); })
         .includes(type)) {
         var structHashes = data.map(function (struct) {
             // eslint-disable-next-line @typescript-eslint/no-use-before-define
-            return (0, exports.getStructHash)(typedData, type.slice(0, -1), struct);
+            return (0, exports.getStructHash)(types, type.slice(0, -1), struct);
         });
         return [type, (0, hash_1.computeHashOnElements)(structHashes)];
     }
+    if (type === 'merkletree') {
+        var merkleTreeType_1 = getMerkleTreeType(types, ctx);
+        var structHashes = data.map(function (struct) {
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            return (0, exports.encodeValue)(types, merkleTreeType_1, struct)[1];
+        });
+        var root = new merkle_1.MerkleTree(structHashes).root;
+        return ['felt', root];
+    }
     if (type === 'felt*') {
         return ['felt*', (0, hash_1.computeHashOnElements)(data)];
     }
+    if (type === 'selector') {
+        return ['felt', prepareSelector(data)];
+    }
     return [type, getHex(data)];
 };
+exports.encodeValue = encodeValue;
 /**
  * Encode the data to an ABI encoded Buffer. The data should be a key -> value object with all the required values. All
  * dependant types are automatically encoded.
@@ -151,20 +185,23 @@ var encodeValue = function (typedData, type, data) {
  * @param {string} type
  * @param {Record<string, any>} data
  */
-var encodeData = function (typedData, type, data) {
-    var _a = __read(typedData.types[type].reduce(function (_a, field) {
+var encodeData = function (types, type, data) {
+    var _a = __read(types[type].reduce(function (_a, field) {
         var _b = __read(_a, 2), ts = _b[0], vs = _b[1];
         if (data[field.name] === undefined || data[field.name] === null) {
             throw new Error("Cannot encode data: missing data for '".concat(field.name, "'"));
         }
         var value = data[field.name];
-        var _c = __read(encodeValue(typedData, field.type, value), 2), t = _c[0], encodedValue = _c[1];
+        var _c = __read((0, exports.encodeValue)(types, field.type, value, {
+            parent: type,
+            key: field.name,
+        }), 2), t = _c[0], encodedValue = _c[1];
         return [
             __spreadArray(__spreadArray([], __read(ts), false), [t], false),
             __spreadArray(__spreadArray([], __read(vs), false), [encodedValue], false),
         ];
-    }, [['felt'], [(0, exports.getTypeHash)(typedData, type)]]), 2), types = _a[0], values = _a[1];
-    return [types, values];
+    }, [['felt'], [(0, exports.getTypeHash)(types, type)]]), 2), returnTypes = _a[0], values = _a[1];
+    return [returnTypes, values];
 };
 exports.encodeData = encodeData;
 /**
@@ -176,24 +213,26 @@ exports.encodeData = encodeData;
  * @param {Record<string, any>} data
  * @return {Buffer}
  */
-var getStructHash = function (typedData, type, data) {
-    return (0, hash_1.computeHashOnElements)((0, exports.encodeData)(typedData, type, data)[1]);
+var getStructHash = function (types, type, data) {
+    return (0, hash_1.computeHashOnElements)((0, exports.encodeData)(types, type, data)[1]);
 };
 exports.getStructHash = getStructHash;
 /**
- * Get the EIP-191 encoded message to sign, from the typedData object. If `hash` is enabled, the message will be hashed
- * with Keccak256.
+ * Get the EIP-191 encoded message to sign, from the typedData object.
  *
  * @param {TypedData} typedData
  * @param {BigNumberish} account
  * @return {string}
  */
 var getMessageHash = function (typedData, account) {
+    if (!(0, utils_1.validateTypedData)(typedData)) {
+        throw new Error('Typed data does not match JSON schema');
+    }
     var message = [
         (0, shortString_1.encodeShortString)('StarkNet Message'),
-        (0, exports.getStructHash)(typedData, 'StarkNetDomain', typedData.domain),
+        (0, exports.getStructHash)(typedData.types, 'StarkNetDomain', typedData.domain),
         account,
-        (0, exports.getStructHash)(typedData, typedData.primaryType, typedData.message),
+        (0, exports.getStructHash)(typedData.types, typedData.primaryType, typedData.message),
     ];
     return (0, hash_1.computeHashOnElements)(message);
 };

package/dist/utils/typedData/types.d.ts

@@ -1,13 +1,18 @@
+export declare type StarkNetMerkleType = {
+    name: string;
+    type: 'merkletree';
+    contains: string;
+};
 /**
  * A single type, as part of a struct. The `type` field can be any of the EIP-712 supported types.
  *
  * Note that the `uint` and `int` aliases like in Solidity, and fixed point numbers are not supported by the EIP-712
  * standard.
  */
-export interface StarkNetType {
+export declare type StarkNetType = {
     name: string;
-    type: 'felt' | 'felt*' | string;
-}
+    type: string;
+} | StarkNetMerkleType;
 /**
  * The EIP712 domain struct. Any of these fields are optional, but it must contain at least one field.
  */

package/index.d.ts

@@ -16,6 +16,7 @@ export * as json from './utils/json';
 export * as number from './utils/number';
 export * as transaction from './utils/transaction';
 export * as stark from './utils/stark';
+export * as merkle from './utils/merkle';
 export * as ec from './utils/ellipticCurve';
 export * as uint256 from './utils/uint256';
 export * as shortString from './utils/shortString';

package/index.js

@@ -26,7 +26,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.typedData = exports.shortString = exports.uint256 = exports.ec = exports.stark = exports.transaction = exports.number = exports.json = exports.hash = exports.encode = exports.constants = void 0;
+exports.typedData = exports.shortString = exports.uint256 = exports.ec = exports.merkle = exports.stark = exports.transaction = exports.number = exports.json = exports.hash = exports.encode = exports.constants = void 0;
 /**
  * Main
  */
@@ -45,6 +45,7 @@ exports.json = __importStar(require("./utils/json"));
 exports.number = __importStar(require("./utils/number"));
 exports.transaction = __importStar(require("./utils/transaction"));
 exports.stark = __importStar(require("./utils/stark"));
+exports.merkle = __importStar(require("./utils/merkle"));
 exports.ec = __importStar(require("./utils/ellipticCurve"));
 exports.uint256 = __importStar(require("./utils/uint256"));
 exports.shortString = __importStar(require("./utils/shortString"));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starknet",
-  "version": "4.3.0",
+  "version": "4.4.1",
   "description": "JavaScript library for StarkNet",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/provider/default.d.ts

@@ -1,5 +1,5 @@
 import { StarknetChainId } from '../constants';
-import { BlockTag, Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
+import { Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
 import { RpcProviderOptions } from './rpc';
@@ -16,7 +16,7 @@ export declare class Provider implements ProviderInterface {
     getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
     getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;
     getEstimateFee(invocation: Invocation, blockIdentifier?: BlockIdentifier, invocationDetails?: InvocationsDetails): Promise<EstimateFeeResponse>;
-    getStorageAt(contractAddress: string, key: BigNumberish, blockTagOrHash?: BlockTag | BigNumberish): Promise<BigNumberish>;
+    getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
     getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
     callContract(request: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;

package/provider/default.js

@@ -86,11 +86,11 @@ var Provider = /** @class */ (function () {
             });
         });
     };
-    Provider.prototype.getStorageAt = function (contractAddress, key, blockTagOrHash) {
-        if (blockTagOrHash === void 0) { blockTagOrHash = 'pending'; }
+    Provider.prototype.getStorageAt = function (contractAddress, key, blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.provider.getStorageAt(contractAddress, key, blockTagOrHash)];
+                return [2 /*return*/, this.provider.getStorageAt(contractAddress, key, blockIdentifier)];
             });
         });
     };

package/provider/interface.d.ts

@@ -1,5 +1,5 @@
 import { StarknetChainId } from '../constants';
-import type { BlockTag, Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
+import type { Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
 import type { BigNumberish } from '../utils/number';
 import { BlockIdentifier } from './utils';
 export declare abstract class ProviderInterface {
@@ -19,6 +19,9 @@ export declare abstract class ProviderInterface {
      * @returns the block object
      */
     abstract getBlock(blockIdentifier: BlockIdentifier): Promise<GetBlockResponse>;
+    /**
+     * @deprecated The method should not be used
+     */
     abstract getCode(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
     /**
      * Gets the contract class of the deployed contract.
@@ -33,10 +36,10 @@ export declare abstract class ProviderInterface {
      *
      * @param contractAddress
      * @param key - from getStorageVarAddress('<STORAGE_VARIABLE_NAME>') (WIP)
-     * @param blockHashOrTag - block hash or tag (pending, latest)
+     * @param blockIdentifier - block identifier
      * @returns the value of the storage variable
      */
-    abstract getStorageAt(contractAddress: string, key: BigNumberish, blockHashOrTag?: BlockTag | BigNumberish): Promise<BigNumberish>;
+    abstract getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier: BlockIdentifier): Promise<BigNumberish>;
     /**
      * Gets the transaction information from a tx id.
      *

package/provider/rpc.d.ts

@@ -1,5 +1,5 @@
 import { StarknetChainId } from '../constants';
-import { BlockTag, Call, CallContractResponse, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
+import { Call, CallContractResponse, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetCodeResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
 import { RPC } from '../types/api';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
@@ -15,16 +15,21 @@ export declare class RpcProvider implements ProviderInterface {
     protected fetchEndpoint<T extends keyof RPC.Methods>(method: T, request?: RPC.Methods[T]['REQUEST']): Promise<RPC.Methods[T]['RESPONSE']>;
     getChainId(): Promise<StarknetChainId>;
     getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
-    getStorageAt(contractAddress: string, key: BigNumberish, blockHashOrTag?: BlockTag | BigNumberish): Promise<BigNumberish>;
+    getBlockWithTxHashes(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxHashesResponse>;
+    getBlockWithTxs(blockIdentifier?: BlockIdentifier): Promise<RPC.GetBlockWithTxs>;
+    getNonce(contractAddress: string): Promise<any>;
+    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>;
-    getClassAt(contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<any>;
+    getClassAt(contractAddress: string, blockIdentifier: BlockIdentifier): Promise<any>;
     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<RPC.GetCodeResponse>;
+    getCode(_contractAddress: string, _blockIdentifier?: BlockIdentifier): Promise<GetCodeResponse>;
     waitForTransaction(txHash: BigNumberish, retryInterval?: number): Promise<void>;
     /**
      * Gets the transaction count from a block.

package/provider/rpc.js

@@ -47,6 +47,7 @@ var number_1 = require("../utils/number");
 var provider_1 = require("../utils/provider");
 var rpc_1 = require("../utils/responseParser/rpc");
 var stark_1 = require("../utils/stark");
+var utils_1 = require("./utils");
 var RpcProvider = /** @class */ (function () {
     function RpcProvider(optionsOrProvider) {
         var _this = this;
@@ -112,36 +113,78 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
+    // Common Interface
     RpcProvider.prototype.getBlock = function (blockIdentifier) {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
-            var method;
             return __generator(this, function (_a) {
-                method = typeof blockIdentifier === 'string' && (0, number_1.isHex)(blockIdentifier)
-                    ? 'starknet_getBlockByHash'
-                    : 'starknet_getBlockByNumber';
-                return [2 /*return*/, this.fetchEndpoint(method, [blockIdentifier]).then(this.responseParser.parseGetBlockResponse)];
+                return [2 /*return*/, this.getBlockWithTxHashes(blockIdentifier).then(this.responseParser.parseGetBlockResponse)];
             });
         });
     };
-    RpcProvider.prototype.getStorageAt = function (contractAddress, key, blockHashOrTag) {
-        if (blockHashOrTag === void 0) { blockHashOrTag = 'pending'; }
+    RpcProvider.prototype.getBlockWithTxHashes = function (blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
+        return __awaiter(this, void 0, void 0, function () {
+            var blockIdentifierGetter;
+            return __generator(this, function (_a) {
+                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockWithTxHashes', [
+                        blockIdentifierGetter.getIdentifier(),
+                    ])];
+            });
+        });
+    };
+    RpcProvider.prototype.getBlockWithTxs = function (blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
+        return __awaiter(this, void 0, void 0, function () {
+            var blockIdentifierGetter;
+            return __generator(this, function (_a) {
+                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockWithTxs', [blockIdentifierGetter.getIdentifier()])];
+            });
+        });
+    };
+    RpcProvider.prototype.getNonce = function (contractAddress) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_getNonce', [contractAddress])];
+            });
+        });
+    };
+    RpcProvider.prototype.getStorageAt = function (contractAddress, key, blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
-            var parsedKey;
+            var parsedKey, blockIdentifierGetter;
             return __generator(this, function (_a) {
                 parsedKey = (0, number_1.toHex)((0, number_1.toBN)(key));
+                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
                 return [2 /*return*/, this.fetchEndpoint('starknet_getStorageAt', [
                         contractAddress,
                         parsedKey,
-                        blockHashOrTag,
+                        blockIdentifierGetter.getIdentifier(),
                     ])];
             });
         });
     };
+    // common interface
     RpcProvider.prototype.getTransaction = function (txHash) {
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.fetchEndpoint('starknet_getTransactionByHash', [txHash]).then(this.responseParser.parseGetTransactionResponse)];
+                return [2 /*return*/, this.getTransactionByHash(txHash).then(this.responseParser.parseGetTransactionResponse)];
+            });
+        });
+    };
+    RpcProvider.prototype.getTransactionByHash = function (txHash) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_getTransactionByHash', [txHash])];
+            });
+        });
+    };
+    RpcProvider.prototype.getTransactionByBlockIdAndIndex = function (blockIdentifier, index) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.fetchEndpoint('starknet_getTransactionByHash', [blockIdentifier, index])];
             });
         });
     };
@@ -152,11 +195,15 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
-    RpcProvider.prototype.getClassAt = function (contractAddress, _blockIdentifier) {
-        if (_blockIdentifier === void 0) { _blockIdentifier = 'pending'; }
+    RpcProvider.prototype.getClassAt = function (contractAddress, blockIdentifier) {
         return __awaiter(this, void 0, void 0, function () {
+            var blockIdentifierGetter;
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.fetchEndpoint('starknet_getClassAt', [contractAddress])];
+                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getClassAt', [
+                        blockIdentifierGetter.getIdentifier(),
+                        contractAddress,
+                    ])];
             });
         });
     };
@@ -170,7 +217,7 @@ var RpcProvider = /** @class */ (function () {
                             contract_address: invocation.contractAddress,
                             entry_point_selector: (0, hash_1.getSelectorFromName)(invocation.entrypoint),
                             calldata: (0, provider_1.parseCalldata)(invocation.calldata),
-                            signature: (0, number_1.bigNumberishArrayToDecimalStringArray)(invocation.signature || []),
+                            signature: (0, number_1.bigNumberishArrayToHexadecimalStringArray)(invocation.signature || []),
                             version: (0, number_1.toHex)((0, number_1.toBN)((invocationDetails === null || invocationDetails === void 0 ? void 0 : invocationDetails.version) || 0)),
                         },
                         blockIdentifier,
@@ -202,7 +249,7 @@ var RpcProvider = /** @class */ (function () {
                 contractDefinition = (0, provider_1.parseContract)(contract);
                 return [2 /*return*/, this.fetchEndpoint('starknet_addDeployTransaction', [
                         addressSalt !== null && addressSalt !== void 0 ? addressSalt : (0, stark_1.randomAddress)(),
-                        (0, number_1.bigNumberishArrayToDecimalStringArray)(constructorCalldata !== null && constructorCalldata !== void 0 ? constructorCalldata : []),
+                        (0, number_1.bigNumberishArrayToHexadecimalStringArray)(constructorCalldata !== null && constructorCalldata !== void 0 ? constructorCalldata : []),
                         {
                             program: contractDefinition.program,
                             entry_points_by_type: contractDefinition.entry_points_by_type,
@@ -220,7 +267,7 @@ var RpcProvider = /** @class */ (function () {
                             entry_point_selector: (0, hash_1.getSelectorFromName)(functionInvocation.entrypoint),
                             calldata: (0, provider_1.parseCalldata)(functionInvocation.calldata),
                         },
-                        (0, number_1.bigNumberishArrayToDecimalStringArray)(functionInvocation.signature || []),
+                        (0, number_1.bigNumberishArrayToHexadecimalStringArray)(functionInvocation.signature || []),
                         (0, number_1.toHex)((0, number_1.toBN)(details.maxFee || 0)),
                         (0, number_1.toHex)((0, number_1.toBN)(details.version || 0)),
                     ]).then(this.responseParser.parseInvokeFunctionResponse)];
@@ -248,16 +295,10 @@ var RpcProvider = /** @class */ (function () {
             });
         });
     };
-    RpcProvider.prototype.getCode = function (contractAddress, _blockIdentifier) {
+    RpcProvider.prototype.getCode = function (_contractAddress, _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.fetchEndpoint('starknet_getCode', [contractAddress])];
-                    case 1:
-                        result = _a.sent();
-                        return [2 /*return*/, this.responseParser.parseGetCodeResponse(result)];
-                }
+                throw new Error('RPC 0.1.0 does not implement getCode function');
             });
         });
     };
@@ -325,11 +366,12 @@ var RpcProvider = /** @class */ (function () {
      */
     RpcProvider.prototype.getTransactionCount = function (blockIdentifier) {
         return __awaiter(this, void 0, void 0, function () {
+            var blockIdentifierGetter;
             return __generator(this, function (_a) {
-                if (typeof blockIdentifier === 'number') {
-                    return [2 /*return*/, this.fetchEndpoint('starknet_getBlockTransactionCountByNumber', [blockIdentifier])];
-                }
-                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockTransactionCountByHash', [blockIdentifier])];
+                blockIdentifierGetter = new utils_1.BlockIdentifierClass(blockIdentifier);
+                return [2 /*return*/, this.fetchEndpoint('starknet_getBlockTransactionCount', [
+                        blockIdentifierGetter.getIdentifier(),
+                    ])];
             });
         });
     };

package/provider/sequencer.d.ts

@@ -1,5 +1,5 @@
 import { StarknetChainId } from '../constants';
-import { BlockTag, Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
+import { Call, CallContractResponse, ContractClass, DeclareContractPayload, DeclareContractResponse, DeployContractPayload, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetTransactionReceiptResponse, GetTransactionResponse, Invocation, InvocationsDetails, InvokeFunctionResponse } from '../types';
 import { GetContractAddressesResponse, GetTransactionStatusResponse, GetTransactionTraceResponse, Sequencer } from '../types/api';
 import { BigNumberish } from '../utils/number';
 import { ProviderInterface } from './interface';
@@ -29,7 +29,7 @@ export declare class SequencerProvider implements ProviderInterface {
     protected fetchEndpoint<T extends keyof Sequencer.Endpoints>(endpoint: T, ...[query, request]: Sequencer.Endpoints[T]['QUERY'] extends never ? Sequencer.Endpoints[T]['REQUEST'] extends never ? [] : [undefined, Sequencer.Endpoints[T]['REQUEST']] : Sequencer.Endpoints[T]['REQUEST'] extends never ? [Sequencer.Endpoints[T]['QUERY']] : [Sequencer.Endpoints[T]['QUERY'], Sequencer.Endpoints[T]['REQUEST']]): Promise<Sequencer.Endpoints[T]['RESPONSE']>;
     callContract({ contractAddress, entrypoint: entryPointSelector, calldata }: Call, blockIdentifier?: BlockIdentifier): Promise<CallContractResponse>;
     getBlock(blockIdentifier?: BlockIdentifier): Promise<GetBlockResponse>;
-    getStorageAt(contractAddress: string, key: BigNumberish, blockHashOrTag?: BlockTag | BigNumberish): Promise<BigNumberish>;
+    getStorageAt(contractAddress: string, key: BigNumberish, blockIdentifier?: BlockIdentifier): Promise<BigNumberish>;
     getTransaction(txHash: BigNumberish): Promise<GetTransactionResponse>;
     getTransactionReceipt(txHash: BigNumberish): Promise<GetTransactionReceiptResponse>;
     getClassAt(contractAddress: string, blockIdentifier?: BlockIdentifier): Promise<ContractClass>;

package/provider/sequencer.js

@@ -249,14 +249,14 @@ var SequencerProvider = /** @class */ (function () {
             });
         });
     };
-    SequencerProvider.prototype.getStorageAt = function (contractAddress, key, blockHashOrTag) {
-        if (blockHashOrTag === void 0) { blockHashOrTag = 'pending'; }
+    SequencerProvider.prototype.getStorageAt = function (contractAddress, key, blockIdentifier) {
+        if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
             var parsedKey;
             return __generator(this, function (_a) {
                 parsedKey = (0, number_1.toBN)(key).toString(10);
                 return [2 /*return*/, this.fetchEndpoint('get_storage_at', {
-                        blockIdentifier: blockHashOrTag,
+                        blockIdentifier: blockIdentifier,
                         contractAddress: contractAddress,
                         key: parsedKey,
                     })];
@@ -359,7 +359,7 @@ var SequencerProvider = /** @class */ (function () {
         if (blockIdentifier === void 0) { blockIdentifier = 'pending'; }
         return __awaiter(this, void 0, void 0, function () {
             return __generator(this, function (_a) {
-                return [2 /*return*/, this.fetchEndpoint('get_code', { contractAddress: contractAddress, blockIdentifier: blockIdentifier }).then(this.responseParser.parseGetCodeResponse)];
+                return [2 /*return*/, this.fetchEndpoint('get_code', { contractAddress: contractAddress, blockIdentifier: blockIdentifier })];
             });
         });
     };

package/provider/utils.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="bn.js" />
 import type { BlockNumber } from '../types';
 import { BigNumberish } from '../utils/number';
 /**
@@ -23,6 +24,17 @@ declare type BlockIdentifierObject = {
     type: 'BLOCK_HASH';
     data: BigNumberish;
 };
+export declare class BlockIdentifierClass {
+    blockIdentifier: BlockIdentifier;
+    constructor(blockIdentifier: BlockIdentifier);
+    getIdentifier(): string | import("bn.js") | {
+        block_hash: string;
+        block_number?: undefined;
+    } | {
+        block_number: number;
+        block_hash?: undefined;
+    } | null;
+}
 /**
  * Identifies the block to be queried.
  *

package/provider/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getFormattedBlockIdentifier = exports.getBlockIdentifier = exports.txIdentifier = exports.formatHash = void 0;
+exports.getFormattedBlockIdentifier = exports.getBlockIdentifier = exports.BlockIdentifierClass = exports.txIdentifier = exports.formatHash = void 0;
 var number_1 = require("../utils/number");
 /**
  *
@@ -29,6 +29,22 @@ function txIdentifier(txHash, txId) {
     return "transactionHash=".concat(hashString);
 }
 exports.txIdentifier = txIdentifier;
+var BlockIdentifierClass = /** @class */ (function () {
+    function BlockIdentifierClass(blockIdentifier) {
+        this.blockIdentifier = blockIdentifier;
+    }
+    BlockIdentifierClass.prototype.getIdentifier = function () {
+        if (typeof this.blockIdentifier === 'string' && (0, number_1.isHex)(this.blockIdentifier)) {
+            return { block_hash: this.blockIdentifier };
+        }
+        if (typeof this.blockIdentifier === 'number') {
+            return { block_number: this.blockIdentifier };
+        }
+        return this.blockIdentifier;
+    };
+    return BlockIdentifierClass;
+}());
+exports.BlockIdentifierClass = BlockIdentifierClass;
 /**
  * Identifies the block to be queried.
  *