starknet 4.3.0 → 4.3.1

package/src/types/api/openrpc.ts

@@ -0,0 +1,168 @@
+/**
+ * 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}$"
+ */
+type FELT = string;
+type BLOCK_NUMBER = number;
+type BLOCK_HASH = FELT;
+type TXN_HASH = FELT;
+type TXN_STATUS = 'PENDING' | 'ACCEPTED_ON_L2' | 'ACCEPTED_ON_L1' | 'REJECTED';
+type TXN_TYPE = 'DECLARE' | 'DEPLOY' | 'INVOKE' | 'L1_HANDLER';
+type MSG_TO_L1 = {
+  to_address: FELT;
+  payload: Array<FELT>;
+};
+type EVENT = {
+  from_address: FELT;
+  keys: Array<FELT>;
+  data: Array<FELT>;
+};
+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;
+};
+type INVOKE_TXN_RECEIPT_PROPERTIES = {
+  messages_sent: MSG_TO_L1;
+  events: EVENT;
+};
+type PENDING_COMMON_RECEIPT_PROPERTIES = {
+  transaction_hash: TXN_HASH;
+  actual_fee: FELT;
+  type?: TXN_TYPE;
+};
+type INVOKE_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES & INVOKE_TXN_RECEIPT_PROPERTIES;
+type L1_HANDLER_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+type DECLARE_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+type DEPLOY_TXN_RECEIPT = COMMON_RECEIPT_PROPERTIES;
+type PENDING_INVOKE_TXN_RECEIPT = PENDING_COMMON_RECEIPT_PROPERTIES & INVOKE_TXN_RECEIPT_PROPERTIES;
+type PENDING_TXN_RECEIPT = PENDING_INVOKE_TXN_RECEIPT | PENDING_COMMON_RECEIPT_PROPERTIES;
+type TXN_RECEIPT =
+  | INVOKE_TXN_RECEIPT
+  | L1_HANDLER_TXN_RECEIPT
+  | DECLARE_TXN_RECEIPT
+  | DEPLOY_TXN_RECEIPT
+  | PENDING_TXN_RECEIPT;
+
+export namespace RPC_1 {
+  export type GetTransactionReceiptResponse = TXN_RECEIPT;
+
+  export type Methods = {
+    starknet_getTransactionReceipt: {
+      QUERY: never;
+      REQUEST: any[];
+      RESPONSE: GetTransactionReceiptResponse;
+    };
+  };
+}
+
+// starknet_getBlockWithTxHashes
+type BLOCK_HEADER = {
+  block_hash: BLOCK_HASH;
+  parent_hash: BLOCK_HASH;
+  block_number: BLOCK_NUMBER;
+  new_root: FELT;
+  timestamp: number;
+  sequencer_address: FELT;
+};
+type BLOCK_BODY_WITH_TX_HASHES = {
+  transactions: Array<TXN_HASH>;
+};
+type BLOCK_WITH_TX_HASHES = {
+  status: TXN_STATUS;
+} & BLOCK_HEADER &
+  BLOCK_BODY_WITH_TX_HASHES;
+type PENDING_BLOCK_WITH_TX_HASHES = BLOCK_BODY_WITH_TX_HASHES & {
+  timestamp: number;
+  sequencer_address: FELT;
+  parent_hash: BLOCK_HASH;
+};
+
+// starknet_getBlockWithTx
+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]+$"
+ */
+type NUM_AS_HEX = string;
+type SIGNATURE = Array<FELT>;
+type COMMON_TXN_PROPERTIES = {
+  transaction_hash: TXN_HASH;
+  max_fee: FELT;
+  version: NUM_AS_HEX;
+  signature: SIGNATURE;
+  nonce: FELT;
+  type: TXN_TYPE;
+};
+type ADDRESS = FELT;
+type FUNCTION_CALL = {
+  contract_address: ADDRESS;
+  entry_point_selector: FELT;
+  calldata: Array<FELT>;
+};
+type INVOKE_TXN = COMMON_TXN_PROPERTIES & FUNCTION_CALL;
+type DECLARE_TXN = COMMON_TXN_PROPERTIES & {
+  class_hash: FELT;
+  sender_address: ADDRESS;
+};
+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>;
+};
+type TXN = INVOKE_TXN | DECLARE_TXN | DEPLOY_TXN;
+type BLOCK_BODY_WITH_TXS = {
+  transactions: Array<TXN>;
+};
+type BLOCK_WITH_TXS = {
+  status: BLOCK_STATUS;
+} & BLOCK_HEADER &
+  BLOCK_BODY_WITH_TXS;
+
+type PENDING_BLOCK_WITH_TXS = BLOCK_BODY_WITH_TXS & {
+  timestamp: number;
+  sequencer_address: FELT;
+  parent_hash: BLOCK_HASH;
+};
+
+type CONTRACT_CLASS = {
+  program: string; // A base64 representation of the compressed program code
+  entry_points_by_type: {
+    CONSTRUCTOR: CONTRACT_ENTRY_POINT_LIST;
+    EXTERNAL: CONTRACT_ENTRY_POINT_LIST;
+    L1_HANDLER: CONTRACT_ENTRY_POINT_LIST;
+  };
+};
+
+type CONTRACT_ENTRY_POINT_LIST = Array<CONTRACT_ENTRY_POINT>;
+type CONTRACT_ENTRY_POINT = {
+  offset: NUM_AS_HEX;
+  selector: FELT;
+};
+
+export namespace OPENRPC {
+  export type GetBlockWithTxHashesResponse = BLOCK_WITH_TX_HASHES | PENDING_BLOCK_WITH_TX_HASHES;
+  export type GetBlockWithTxs = BLOCK_WITH_TXS | PENDING_BLOCK_WITH_TXS;
+  export type GetStorageAtResponse = FELT;
+  export type GetTransactionByHashResponse = TXN;
+  export type GetTransactionByBlockIdAndIndex = TXN;
+  export type GetClassResponse = CONTRACT_CLASS;
+}

package/src/types/api/rpc.ts

@@ -1,5 +1,7 @@
 import { StarknetChainId } from '../../constants';
+import { BlockIdentifier } from '../../provider/utils';
 import { Status } from '../lib';
+import { OPENRPC } from './openrpc';
 
 export namespace RPC {
   export type Response = {
@@ -32,25 +34,9 @@ export namespace RPC {
     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;
@@ -81,7 +67,8 @@ export namespace RPC {
     sender_address?: string;
   }
 
-  export type GetTransactionResponse = InvokeTransactionResponse & DeclareTransactionResponse;
+  export type GetTransactionByHashResponse = OPENRPC.GetTransactionByHashResponse;
+  export type GetTransactionByBlockIdAndIndex = OPENRPC.GetTransactionByBlockIdAndIndex;
 
   export type GetTransactionCountResponse = number;
 
@@ -99,8 +86,8 @@ export namespace RPC {
     | boolean;
 
   export type EventFilter = {
-    fromBlock: string;
-    toBlock: string;
+    fromBlock: BlockIdentifier;
+    toBlock: BlockIdentifier;
     address: string;
     keys: string[];
     page_size: number;
@@ -143,56 +130,46 @@ export namespace RPC {
   };
 
   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: {
-      QUERY: never;
-      REQUEST: any[];
-      RESPONSE: GetTransactionCountResponse;
-    };
-    starknet_getBlockTransactionCountByNumber: {
+    starknet_getBlockTransactionCount: {
       QUERY: never;
       REQUEST: any[];
       RESPONSE: GetTransactionCountResponse;
     };
-    starknet_getCode: {
-      QUERY: never;
-      REQUEST: any[];
-      RESPONSE: GetCodeResponse;
-    };
     starknet_call: {
       QUERY: never;
       REQUEST: any[];

package/src/types/provider.ts

@@ -1,19 +1,19 @@
+/**
+ * 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 {

package/src/utils/ellipticCurve.ts

@@ -21,11 +21,13 @@ export const ec = new EC(
   })
 );
 
-/*
- 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: string) {
   const pureHex = msg.replace(/^0x0*/, '');
 
@@ -64,11 +66,12 @@ export function getKeyPairFromPublicKey(publicKey: BigNumberish): KeyPair {
   return ec.keyFromPublic(removeHexPrefix(toHex(publicKeyBn)), 'hex');
 }
 
-/*
- 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.
+ */
 export function sign(keyPair: KeyPair, msgHash: string): Signature {
   const msgHashBN = toBN(addHexPrefix(msgHash));
   // Verify message hash has valid length.
@@ -89,12 +92,13 @@ function chunkArray(arr: any[], n: number): any[][] {
     .map((_, i) => 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.
+ */
 export function verify(keyPair: KeyPair | KeyPair[], msgHash: string, sig: Signature): boolean {
   const keyPairArray = Array.isArray(keyPair) ? keyPair : [keyPair];
   const msgHashBN = toBN(addHexPrefix(msgHash));

package/src/utils/responseParser/rpc.ts

@@ -1,3 +1,7 @@
+/**
+ * Map RPC Response to common interface response
+ * Intersection (sequencer response ∩ (∪ rpc responses))
+ */
 import {
   CallContractResponse,
   DeclareContractResponse,
@@ -12,33 +16,36 @@ import { RPC } from '../../types/api';
 import { toBN } from '../number';
 import { ResponseParser } from '.';
 
+type RpcGetBlockResponse = RPC.GetBlockWithTxHashesResponse & {
+  [key: string]: any;
+};
+
+type GetTransactionByHashResponse = RPC.GetTransactionByHashResponse & {
+  [key: string]: any;
+};
+
 export class RPCResponseParser extends ResponseParser {
-  public parseGetBlockResponse(res: RPC.GetBlockResponse): GetBlockResponse {
+  public parseGetBlockResponse(res: RpcGetBlockResponse): GetBlockResponse {
     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,
     };
   }
 
-  public parseGetTransactionResponse(res: RPC.GetTransactionResponse): GetTransactionResponse {
+  public parseGetTransactionResponse(res: GetTransactionByHashResponse): GetTransactionResponse {
     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,
     };
   }
@@ -57,10 +64,6 @@ export class RPCResponseParser extends ResponseParser {
     };
   }
 
-  public parseGetCodeResponse(res: RPC.GetCodeResponse): RPC.GetCodeResponse {
-    return res;
-  }
-
   public parseFeeEstimateResponse(res: RPC.EstimateFeeResponse): EstimateFeeResponse {
     return {
       overall_fee: toBN(res.overall_fee),

package/src/utils/responseParser/sequencer.ts

@@ -1,3 +1,7 @@
+/**
+ * Map Sequencer Response to common interface response
+ * Intersection (sequencer response ∩ (∪ rpc responses))
+ */
 import {
   CallContractResponse,
   DeclareContractResponse,
@@ -15,14 +19,11 @@ import { ResponseParser } from '.';
 export class SequencerAPIResponseParser extends ResponseParser {
   public parseGetBlockResponse(res: Sequencer.GetBlockResponse): GetBlockResponse {
     return {
-      accepted_time: res.timestamp,
+      timestamp: res.timestamp,
       block_hash: res.block_hash,
       block_number: res.block_number,
-      gas_price: res.gas_price,
       new_root: res.state_root,
-      old_root: undefined,
       parent_hash: res.parent_block_hash,
-      sequencer: res.sequencer_address,
       status: res.status,
       transactions: Object.values(res.transactions)
         .map((value) => 'transaction_hash' in value && value.transaction_hash)
@@ -70,10 +71,6 @@ export class SequencerAPIResponseParser extends ResponseParser {
     };
   }
 
-  public parseGetCodeResponse(res: Sequencer.GetCodeResponse): Sequencer.GetCodeResponse {
-    return res;
-  }
-
   public parseFeeEstimateResponse(res: Sequencer.EstimateFeeResponse): EstimateFeeResponse {
     if ('overall_fee' in res) {
       let gasInfo = {};

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 });