starknet 4.3.0 → 4.4.1

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/hash.ts

@@ -62,13 +62,15 @@ export function pedersen(input: [BigNumberish, BigNumberish]) {
   for (let i = 0; i < input.length; i += 1) {
     let x = toBN(input[i]);
     assert(x.gte(ZERO) && x.lt(toBN(addHexPrefix(FIELD_PRIME))), `Invalid input: ${input[i]}`);
-    for (let j = 0; j < 252; j += 1) {
-      const pt = constantPoints[2 + i * 252 + j];
-      assert(!point.getX().eq(pt.getX()));
-      if (x.and(ONE).toNumber() !== 0) {
-        point = point.add(pt);
+    if (!x.isZero()) {
+      for (let j = 0; j < 252; j += 1) {
+        const pt = constantPoints[2 + i * 252 + j];
+        assert(!point.getX().eq(pt.getX()));
+        if (x.and(ONE).toNumber() !== 0) {
+          point = point.add(pt);
+        }
+        x = x.shrn(1);
       }
-      x = x.shrn(1);
     }
   }
   return addHexPrefix(point.getX().toString(16));

package/src/utils/merkle.ts

@@ -0,0 +1,70 @@
+import { pedersen } from './hash';
+
+export class MerkleTree {
+  public leaves: string[];
+
+  public branches: string[][] = [];
+
+  public root: string;
+
+  constructor(leafHashes: string[]) {
+    this.leaves = leafHashes;
+    this.root = this.build(leafHashes);
+  }
+
+  private build(leaves: string[]): string {
+    if (leaves.length === 1) {
+      return leaves[0];
+    }
+    if (leaves.length !== this.leaves.length) {
+      this.branches.push(leaves);
+    }
+    const newLeaves = [];
+    for (let 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);
+  }
+
+  static hash(a: string, b: string) {
+    const [aSorted, bSorted] = [a, b].sort();
+    return pedersen([aSorted, bSorted]);
+  }
+
+  public getProof(leaf: string, branch = this.leaves, hashPath: string[] = []): string[] {
+    const index = branch.indexOf(leaf);
+    if (index === -1) {
+      throw new Error('leaf not found');
+    }
+    if (branch.length === 1) {
+      return hashPath;
+    }
+    const isLeft = index % 2 === 0;
+    const neededBranch = (isLeft ? branch[index + 1] : branch[index - 1]) ?? '0x0';
+    const newHashPath = [...hashPath, neededBranch];
+    const currentBranchLevelIndex =
+      this.leaves.length === branch.length
+        ? -1
+        : this.branches.findIndex((b) => b.length === branch.length);
+    const nextBranch = this.branches[currentBranchLevelIndex + 1] ?? [this.root];
+    return this.getProof(
+      neededBranch === '0x0'
+        ? leaf
+        : MerkleTree.hash(isLeft ? leaf : neededBranch, isLeft ? neededBranch : leaf),
+      nextBranch,
+      newHashPath
+    );
+  }
+}
+
+export function proofMerklePath(root: string, leaf: string, path: string[]): boolean {
+  if (path.length === 0) {
+    return root === leaf;
+  }
+  const [next, ...rest] = path;
+  return proofMerklePath(root, MerkleTree.hash(leaf, next), rest);
+}

package/src/utils/number.ts

@@ -6,7 +6,7 @@ import { addHexPrefix, removeHexPrefix } from './encode';
 export type BigNumberish = string | number | BN;
 
 export function isHex(hex: string): boolean {
-  return hex.startsWith('0x');
+  return /^0x[0-9a-f]*$/i.test(hex);
 }
 
 export function toBN(number: BigNumberish, base?: number | 'hex') {
@@ -57,3 +57,7 @@ export function assertInRange(
 export function bigNumberishArrayToDecimalStringArray(rawCalldata: BigNumberish[]): string[] {
   return rawCalldata.map((x) => toBN(x).toString(10));
 }
+
+export function bigNumberishArrayToHexadecimalStringArray(rawCalldata: BigNumberish[]): string[] {
+  return rawCalldata.map((x) => toHex(toBN(x)));
+}

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/src/utils/typedData/index.ts

@@ -1,7 +1,8 @@
 import { computeHashOnElements, getSelectorFromName } from '../hash';
-import { BigNumberish, toBN, toHex } from '../number';
+import { MerkleTree } from '../merkle';
+import { BigNumberish, isHex, toBN, toHex } from '../number';
 import { encodeShortString } from '../shortString';
-import { TypedData } from './types';
+import { StarkNetMerkleType, StarkNetType, TypedData } from './types';
 import { validateTypedData } from './utils';
 
 export * from './types';
@@ -17,6 +18,19 @@ function getHex(value: BigNumberish): string {
   }
 }
 
+export function prepareSelector(selector: string): string {
+  return isHex(selector) ? selector : getSelectorFromName(selector);
+}
+
+export function isMerkleTreeType(type: StarkNetType): type is StarkNetMerkleType {
+  return type.type === 'merkletree';
+}
+
+interface Context {
+  parent?: string;
+  key?: string;
+}
+
 /**
  * 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.
@@ -27,15 +41,10 @@ function getHex(value: BigNumberish): string {
  * @return {string[]}
  */
 export const getDependencies = (
-  typedData: TypedData,
+  types: TypedData['types'],
   type: string,
   dependencies: string[] = []
 ): string[] => {
-  // `getDependencies` is called by most other functions, so we validate the JSON schema here
-  if (!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
@@ -46,16 +55,16 @@ export const getDependencies = (
     return dependencies;
   }
 
-  if (!typedData.types[type]) {
+  if (!types[type]) {
     return dependencies;
   }
 
   return [
     type,
-    ...typedData.types[type].reduce<string[]>(
+    ...types[type].reduce<string[]>(
       (previous, t) => [
         ...previous,
-        ...getDependencies(typedData, t.type, previous).filter(
+        ...getDependencies(types, t.type, previous).filter(
           (dependency) => !previous.includes(dependency)
         ),
       ],
@@ -64,6 +73,22 @@ export const getDependencies = (
   ];
 };
 
+function getMerkleTreeType(types: TypedData['types'], ctx: Context) {
+  if (ctx.parent && ctx.key) {
+    const parentType = types[ctx.parent];
+    const merkleType = parentType.find((t) => t.name === ctx.key)!;
+    const isMerkleTree = isMerkleTreeType(merkleType);
+    if (!isMerkleTree) {
+      throw new Error(`${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 ${ctx.key}`);
+    }
+    return merkleType.contains;
+  }
+  return 'raw';
+}
+
 /**
  * Encode a type to a string. All dependant types are alphabetically sorted.
  *
@@ -71,13 +96,13 @@ export const getDependencies = (
  * @param {string} type
  * @return {string}
  */
-export const encodeType = (typedData: TypedData, type: string): string => {
-  const [primary, ...dependencies] = getDependencies(typedData, type);
-  const types = [primary, ...dependencies.sort()];
+export const encodeType = (types: TypedData['types'], type: string): string => {
+  const [primary, ...dependencies] = getDependencies(types, type);
+  const newTypes = !primary ? [] : [primary, ...dependencies.sort()];
 
-  return types
+  return newTypes
     .map((dependency) => {
-      return `${dependency}(${typedData.types[dependency].map((t) => `${t.name}:${t.type}`)})`;
+      return `${dependency}(${types[dependency].map((t) => `${t.name}:${t.type}`)})`;
     })
     .join('');
 };
@@ -89,8 +114,8 @@ export const encodeType = (typedData: TypedData, type: string): string => {
  * @param {string} type
  * @return {string}
  */
-export const getTypeHash = (typedData: TypedData, type: string): string => {
-  return getSelectorFromName(encodeType(typedData, type));
+export const getTypeHash = (types: TypedData['types'], type: string): string => {
+  return getSelectorFromName(encodeType(types, type));
 };
 
 /**
@@ -102,28 +127,47 @@ export const getTypeHash = (typedData: TypedData, type: string): string => {
  * @param {any} data
  * @returns {[string, string]}
  */
-const encodeValue = (typedData: TypedData, type: string, data: unknown): [string, string] => {
-  if (typedData.types[type]) {
+export const encodeValue = (
+  types: TypedData['types'],
+  type: string,
+  data: unknown,
+  ctx: Context = {}
+): [string, string] => {
+  if (types[type]) {
     // eslint-disable-next-line @typescript-eslint/no-use-before-define
-    return [type, getStructHash(typedData, type, data as Record<string, unknown>)];
+    return [type, getStructHash(types, type, data as Record<string, unknown>)];
   }
 
   if (
-    Object.keys(typedData.types)
+    Object.keys(types)
       .map((x) => `${x}*`)
       .includes(type)
   ) {
     const structHashes: string[] = (data as unknown[]).map((struct) => {
       // eslint-disable-next-line @typescript-eslint/no-use-before-define
-      return getStructHash(typedData, type.slice(0, -1), struct as Record<string, unknown>);
+      return getStructHash(types, type.slice(0, -1), struct as Record<string, unknown>);
     });
     return [type, computeHashOnElements(structHashes)];
   }
 
+  if (type === 'merkletree') {
+    const merkleTreeType = getMerkleTreeType(types, ctx);
+    const structHashes: string[] = (data as unknown[]).map((struct) => {
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define
+      return encodeValue(types, merkleTreeType, struct as Record<string, unknown>)[1];
+    });
+    const { root } = new MerkleTree(structHashes as string[]);
+    return ['felt', root];
+  }
+
   if (type === 'felt*') {
     return ['felt*', computeHashOnElements(data as string[])];
   }
 
+  if (type === 'selector') {
+    return ['felt', prepareSelector(data as string)];
+  }
+
   return [type, getHex(data as string)];
 };
 
@@ -135,25 +179,32 @@ const encodeValue = (typedData: TypedData, type: string, data: unknown): [string
  * @param {string} type
  * @param {Record<string, any>} data
  */
-export const encodeData = <T extends TypedData>(typedData: T, type: string, data: T['message']) => {
-  const [types, values] = typedData.types[type].reduce<[string[], string[]]>(
+export const encodeData = <T extends TypedData>(
+  types: T['types'],
+  type: string,
+  data: T['message']
+) => {
+  const [returnTypes, values] = types[type].reduce<[string[], string[]]>(
     ([ts, vs], field) => {
       if (data[field.name] === undefined || data[field.name] === null) {
         throw new Error(`Cannot encode data: missing data for '${field.name}'`);
       }
 
       const value = data[field.name];
-      const [t, encodedValue] = encodeValue(typedData, field.type, value);
+      const [t, encodedValue] = encodeValue(types, field.type, value, {
+        parent: type,
+        key: field.name,
+      });
 
       return [
         [...ts, t],
         [...vs, encodedValue],
       ];
     },
-    [['felt'], [getTypeHash(typedData, type)]]
+    [['felt'], [getTypeHash(types, type)]]
   );
 
-  return [types, values];
+  return [returnTypes, values];
 };
 
 /**
@@ -166,27 +217,30 @@ export const encodeData = <T extends TypedData>(typedData: T, type: string, data
  * @return {Buffer}
  */
 export const getStructHash = <T extends TypedData>(
-  typedData: T,
+  types: T['types'],
   type: string,
   data: T['message']
 ) => {
-  return computeHashOnElements(encodeData(typedData, type, data)[1]);
+  return computeHashOnElements(encodeData(types, type, data)[1]);
 };
 
 /**
- * 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}
  */
 export const getMessageHash = (typedData: TypedData, account: BigNumberish): string => {
+  if (!validateTypedData(typedData)) {
+    throw new Error('Typed data does not match JSON schema');
+  }
+
   const message = [
     encodeShortString('StarkNet Message'),
-    getStructHash(typedData, 'StarkNetDomain', typedData.domain),
+    getStructHash(typedData.types, 'StarkNetDomain', typedData.domain),
     account,
-    getStructHash(typedData, typedData.primaryType, typedData.message),
+    getStructHash(typedData.types, typedData.primaryType, typedData.message),
   ];
 
   return computeHashOnElements(message);

package/src/utils/typedData/types.ts

@@ -1,13 +1,21 @@
+export 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 {
-  name: string;
-  type: 'felt' | 'felt*' | string;
-}
+export type StarkNetType =
+  | {
+      name: string;
+      type: string;
+    }
+  | StarkNetMerkleType;
 
 /**
  * The EIP712 domain struct. Any of these fields are optional, but it must contain at least one field.

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