starknet 3.18.0 → 3.19.0

package/src/utils/responseParser/sequencer.ts

@@ -0,0 +1,127 @@
+import {
+  CallContractResponse,
+  DeclareContractResponse,
+  DeployContractResponse,
+  EstimateFeeResponse,
+  GetBlockResponse,
+  GetTransactionReceiptResponse,
+  GetTransactionResponse,
+  InvokeFunctionResponse,
+} from '../../types';
+import { Sequencer } from '../../types/api';
+import { toBN } from '../number';
+import { ResponseParser } from '.';
+
+export class SequencerAPIResponseParser extends ResponseParser {
+  public parseGetBlockResponse(res: Sequencer.GetBlockResponse): GetBlockResponse {
+    return {
+      accepted_time: 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)
+        .filter(Boolean) as Array<string>,
+    };
+  }
+
+  public parseGetTransactionResponse(
+    res: Sequencer.GetTransactionResponse
+  ): GetTransactionResponse {
+    return {
+      calldata: 'calldata' in res.transaction ? (res.transaction.calldata as Array<string>) : [],
+      contract_address:
+        'contract_address' in res.transaction ? res.transaction.contract_address : undefined,
+      contract_class:
+        'contract_class' in res.transaction ? (res.transaction.contract_class as any) : undefined,
+      entry_point_selector:
+        'entry_point_selector' in res.transaction
+          ? res.transaction.entry_point_selector
+          : undefined,
+      max_fee: 'max_fee' in res.transaction ? (res.transaction.max_fee as string) : undefined,
+      nonce: res.transaction.nonce as string,
+      sender_address:
+        'sender_address' in res.transaction
+          ? (res.transaction.sender_address as string)
+          : undefined,
+      signature: 'signature' in res.transaction ? res.transaction.signature : undefined,
+      transaction_hash:
+        'transaction_hash' in res.transaction ? res.transaction.transaction_hash : undefined,
+      version: 'version' in res.transaction ? (res.transaction.version as string) : undefined,
+    };
+  }
+
+  public parseGetTransactionReceiptResponse(
+    res: Sequencer.TransactionReceiptResponse
+  ): GetTransactionReceiptResponse {
+    return {
+      transaction_hash: res.transaction_hash,
+      actual_fee: 'actual_fee' in res ? res.actual_fee : undefined,
+      status: res.status,
+      status_data: undefined,
+      messages_sent: res.l2_to_l1_messages as any, // TODO: parse
+      events: res.events as any,
+      l1_origin_message: undefined,
+    };
+  }
+
+  public parseFeeEstimateResponse(res: Sequencer.EstimateFeeResponse): EstimateFeeResponse {
+    if ('overall_fee' in res) {
+      let gasInfo = {};
+
+      try {
+        gasInfo = {
+          gas_consumed: toBN(res.gas_usage),
+          gas_price: toBN(res.gas_price),
+        };
+      } catch {
+        // do nothing
+      }
+
+      return {
+        overall_fee: toBN(res.overall_fee),
+        ...gasInfo,
+      };
+    }
+    return {
+      overall_fee: toBN(res.amount),
+    };
+  }
+
+  public parseCallContractResponse(res: Sequencer.CallContractResponse): CallContractResponse {
+    return {
+      result: res.result,
+    };
+  }
+
+  public parseInvokeFunctionResponse(
+    res: Sequencer.AddTransactionResponse
+  ): InvokeFunctionResponse {
+    return {
+      transaction_hash: res.transaction_hash,
+    };
+  }
+
+  public parseDeployContractResponse(
+    res: Sequencer.AddTransactionResponse
+  ): DeployContractResponse {
+    return {
+      transaction_hash: res.transaction_hash,
+      contract_address: res.address as string,
+    };
+  }
+
+  public parseDeclareContractResponse(
+    res: Sequencer.AddTransactionResponse
+  ): DeclareContractResponse {
+    return {
+      transaction_hash: res.transaction_hash,
+      class_hash: res.class_hash as string,
+    };
+  }
+}

package/src/utils/typedData/index.ts

@@ -36,6 +36,12 @@ export const getDependencies = (
     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
+    type = type.slice(0, -1);
+  }
+
   if (dependencies.includes(type)) {
     return dependencies;
   }
@@ -102,6 +108,18 @@ const encodeValue = (typedData: TypedData, type: string, data: unknown): [string
     return [type, getStructHash(typedData, type, data as Record<string, unknown>)];
   }
 
+  if (
+    Object.keys(typedData.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 [type, computeHashOnElements(structHashes)];
+  }
+
   if (type === 'felt*') {
     return ['felt*', computeHashOnElements(data as string[])];
   }

package/types/account.d.ts

@@ -1,13 +1,11 @@
 import BN from 'bn.js';
-
 import { BlockIdentifier } from '../provider/utils';
 import { BigNumberish } from '../utils/number';
-export interface EstimateFee {
-  amount: BN;
-  unit: string;
-  suggestedMaxFee: BN;
+import { EstimateFeeResponse } from './provider';
+export interface EstimateFee extends EstimateFeeResponse {
+    suggestedMaxFee: BN;
 }
 export interface EstimateFeeDetails {
-  nonce?: BigNumberish;
-  blockIdentifier?: BlockIdentifier;
+    nonce?: BigNumberish;
+    blockIdentifier?: BlockIdentifier;
 }

package/types/account.js

@@ -1,2 +1,2 @@
-'use strict';
-Object.defineProperty(exports, '__esModule', { value: true });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/types/api/index.d.ts

@@ -0,0 +1,16 @@
+import { BigNumberish } from '../../utils/number';
+import { Signature } from '../lib';
+export declare type RawArgs = {
+    [inputName: string]: string | string[] | {
+        type: 'struct';
+        [k: string]: BigNumberish;
+    };
+};
+export declare type Calldata = string[];
+export declare type Overrides = {
+    maxFee?: BigNumberish;
+    nonce?: BigNumberish;
+    signature?: Signature;
+};
+export * from './sequencer';
+export * from './rpc';

package/types/api/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sequencer"), exports);
+__exportStar(require("./rpc"), exports);

package/types/api/rpc.d.ts

@@ -0,0 +1,221 @@
+import { StarknetChainId } from '../../constants';
+import { Status } from '../lib';
+export declare namespace RPC {
+    export type Response = {
+        id: number;
+        result: any;
+        jsonrpc: string;
+        error?: {
+            code: string;
+            message: string;
+        };
+    };
+    export type AddTransactionResponse = {
+        transaction_hash: string;
+    };
+    export type GetClassResponse = {
+        program: string;
+        entry_point_by_type: any;
+    };
+    export type DeclareResponse = {
+        transaction_hash: string;
+        class_hash: string;
+    };
+    export type EstimateFeeResponse = {
+        overall_fee: number;
+        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 GetTransactionReceiptResponse = {
+        txn_hash: string;
+        actual_fee: string;
+        status: Status;
+        status_data: string;
+        messages_sent: Array<MessageToL1>;
+        l1_origin_message: MessageToL2;
+        events: Array<StarknetEvent>;
+    };
+    interface CommonTransactionProperties {
+        txn_hash: string;
+        max_fee: string;
+        version: string;
+        nonce: string;
+        signature: Array<string>;
+    }
+    export interface InvokeTransactionResponse extends CommonTransactionProperties {
+        contract_address?: string;
+        entry_point_selector?: string;
+        calldata?: Array<string>;
+    }
+    export interface DeclareTransactionResponse extends CommonTransactionProperties {
+        contract_class?: GetClassResponse;
+        sender_address?: string;
+    }
+    export type GetTransactionResponse = InvokeTransactionResponse & DeclareTransactionResponse;
+    export type GetTransactionCountResponse = number;
+    export type GetBlockNumberResponse = number;
+    export type GetSyncingStatsResponse = {
+        starting_block_hash: string;
+        starting_block_num: string;
+        current_block_hash: string;
+        current_block_num: string;
+        highest_block_hash: string;
+        highest_block_num: string;
+    } | boolean;
+    export type EventFilter = {
+        fromBlock: string;
+        toBlock: string;
+        address: string;
+        keys: string[];
+        page_size: number;
+        page_number: number;
+    };
+    export type GetEventsResponse = {
+        events: StarknetEmittedEvent[];
+        page_number: number;
+        is_last_page: number;
+    };
+    export type DeployContractResponse = {
+        transaction_hash: string;
+        contract_address: string;
+    };
+    export type StarknetEvent = {
+        from_address: string;
+        keys: string[];
+        data: string[];
+    };
+    export type StarknetEmittedEvent = {
+        event: StarknetEvent;
+        block_hash: string;
+        block_number: number;
+        transaction_hash: string;
+    };
+    export type MessageToL1 = {
+        to_address: string;
+        payload: string[];
+    };
+    export type MessageToL2 = {
+        from_address: string;
+        payload: string[];
+    };
+    export type Methods = {
+        starknet_getBlockByHash: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetBlockResponse;
+        };
+        starknet_getBlockByNumber: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetBlockResponse;
+        };
+        starknet_getStorageAt: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetStorageAtResponse;
+        };
+        starknet_getTransactionByHash: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetTransactionResponse;
+        };
+        starknet_getTransactionByBlockHashAndIndex: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetTransactionResponse;
+        };
+        starknet_getTransactionByBlockNumberAndIndex: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetTransactionResponse;
+        };
+        starknet_getTransactionReceipt: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetTransactionReceiptResponse;
+        };
+        starknet_getBlockTransactionCountByHash: {
+            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[];
+            RESPONSE: string[];
+        };
+        starknet_estimateFee: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: EstimateFeeResponse;
+        };
+        starknet_blockNumber: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetBlockNumberResponse;
+        };
+        starknet_chainId: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: StarknetChainId;
+        };
+        starknet_syncing: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetSyncingStatsResponse;
+        };
+        starknet_getEvents: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: GetEventsResponse;
+        };
+        starknet_addInvokeTransaction: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: AddTransactionResponse;
+        };
+        starknet_addDeployTransaction: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: DeployContractResponse;
+        };
+        starknet_addDeclareTransaction: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: DeclareResponse;
+        };
+        starknet_getClassAt: {
+            QUERY: never;
+            REQUEST: any[];
+            RESPONSE: any;
+        };
+    };
+    export {};
+}

package/types/api/rpc.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });