starknet 4.2.0 → 4.4.0

package/src/utils/url.ts

@@ -0,0 +1,53 @@
+import urljoin from 'url-join';
+
+/**
+ * Inspired from https://github.com/segmentio/is-url
+ */
+
+/**
+ * RegExps.
+ * A URL must match #1 and then at least one of #2/#3.
+ * Use two levels of REs to avoid REDOS.
+ */
+const protocolAndDomainRE = /^(?:\w+:)?\/\/(\S+)$/;
+
+const localhostDomainRE = /^localhost[:?\d]*(?:[^:?\d]\S*)?$/;
+const nonLocalhostDomainRE = /^[^\s.]+\.\S{2,}$/;
+
+/**
+ * Loosely validate a URL `string`.
+ * @param {String} s
+ * @return {Boolean}
+ */
+export function isUrl(s?: string): boolean {
+  if (!s) {
+    return false;
+  }
+
+  if (typeof s !== 'string') {
+    return false;
+  }
+
+  const match = s.match(protocolAndDomainRE);
+  if (!match) {
+    return false;
+  }
+
+  const everythingAfterProtocol = match[1];
+  if (!everythingAfterProtocol) {
+    return false;
+  }
+
+  if (
+    localhostDomainRE.test(everythingAfterProtocol) ||
+    nonLocalhostDomainRE.test(everythingAfterProtocol)
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+export function buildUrl(baseUrl: string, defaultPath: string, urlOrPath?: string) {
+  return isUrl(urlOrPath) ? urlOrPath! : urljoin(baseUrl, urlOrPath ?? defaultPath);
+}

package/types/api/openrpc.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Starknet RPC version 0.1.0
+ * starknet_api_openrpc version 0.31.0
+ *
+ * TypeScript Representation of OpenRpc protocol types | results
+ * errors are not implemented here only results
+ */
+/**
+ * "type": "string",
+ * "title": "Field element",
+ * "$comment": "A field element, represented as a string of hex digits",
+ * "description": "A field element. Represented as up to 63 hex digits and leading 4 bits zeroed.",
+ * "pattern": "^0x0[a-fA-F0-9]{1,63}$"
+ */
+declare type FELT = string;
+declare type BLOCK_NUMBER = number;
+declare type BLOCK_HASH = FELT;
+declare type TXN_HASH = FELT;
+declare type TXN_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+declare type TXN_TYPE = 'DECLARE' | 'DEPLOY' | 'INVOKE' | 'L1_HANDLER';
+declare type MSG_TO_L1 = {
+    to_address: FELT;
+    payload: Array<FELT>;
+};
+declare type EVENT = {
+    from_address: FELT;
+    keys: Array<FELT>;
+    data: Array<FELT>;
+};
+declare type COMMON_RECEIPT_PROPERTIES = {
+    transaction_hash: TXN_HASH;
+    actual_fee: FELT;
+    status: TXN_STATUS;
+    block_hash: BLOCK_HASH;
+    block_number: BLOCK_NUMBER;
+    type?: TXN_TYPE;
+};
+declare type INVOKE_TXN_RECEIPT_PROPERTIES = {
+    messages_sent: MSG_TO_L1;
+    events: EVENT;
+};
+declare type PENDING_COMMON_RECEIPT_PROPERTIES = {
+    transaction_hash: TXN_HASH;
+    actual_fee: FELT;
+    type?: TXN_TYPE;
+};
+declare type INVOKE_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES & INVOKE_TXN_RECEIPT_PROPERTIES;
+declare type L1_HANDLER_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+declare type DECLARE_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+declare type DEPLOY_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+declare type PENDING_INVOKE_TXN_RECEIPT = PENDING_COMMON_RECEIPT_PROPERTIES & INVOKE_TXN_RECEIPT_PROPERTIES;
+declare type PENDING_TXN_RECEIPT = PENDING_INVOKE_TXN_RECEIPT | PENDING_COMMON_RECEIPT_PROPERTIES;
+declare type TXN_RECEIPT = INVOKE_TXN_RECEIPT | L1_HANDLER_TXN_RECEIPT | DECLARE_TXN_RECEIPT | DEPLOY_TXN_RECEIPT | PENDING_TXN_RECEIPT;
+export declare namespace RPC_1 {
+    type GetTransactionReceiptResponse = TXN_RECEIPT;
+    type Methods = {
+        starknet_getTransactionReceipt: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetTransactionReceiptResponse;
+        };
+    };
+}
+declare type BLOCK_HEADER = {
+    block_hash: BLOCK_HASH;
+    parent_hash: BLOCK_HASH;
+    block_number: BLOCK_NUMBER;
+    new_root: FELT;
+    timestamp: number;
+    sequencer_address: FELT;
+};
+declare type BLOCK_BODY_WITH_TX_HASHES = {
+    transactions: Array<TXN_HASH>;
+};
+declare type BLOCK_WITH_TX_HASHES = {
+    status: TXN_STATUS;
+} & BLOCK_HEADER & BLOCK_BODY_WITH_TX_HASHES;
+declare type PENDING_BLOCK_WITH_TX_HASHES = BLOCK_BODY_WITH_TX_HASHES & {
+    timestamp: number;
+    sequencer_address: FELT;
+    parent_hash: BLOCK_HASH;
+};
+declare type BLOCK_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+/**
+ * "title": "An integer number in hex format (0x...)",
+ * "pattern": "^0x[a-fA-F0-9]+$"
+ */
+declare type NUM_AS_HEX = string;
+declare type SIGNATURE = Array<FELT>;
+declare type COMMON_TXN_PROPERTIES = {
+    transaction_hash: TXN_HASH;
+    max_fee: FELT;
+    version: NUM_AS_HEX;
+    signature: SIGNATURE;
+    nonce: FELT;
+    type: TXN_TYPE;
+};
+declare type ADDRESS = FELT;
+declare type FUNCTION_CALL = {
+    contract_address: ADDRESS;
+    entry_point_selector: FELT;
+    calldata: Array<FELT>;
+};
+declare type INVOKE_TXN = COMMON_TXN_PROPERTIES & FUNCTION_CALL;
+declare type DECLARE_TXN = COMMON_TXN_PROPERTIES & {
+    class_hash: FELT;
+    sender_address: ADDRESS;
+};
+declare type DEPLOY_TXN = {
+    transaction_hash: TXN_HASH;
+    class_hash: FELT;
+    version: NUM_AS_HEX;
+    type: TXN_TYPE;
+    contract_address: FELT;
+    contract_address_salt: FELT;
+    constructor_calldata: Array<FELT>;
+};
+declare type TXN = INVOKE_TXN | DECLARE_TXN | DEPLOY_TXN;
+declare type BLOCK_BODY_WITH_TXS = {
+    transactions: Array<TXN>;
+};
+declare type BLOCK_WITH_TXS = {
+    status: BLOCK_STATUS;
+} & BLOCK_HEADER & BLOCK_BODY_WITH_TXS;
+declare type PENDING_BLOCK_WITH_TXS = BLOCK_BODY_WITH_TXS & {
+    timestamp: number;
+    sequencer_address: FELT;
+    parent_hash: BLOCK_HASH;
+};
+declare type CONTRACT_CLASS = {
+    program: string;
+    entry_points_by_type: {
+        CONSTRUCTOR: CONTRACT_ENTRY_POINT_LIST;
+        EXTERNAL: CONTRACT_ENTRY_POINT_LIST;
+        L1_HANDLER: CONTRACT_ENTRY_POINT_LIST;
+    };
+};
+declare type CONTRACT_ENTRY_POINT_LIST = Array<CONTRACT_ENTRY_POINT>;
+declare type CONTRACT_ENTRY_POINT = {
+    offset: NUM_AS_HEX;
+    selector: FELT;
+};
+export declare namespace OPENRPC {
+    type GetBlockWithTxHashesResponse = BLOCK_WITH_TX_HASHES | PENDING_BLOCK_WITH_TX_HASHES;
+    type GetBlockWithTxs = BLOCK_WITH_TXS | PENDING_BLOCK_WITH_TXS;
+    type GetStorageAtResponse = FELT;
+    type GetTransactionByHashResponse = TXN;
+    type GetTransactionByBlockIdAndIndex = TXN;
+    type GetClassResponse = CONTRACT_CLASS;
+}
+export {};

package/types/api/openrpc.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Starknet RPC version 0.1.0
+ * starknet_api_openrpc version 0.31.0
+ *
+ * TypeScript Representation of OpenRpc protocol types | results
+ * errors are not implemented here only results
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/api/rpc.d.ts

@@ -1,5 +1,7 @@
 import { StarknetChainId } from '../../constants';
+import { BlockIdentifier } from '../../provider/utils';
 import { Status } from '../lib';
+import { OPENRPC } from './openrpc';
 export declare namespace RPC {
     export type Response = {
         id: number;
@@ -26,23 +28,9 @@ export declare namespace RPC {
         gas_consumed: number;
         gas_price: number;
     };
-    export type GetBlockResponse = {
-        block_hash: string;
-        parent_hash: string;
-        block_number: number;
-        status: Status;
-        sequencer: string;
-        new_root: string;
-        old_root: string;
-        accepted_time: number;
-        gas_price: string;
-        transactions: string[];
-    };
-    export type GetCodeResponse = {
-        bytecode: string[];
-        abi: string;
-    };
-    export type GetStorageAtResponse = string;
+    export type GetBlockWithTxHashesResponse = OPENRPC.GetBlockWithTxHashesResponse;
+    export type GetBlockWithTxs = OPENRPC.GetBlockWithTxs;
+    export type GetStorageAtResponse = OPENRPC.GetStorageAtResponse;
     export type GetTransactionReceiptResponse = {
         txn_hash: string;
         actual_fee: string;
@@ -68,7 +56,8 @@ export declare namespace RPC {
         contract_class?: GetClassResponse;
         sender_address?: string;
     }
-    export type GetTransactionResponse = InvokeTransactionResponse & DeclareTransactionResponse;
+    export type GetTransactionByHashResponse = OPENRPC.GetTransactionByHashResponse;
+    export type GetTransactionByBlockIdAndIndex = OPENRPC.GetTransactionByBlockIdAndIndex;
     export type GetTransactionCountResponse = number;
     export type GetBlockNumberResponse = number;
     export type GetSyncingStatsResponse = {
@@ -80,8 +69,8 @@ export declare namespace RPC {
         highest_block_num: string;
     } | boolean;
     export type EventFilter = {
-        fromBlock: string;
-        toBlock: string;
+        fromBlock: BlockIdentifier;
+        toBlock: BlockIdentifier;
         address: string;
         keys: string[];
         page_size: number;
@@ -116,56 +105,46 @@ export declare namespace RPC {
         payload: string[];
     };
     export type Methods = {
-        starknet_getBlockByHash: {
+        starknet_getBlockWithTxHashes: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: GetBlockResponse;
+            RESPONSE: GetBlockWithTxHashesResponse;
         };
-        starknet_getBlockByNumber: {
+        starknet_getBlockWithTxs: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: GetBlockResponse;
+            RESPONSE: GetBlockWithTxs;
         };
-        starknet_getStorageAt: {
+        starknet_getNonce: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: GetStorageAtResponse;
+            RESPONSE: string;
         };
-        starknet_getTransactionByHash: {
+        starknet_getStorageAt: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: GetTransactionResponse;
+            RESPONSE: GetStorageAtResponse;
         };
-        starknet_getTransactionByBlockHashAndIndex: {
+        starknet_getTransactionByHash: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: GetTransactionResponse;
+            RESPONSE: GetTransactionByHashResponse;
         };
-        starknet_getTransactionByBlockNumberAndIndex: {
+        starknet_getTransactionByBlockIdAndIndex: {
             QUERY: never;
             REQUEST: any[];
-            RESPONSE: GetTransactionResponse;
+            RESPONSE: GetTransactionByBlockIdAndIndex;
         };
         starknet_getTransactionReceipt: {
             QUERY: never;
             REQUEST: any[];
             RESPONSE: GetTransactionReceiptResponse;
         };
-        starknet_getBlockTransactionCountByHash: {
+        starknet_getBlockTransactionCount: {
             QUERY: never;
             REQUEST: any[];
             RESPONSE: GetTransactionCountResponse;
         };
-        starknet_getBlockTransactionCountByNumber: {
-            QUERY: never;
-            REQUEST: any[];
-            RESPONSE: GetTransactionCountResponse;
-        };
-        starknet_getCode: {
-            QUERY: never;
-            REQUEST: any[];
-            RESPONSE: GetCodeResponse;
-        };
         starknet_call: {
             QUERY: never;
             REQUEST: any[];

package/types/provider.d.ts

@@ -1,17 +1,17 @@
+/**
+ * Common interface response
+ * Intersection (sequencer response ∩ (∪ rpc responses))
+ */
 import BN from 'bn.js';
 import { Abi, CompressedProgram, EntryPointsByType, RawCalldata, Signature, Status } from './lib';
 export interface GetBlockResponse {
-    accepted_time: number;
+    timestamp: number;
     block_hash: string;
     block_number: number;
-    gas_price: string;
     new_root: string;
-    old_root?: string;
     parent_hash: string;
-    sequencer: string;
     status: Status;
     transactions: Array<string>;
-    starknet_version?: string;
 }
 export interface GetCodeResponse {
     bytecode: string[];

package/utils/ellipticCurve.d.ts

@@ -12,5 +12,18 @@ export declare function getStarkKey(keyPair: KeyPair): string;
  * @returns keyPair with public key only, which can be used to verify signatures, but cant sign anything
  */
 export declare function getKeyPairFromPublicKey(publicKey: BigNumberish): KeyPair;
+/**
+ * Signs a message using the provided key.
+ *
+ * @param keyPair should be an KeyPair with a valid private key.
+ * @returns an Signature.
+ */
 export declare function sign(keyPair: KeyPair, msgHash: string): Signature;
+/**
+ * Verifies a message using the provided key.
+ *
+ * @param keyPair should be an KeyPair with a valid public key.
+ * @param sig should be an Signature.
+ * @returns true if the verification succeeds.
+ */
 export declare function verify(keyPair: KeyPair | KeyPair[], msgHash: string, sig: Signature): boolean;

package/utils/ellipticCurve.js

@@ -37,11 +37,13 @@ exports.ec = new elliptic_1.ec(new elliptic_1.curves.PresetCurve({
     gRed: false,
     g: constants_1.CONSTANT_POINTS[1],
 }));
-/*
- The function _truncateToN in lib/elliptic/ec/index.js does a shift-right of 4 bits
- in some cases. This function does the opposite operation so that
-   _truncateToN(fixMessage(msg)) == msg.
-*/
+/**
+ * The function _truncateToN in lib/elliptic/ec/index.js does a shift-right of 4 bits
+ * in some cases. This function does the opposite operation so that
+ * _truncateToN(fixMessage(msg)) == msg.
+ *
+ * @param msg
+ */
 function fixMessage(msg) {
     var pureHex = msg.replace(/^0x0*/, '');
     if (pureHex.length <= 62) {
@@ -77,11 +79,12 @@ function getKeyPairFromPublicKey(publicKey) {
     return exports.ec.keyFromPublic((0, encode_1.removeHexPrefix)((0, number_1.toHex)(publicKeyBn)), 'hex');
 }
 exports.getKeyPairFromPublicKey = getKeyPairFromPublicKey;
-/*
- Signs a message using the provided key.
- key should be an KeyPair with a valid private key.
- Returns an Signature.
-*/
+/**
+ * Signs a message using the provided key.
+ *
+ * @param keyPair should be an KeyPair with a valid private key.
+ * @returns an Signature.
+ */
 function sign(keyPair, msgHash) {
     var msgHashBN = (0, number_1.toBN)((0, encode_1.addHexPrefix)(msgHash));
     // Verify message hash has valid length.
@@ -101,12 +104,13 @@ function chunkArray(arr, n) {
         .fill('')
         .map(function (_, i) { return arr.slice(i * n, i * n + n); });
 }
-/*
-   Verifies a message using the provided key.
-   key should be an KeyPair with a valid public key.
-   msgSignature should be an Signature.
-   Returns a boolean true if the verification succeeds.
-  */
+/**
+ * Verifies a message using the provided key.
+ *
+ * @param keyPair should be an KeyPair with a valid public key.
+ * @param sig should be an Signature.
+ * @returns true if the verification succeeds.
+ */
 function verify(keyPair, msgHash, sig) {
     var keyPairArray = Array.isArray(keyPair) ? keyPair : [keyPair];
     var msgHashBN = (0, number_1.toBN)((0, encode_1.addHexPrefix)(msgHash));

package/utils/hash.js

@@ -78,13 +78,15 @@ function pedersen(input) {
     for (var i = 0; i < input.length; i += 1) {
         var x = (0, number_1.toBN)(input[i]);
         (0, minimalistic_assert_1.default)(x.gte(constants_1.ZERO) && x.lt((0, number_1.toBN)((0, encode_1.addHexPrefix)(constants_1.FIELD_PRIME))), "Invalid input: ".concat(input[i]));
-        for (var j = 0; j < 252; j += 1) {
-            var pt = constantPoints[2 + i * 252 + j];
-            (0, minimalistic_assert_1.default)(!point.getX().eq(pt.getX()));
-            if (x.and(constants_1.ONE).toNumber() !== 0) {
-                point = point.add(pt);
+        if (!x.isZero()) {
+            for (var j = 0; j < 252; j += 1) {
+                var pt = constantPoints[2 + i * 252 + j];
+                (0, minimalistic_assert_1.default)(!point.getX().eq(pt.getX()));
+                if (x.and(constants_1.ONE).toNumber() !== 0) {
+                    point = point.add(pt);
+                }
+                x = x.shrn(1);
             }
-            x = x.shrn(1);
         }
     }
     return (0, encode_1.addHexPrefix)(point.getX().toString(16));

package/utils/merkle.d.ts

@@ -0,0 +1,10 @@
+export declare class MerkleTree {
+    leaves: string[];
+    branches: string[][];
+    root: string;
+    constructor(leafHashes: string[]);
+    private build;
+    static hash(a: string, b: string): string;
+    getProof(leaf: string, branch?: string[], hashPath?: string[]): string[];
+}
+export declare function proofMerklePath(root: string, leaf: string, path: string[]): boolean;

package/utils/merkle.js

@@ -0,0 +1,90 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proofMerklePath = exports.MerkleTree = void 0;
+var hash_1 = require("./hash");
+var MerkleTree = /** @class */ (function () {
+    function MerkleTree(leafHashes) {
+        this.branches = [];
+        this.leaves = leafHashes;
+        this.root = this.build(leafHashes);
+    }
+    MerkleTree.prototype.build = function (leaves) {
+        if (leaves.length === 1) {
+            return leaves[0];
+        }
+        if (leaves.length !== this.leaves.length) {
+            this.branches.push(leaves);
+        }
+        var newLeaves = [];
+        for (var i = 0; i < leaves.length; i += 2) {
+            if (i + 1 === leaves.length) {
+                newLeaves.push(leaves[i]);
+            }
+            else {
+                newLeaves.push(MerkleTree.hash(leaves[i], leaves[i + 1]));
+            }
+        }
+        return this.build(newLeaves);
+    };
+    MerkleTree.hash = function (a, b) {
+        var _a = __read([a, b].sort(), 2), aSorted = _a[0], bSorted = _a[1];
+        return (0, hash_1.pedersen)([aSorted, bSorted]);
+    };
+    MerkleTree.prototype.getProof = function (leaf, branch, hashPath) {
+        var _a, _b;
+        if (branch === void 0) { branch = this.leaves; }
+        if (hashPath === void 0) { hashPath = []; }
+        var index = branch.indexOf(leaf);
+        if (index === -1) {
+            throw new Error('leaf not found');
+        }
+        if (branch.length === 1) {
+            return hashPath;
+        }
+        var isLeft = index % 2 === 0;
+        var neededBranch = (_a = (isLeft ? branch[index + 1] : branch[index - 1])) !== null && _a !== void 0 ? _a : '0x0';
+        var newHashPath = __spreadArray(__spreadArray([], __read(hashPath), false), [neededBranch], false);
+        var currentBranchLevelIndex = this.leaves.length === branch.length
+            ? -1
+            : this.branches.findIndex(function (b) { return b.length === branch.length; });
+        var nextBranch = (_b = this.branches[currentBranchLevelIndex + 1]) !== null && _b !== void 0 ? _b : [this.root];
+        return this.getProof(neededBranch === '0x0'
+            ? leaf
+            : MerkleTree.hash(isLeft ? leaf : neededBranch, isLeft ? neededBranch : leaf), nextBranch, newHashPath);
+    };
+    return MerkleTree;
+}());
+exports.MerkleTree = MerkleTree;
+function proofMerklePath(root, leaf, path) {
+    if (path.length === 0) {
+        return root === leaf;
+    }
+    var _a = __read(path), next = _a[0], rest = _a.slice(1);
+    return proofMerklePath(root, MerkleTree.hash(leaf, next), rest);
+}
+exports.proofMerklePath = proofMerklePath;

package/utils/number.js

@@ -31,7 +31,7 @@ var bn_js_1 = __importStar(require("bn.js"));
 var minimalistic_assert_1 = __importDefault(require("minimalistic-assert"));
 var encode_1 = require("./encode");
 function isHex(hex) {
-    return hex.startsWith('0x');
+    return /^0x[0-9a-f]*$/i.test(hex);
 }
 exports.isHex = isHex;
 function toBN(number, base) {

package/utils/responseParser/rpc.d.ts

@@ -1,14 +1,24 @@
+/**
+ * Map RPC Response to common interface response
+ * Intersection (sequencer response ∩ (∪ rpc responses))
+ */
 import { CallContractResponse, DeclareContractResponse, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetTransactionReceiptResponse, GetTransactionResponse, InvokeFunctionResponse } from '../../types';
 import { RPC } from '../../types/api';
 import { ResponseParser } from '.';
+declare type RpcGetBlockResponse = RPC.GetBlockWithTxHashesResponse & {
+    [key: string]: any;
+};
+declare type GetTransactionByHashResponse = RPC.GetTransactionByHashResponse & {
+    [key: string]: any;
+};
 export declare class RPCResponseParser extends ResponseParser {
-    parseGetBlockResponse(res: RPC.GetBlockResponse): GetBlockResponse;
-    parseGetTransactionResponse(res: RPC.GetTransactionResponse): GetTransactionResponse;
+    parseGetBlockResponse(res: RpcGetBlockResponse): GetBlockResponse;
+    parseGetTransactionResponse(res: GetTransactionByHashResponse): GetTransactionResponse;
     parseGetTransactionReceiptResponse(res: RPC.GetTransactionReceiptResponse): GetTransactionReceiptResponse;
-    parseGetCodeResponse(res: RPC.GetCodeResponse): RPC.GetCodeResponse;
     parseFeeEstimateResponse(res: RPC.EstimateFeeResponse): EstimateFeeResponse;
     parseCallContractResponse(res: Array<string>): CallContractResponse;
     parseInvokeFunctionResponse(res: RPC.AddTransactionResponse): InvokeFunctionResponse;
     parseDeployContractResponse(res: RPC.DeployContractResponse): DeployContractResponse;
     parseDeclareContractResponse(res: RPC.DeclareResponse): DeclareContractResponse;
 }
+export {};

package/utils/responseParser/rpc.js

@@ -25,14 +25,11 @@ var RPCResponseParser = /** @class */ (function (_super) {
     }
     RPCResponseParser.prototype.parseGetBlockResponse = function (res) {
         return {
-            accepted_time: res.accepted_time,
+            timestamp: res.timestamp,
             block_hash: res.block_hash,
             block_number: res.block_number,
-            gas_price: res.gas_price,
             new_root: res.new_root,
-            old_root: res.old_root,
             parent_hash: res.parent_hash,
-            sequencer: res.sequencer,
             status: res.status,
             transactions: res.transactions,
         };
@@ -41,13 +38,11 @@ var RPCResponseParser = /** @class */ (function (_super) {
         return {
             calldata: res.calldata || [],
             contract_address: res.contract_address,
-            contract_class: res.contract_class,
             entry_point_selector: res.entry_point_selector,
             max_fee: res.max_fee,
             nonce: res.nonce,
-            sender_address: res.sender_address,
             signature: res.signature || [],
-            transaction_hash: res.txn_hash,
+            transaction_hash: res.transaction_hash,
             version: res.version,
         };
     };
@@ -62,9 +57,6 @@ var RPCResponseParser = /** @class */ (function (_super) {
             events: res.events,
         };
     };
-    RPCResponseParser.prototype.parseGetCodeResponse = function (res) {
-        return res;
-    };
     RPCResponseParser.prototype.parseFeeEstimateResponse = function (res) {
         return {
             overall_fee: (0, number_1.toBN)(res.overall_fee),

package/utils/responseParser/sequencer.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Map Sequencer Response to common interface response
+ * Intersection (sequencer response ∩ (∪ rpc responses))
+ */
 import { CallContractResponse, DeclareContractResponse, DeployContractResponse, EstimateFeeResponse, GetBlockResponse, GetTransactionReceiptResponse, GetTransactionResponse, InvokeFunctionResponse } from '../../types';
 import { Sequencer } from '../../types/api';
 import { ResponseParser } from '.';
@@ -5,7 +9,6 @@ export declare class SequencerAPIResponseParser extends ResponseParser {
     parseGetBlockResponse(res: Sequencer.GetBlockResponse): GetBlockResponse;
     parseGetTransactionResponse(res: Sequencer.GetTransactionResponse): GetTransactionResponse;
     parseGetTransactionReceiptResponse(res: Sequencer.TransactionReceiptResponse): GetTransactionReceiptResponse;
-    parseGetCodeResponse(res: Sequencer.GetCodeResponse): Sequencer.GetCodeResponse;
     parseFeeEstimateResponse(res: Sequencer.EstimateFeeResponse): EstimateFeeResponse;
     parseCallContractResponse(res: Sequencer.CallContractResponse): CallContractResponse;
     parseInvokeFunctionResponse(res: Sequencer.AddTransactionResponse): InvokeFunctionResponse;