genlayer-js 0.8.0 → 0.9.1

package/src/transactions/actions.ts

@@ -1,10 +1,26 @@
 import {GenLayerClient} from "../types/clients";
-import {TransactionHash, TransactionStatus, GenLayerTransaction} from "../types/transactions";
+import {
+  TransactionHash,
+  TransactionStatus,
+  GenLayerTransaction,
+  GenLayerRawTransaction,
+  transactionsStatusNameToNumber,
+  transactionsStatusNumberToName,
+  transactionResultNumberToName,
+  VoteType,
+  voteTypeNumberToName,
+  DecodedCallData,
+  DecodedDeployData,
+} from "../types/transactions";
 import {transactionsConfig} from "../config/transactions";
 import {sleep} from "../utils/async";
-import {SimulatorChain} from "@/types";
+import {GenLayerChain} from "@/types";
+import {b64ToArray, calldataToUserFriendlyJson, resultToUserFriendlyJson} from "@/utils/jsonifier";
+import {Abi, PublicClient, fromRlp, fromHex, Hex, Address} from "viem";
+import * as calldataAbi from "@/abi/calldata";
+import {localnet} from "@/chains/localnet";
 
-export const transactionActions = (client: GenLayerClient<SimulatorChain>) => ({
+export const receiptActions = (client: GenLayerClient<GenLayerChain>, publicClient: PublicClient) => ({
   waitForTransactionReceipt: async ({
     hash,
     status = TransactionStatus.ACCEPTED,
@@ -16,16 +32,23 @@ export const transactionActions = (client: GenLayerClient<SimulatorChain>) => ({
     interval?: number;
     retries?: number;
   }): Promise<GenLayerTransaction> => {
-    const transaction = await client.getTransaction({hash});
+    const transaction = await client.getTransaction({
+      hash,
+    });
 
     if (!transaction) {
       throw new Error("Transaction not found");
     }
-
+    const transactionStatusString = String(transaction.status);
+    const transactionStatusFinalized = transactionsStatusNameToNumber[TransactionStatus.FINALIZED];
+    const requestedStatus = transactionsStatusNameToNumber[status];
     if (
-      transaction.status === status ||
-      (status === TransactionStatus.ACCEPTED && transaction.status === TransactionStatus.FINALIZED)
+      transactionStatusString === requestedStatus ||
+      (status === TransactionStatus.ACCEPTED && transactionStatusString === transactionStatusFinalized)
     ) {
+      if (client.chain.id === localnet.id) {
+        return _decodeLocalnetTransaction(transaction as unknown as GenLayerTransaction);
+      }
       return transaction;
     }
 
@@ -34,7 +57,7 @@ export const transactionActions = (client: GenLayerClient<SimulatorChain>) => ({
     }
 
     await sleep(interval);
-    return transactionActions(client).waitForTransactionReceipt({
+    return receiptActions(client, publicClient).waitForTransactionReceipt({
       hash,
       status,
       interval,
@@ -42,3 +65,145 @@ export const transactionActions = (client: GenLayerClient<SimulatorChain>) => ({
     });
   },
 });
+
+export const transactionActions = (client: GenLayerClient<GenLayerChain>, publicClient: PublicClient) => ({
+  getTransaction: async ({hash}: {hash: TransactionHash}): Promise<GenLayerTransaction> => {
+    const transaction = (await publicClient.readContract({
+      address: client.chain.consensusDataContract?.address as Address,
+      abi: client.chain.consensusDataContract?.abi as Abi,
+      functionName: "getTransactionData",
+      args: [
+        hash,
+        Math.round(new Date().getTime() / 1000), // unix seconds
+      ],
+    })) as unknown as GenLayerRawTransaction;
+    return _decodeTransaction(transaction);
+  },
+});
+
+const _decodeInputData = (
+  rlpEncodedAppData: Hex | undefined | null,
+  recipient: Address,
+): DecodedDeployData | DecodedCallData | null => {
+  if (!rlpEncodedAppData || rlpEncodedAppData === "0x" || rlpEncodedAppData.length <= 2) {
+    return null;
+  }
+  try {
+    const rlpDecodedArray = fromRlp(rlpEncodedAppData) as Hex[];
+
+    if (rlpDecodedArray.length === 3) {
+      return {
+        code: fromHex(rlpDecodedArray[0], "string") as `0x${string}`,
+        constructorArgs:
+          rlpDecodedArray[1] && rlpDecodedArray[1] !== "0x"
+            ? calldataAbi.decode(fromHex(rlpDecodedArray[1], "bytes"))
+            : null,
+        leaderOnly: rlpDecodedArray[2] === "0x01",
+        type: "deploy",
+        contractAddress: recipient,
+      };
+    } else if (rlpDecodedArray.length === 2) {
+      return {
+        callData:
+          rlpDecodedArray[0] && rlpDecodedArray[0] !== "0x"
+            ? calldataAbi.decode(fromHex(rlpDecodedArray[0], "bytes"))
+            : null,
+        leaderOnly: rlpDecodedArray[1] === "0x01",
+        type: "call",
+      };
+    } else {
+      console.warn(
+        "[decodeInputData] WRITE: Unexpected RLP array length:",
+        rlpDecodedArray.length,
+        rlpDecodedArray,
+      );
+      return null;
+    }
+  } catch (e) {
+    console.error(
+      "[decodeInputData] Error during comprehensive decoding:",
+      e,
+      "Raw RLP App Data:",
+      rlpEncodedAppData,
+    );
+    return null;
+  }
+};
+
+const _decodeTransaction = (tx: GenLayerRawTransaction): GenLayerTransaction => {
+  const txDataDecoded = _decodeInputData(tx.txData, tx.recipient);
+
+  const decodedTx = {
+    ...tx,
+    txData: tx.txData,
+    txDataDecoded: txDataDecoded,
+
+    currentTimestamp: tx.currentTimestamp.toString(),
+    numOfInitialValidators: tx.numOfInitialValidators.toString(),
+    txSlot: tx.txSlot.toString(),
+    createdTimestamp: tx.createdTimestamp.toString(),
+    lastVoteTimestamp: tx.lastVoteTimestamp.toString(),
+    queuePosition: tx.queuePosition.toString(),
+    numOfRounds: tx.numOfRounds.toString(),
+
+    readStateBlockRange: {
+      ...tx.readStateBlockRange,
+      activationBlock: tx.readStateBlockRange.activationBlock.toString(),
+      processingBlock: tx.readStateBlockRange.processingBlock.toString(),
+      proposalBlock: tx.readStateBlockRange.proposalBlock.toString(),
+    },
+
+    statusName:
+      transactionsStatusNumberToName[String(tx.status) as keyof typeof transactionsStatusNumberToName],
+    resultName:
+      transactionResultNumberToName[String(tx.result) as keyof typeof transactionResultNumberToName],
+
+    lastRound: {
+      ...tx.lastRound,
+      round: tx.lastRound.round.toString(),
+      leaderIndex: tx.lastRound.leaderIndex.toString(),
+      votesCommitted: tx.lastRound.votesCommitted.toString(),
+      votesRevealed: tx.lastRound.votesRevealed.toString(),
+      appealBond: tx.lastRound.appealBond.toString(),
+      rotationsLeft: tx.lastRound.rotationsLeft.toString(),
+      validatorVotesName: tx.lastRound.validatorVotes.map(
+        vote => voteTypeNumberToName[String(vote) as keyof typeof voteTypeNumberToName],
+      ) as VoteType[],
+    },
+  };
+  return decodedTx as GenLayerTransaction;
+};
+
+const _decodeLocalnetTransaction = (tx: GenLayerTransaction): GenLayerTransaction => {
+  try {
+    const leaderReceipt = tx.consensus_data?.leader_receipt;
+    if (leaderReceipt) {
+      if (leaderReceipt.result) {
+        leaderReceipt.result = resultToUserFriendlyJson(leaderReceipt.result);
+      }
+      if (leaderReceipt.calldata) {
+        leaderReceipt.calldata = {
+          base64: leaderReceipt.calldata as string,
+          ...calldataToUserFriendlyJson(b64ToArray(leaderReceipt.calldata as string)),
+        };
+      }
+      if (leaderReceipt.eq_outputs) {
+        leaderReceipt.eq_outputs = Object.fromEntries(
+          Object.entries(leaderReceipt.eq_outputs).map(([key, value]) => {
+            const decodedValue = new TextDecoder().decode(b64ToArray(String(value)));
+            return [key, resultToUserFriendlyJson(decodedValue)];
+          }),
+        );
+      }
+    }
+    if (tx.data?.calldata) {
+      tx.data.calldata = {
+        base64: tx.data.calldata as string,
+        ...calldataToUserFriendlyJson(b64ToArray(tx.data.calldata as string)),
+      };
+    }
+  } catch (e) {
+    console.error("Error in _decodeLocalnetTransaction:", e);
+  }
+  return tx;
+};

package/src/types/accounts.ts

@@ -1,2 +1 @@
-export type {Account} from "viem";
-export type Address = `0x${string}` & {length: 42};
+export type {Account, Address} from "viem";

package/src/types/chains.ts

@@ -1,8 +1,14 @@
 import {Chain} from "viem";
+import {Address} from "./accounts";
 
-export type SimulatorChain = Chain & {
+export type GenLayerChain = Chain & {
   consensusMainContract: {
-    address: string;
+    address: Address;
+    abi: any[];
+    bytecode: string;
+  } | null;
+  consensusDataContract: {
+    address: Address;
     abi: any[];
     bytecode: string;
   } | null;

package/src/types/clients.ts

@@ -1,6 +1,6 @@
 import {Transport, Client, PublicActions, WalletActions} from "viem";
 import {GenLayerTransaction, TransactionHash, TransactionStatus} from "./transactions";
-import {SimulatorChain} from "./chains";
+import {GenLayerChain} from "./chains";
 import {Address, Account} from "./accounts";
 import {CalldataEncodable} from "./calldata";
 import {ContractSchema} from "./contracts";
@@ -9,31 +9,32 @@ import {SnapSource} from "@/types/snapSource";
 import {MetaMaskClientResult} from "@/types/metamaskClientResult";
 
 export type GenLayerMethod =
-  | {method: "sim_fundAccount"; params: [address: string, amount: number]}
+  | {method: "sim_fundAccount"; params: [address: Address, amount: number]}
   | {method: "eth_getTransactionByHash"; params: [hash: TransactionHash]}
   | {method: "eth_call"; params: [requestParams: any, blockNumberOrHash: string]}
   | {method: "eth_sendRawTransaction"; params: [signedTransaction: string]}
-  | {method: "gen_getContractSchema"; params: [address: string]}
+  | {method: "gen_getContractSchema"; params: [address: Address]}
   | {method: "gen_getContractSchemaForCode"; params: [contractCode: string]}
-  | {method: "sim_getTransactionsForAddress"; params: [address: string, filter?: "all" | "from" | "to"]}
-  | {method: "eth_getTransactionCount"; params: [address: string, block: string]};
+  | {method: "sim_getTransactionsForAddress"; params: [address: Address, filter?: "all" | "from" | "to"]}
+  | {method: "eth_getTransactionCount"; params: [address: Address, block: string]}
+  | {method: "gen_call"; params: [requestParams: any]};
 
 /*
-  Take all the properties from PublicActions<Transport, TSimulatorChain>
+  Take all the properties from PublicActions<Transport, TGenLayerChain>
   Remove the transport, readContract, and getTransaction properties
   The resulting type will have everything from PublicActions EXCEPT those
   two properties which are added later
 */
-export type GenLayerClient<TSimulatorChain extends SimulatorChain> = Omit<
-  Client<Transport, TSimulatorChain>,
+export type GenLayerClient<TGenLayerChain extends GenLayerChain> = Omit<
+  Client<Transport, TGenLayerChain>,
   "transport" | "getTransaction" | "readContract"
 > &
-  Omit<WalletActions<TSimulatorChain>, "deployContract" | "writeContract"> &
+  Omit<WalletActions<TGenLayerChain>, "deployContract" | "writeContract"> &
   Omit<
-    PublicActions<Transport, TSimulatorChain>,
+    PublicActions<Transport, TGenLayerChain>,
     "readContract" | "getTransaction" | "waitForTransactionReceipt"
   > & {
-    request: Client<Transport, TSimulatorChain>["request"] & {
+    request: Client<Transport, TGenLayerChain>["request"] & {
       <TMethod extends GenLayerMethod>(
         args: Extract<GenLayerMethod, {method: TMethod["method"]}>,
       ): Promise<unknown>;
@@ -66,14 +67,14 @@ export type GenLayerClient<TSimulatorChain extends SimulatorChain> = Omit<
       consensusMaxRotations?: number;
     }) => Promise<`0x${string}`>;
     getTransaction: (args: {hash: TransactionHash}) => Promise<GenLayerTransaction>;
-    getCurrentNonce: (args: {address: string}) => Promise<number>;
+    getCurrentNonce: (args: {address: Address}) => Promise<number>;
     waitForTransactionReceipt: (args: {
       hash: TransactionHash;
       status?: TransactionStatus;
       interval?: number;
       retries?: number;
     }) => Promise<GenLayerTransaction>;
-    getContractSchema: (address: string) => Promise<ContractSchema>;
+    getContractSchema: (address: Address) => Promise<ContractSchema>;
     getContractSchemaForCode: (contractCode: string | Uint8Array) => Promise<ContractSchema>;
     initializeConsensusSmartContract: (forceReset?: boolean) => Promise<void>;
     connect: (network?: Network, snapSource?: SnapSource) => Promise<void>;

package/src/types/transactions.ts

@@ -1,22 +1,226 @@
-export type TransactionHash = `0x${string}` & {length: 66};
+import {Hex} from "viem";
+import {Address} from "./accounts";
+
+export type Hash = `0x${string}` & {length: 66};
+export type TransactionHash = Hash;
 
 export enum TransactionStatus {
+  UNINITIALIZED = "UNINITIALIZED",
   PENDING = "PENDING",
-  CANCELED = "CANCELED",
   PROPOSING = "PROPOSING",
   COMMITTING = "COMMITTING",
   REVEALING = "REVEALING",
   ACCEPTED = "ACCEPTED",
-  FINALIZED = "FINALIZED",
   UNDETERMINED = "UNDETERMINED",
+  FINALIZED = "FINALIZED",
+  CANCELED = "CANCELED",
+  APPEAL_REVEALING = "APPEAL_REVEALING",
+  APPEAL_COMMITTING = "APPEAL_COMMITTING",
+  READY_TO_FINALIZE = "READY_TO_FINALIZE",
+  VALIDATORS_TIMEOUT = "VALIDATORS_TIMEOUT",
+  LEADER_TIMEOUT = "LEADER_TIMEOUT",
+}
+
+export enum TransactionResult {
+  SUCCESS = "SUCCESS",
+  FAILURE = "FAILURE",
 }
 
+export enum TransactionResult {
+  IDLE = "IDLE",
+  AGREE = "AGREE",
+  DISAGREE = "DISAGREE",
+  TIMEOUT = "TIMEOUT",
+  DETERMINISTIC_VIOLATION = "DETERMINISTIC_VIOLATION",
+  NO_MAJORITY = "NO_MAJORITY",
+  MAJORITY_AGREE = "MAJORITY_AGREE",
+  MAJORITY_DISAGREE = "MAJORITY_DISAGREE",
+}
+
+export const transactionsStatusNumberToName = {
+  "0": TransactionStatus.UNINITIALIZED,
+  "1": TransactionStatus.PENDING,
+  "2": TransactionStatus.PROPOSING,
+  "3": TransactionStatus.COMMITTING,
+  "4": TransactionStatus.REVEALING,
+  "5": TransactionStatus.ACCEPTED,
+  "6": TransactionStatus.UNDETERMINED,
+  "7": TransactionStatus.FINALIZED,
+  "8": TransactionStatus.CANCELED,
+  "9": TransactionStatus.APPEAL_REVEALING,
+  "10": TransactionStatus.APPEAL_COMMITTING,
+  "11": TransactionStatus.READY_TO_FINALIZE,
+  "12": TransactionStatus.VALIDATORS_TIMEOUT,
+  "13": TransactionStatus.LEADER_TIMEOUT,
+};
+
+export const transactionsStatusNameToNumber = {
+  [TransactionStatus.UNINITIALIZED]: "0",
+  [TransactionStatus.PENDING]: "1",
+  [TransactionStatus.PROPOSING]: "2",
+  [TransactionStatus.COMMITTING]: "3",
+  [TransactionStatus.REVEALING]: "4",
+  [TransactionStatus.ACCEPTED]: "5",
+  [TransactionStatus.UNDETERMINED]: "6",
+  [TransactionStatus.FINALIZED]: "7",
+  [TransactionStatus.CANCELED]: "8",
+  [TransactionStatus.APPEAL_REVEALING]: "9",
+  [TransactionStatus.APPEAL_COMMITTING]: "10",
+  [TransactionStatus.READY_TO_FINALIZE]: "11",
+  [TransactionStatus.VALIDATORS_TIMEOUT]: "12",
+  [TransactionStatus.LEADER_TIMEOUT]: "13",
+};
+
+export const transactionResultNumberToName = {
+  "0": TransactionResult.IDLE,
+  "1": TransactionResult.AGREE,
+  "2": TransactionResult.DISAGREE,
+  "3": TransactionResult.TIMEOUT,
+  "4": TransactionResult.DETERMINISTIC_VIOLATION,
+  "5": TransactionResult.NO_MAJORITY,
+  "6": TransactionResult.MAJORITY_AGREE,
+  "7": TransactionResult.MAJORITY_DISAGREE,
+};
+
+export const TransactionResultNameToNumber = {
+  [TransactionResult.IDLE]: "0",
+  [TransactionResult.AGREE]: "1",
+  [TransactionResult.DISAGREE]: "2",
+  [TransactionResult.TIMEOUT]: "3",
+  [TransactionResult.DETERMINISTIC_VIOLATION]: "4",
+  [TransactionResult.NO_MAJORITY]: "5",
+  [TransactionResult.MAJORITY_AGREE]: "6",
+  [TransactionResult.MAJORITY_DISAGREE]: "7",
+};
+
+export enum VoteType {
+  NOT_VOTED = "NOT_VOTED",
+  AGREE = "AGREE",
+  DISAGREE = "DISAGREE",
+  TIMEOUT = "TIMEOUT",
+  DETERMINISTIC_VIOLATION = "DETERMINISTIC_VIOLATION",
+}
+
+export const voteTypeNumberToName = {
+  "0": VoteType.NOT_VOTED,
+  "1": VoteType.AGREE,
+  "2": VoteType.DISAGREE,
+  "3": VoteType.TIMEOUT,
+  "4": VoteType.DETERMINISTIC_VIOLATION,
+};
+
+export const voteTypeNameToNumber = {
+  [VoteType.NOT_VOTED]: "0",
+  [VoteType.AGREE]: "1",
+  [VoteType.DISAGREE]: "2",
+  [VoteType.TIMEOUT]: "3",
+  [VoteType.DETERMINISTIC_VIOLATION]: "4",
+};
+
+export type TransactionType = "deploy" | "call";
+
+export type DecodedDeployData = {
+  code?: Hex;
+  constructorArgs?: any; // Type this more strictly if possible
+  leaderOnly?: boolean;
+  type?: TransactionType;
+  contractAddress?: Address;
+};
+
+export type DecodedCallData = {
+  callData?: any; // Type this more strictly if possible
+  leaderOnly?: boolean;
+  type: TransactionType;
+};
+
+// TODO: make localnet compatible with testnet and unify the types
 export type GenLayerTransaction = {
-  hash: TransactionHash;
-  status: TransactionStatus;
-  from_address?: string;
-  to_address?: string;
+  // currentTimestamp: testnet
+  currentTimestamp?: string;
+
+  // from_address: localnet // sender: testnet
+  from_address?: Address;
+  sender?: Address;
+
+  // to_address: localnet // recipient: testnet
+  to_address?: Address;
+  recipient?: Address;
+
+  // numOfInitialValidators: testnet
+  numOfInitialValidators?: string;
+
+  // txSlot: testnet
+  txSlot?: string;
+
+  // createdTimestamp: testnet
+  createdTimestamp?: string;
+
+  // lastVoteTimestamp: testnet
+  lastVoteTimestamp?: string;
+
+  // randomSeed: testnet
+  randomSeed?: Hash;
+
+  // result: testnet
+  result?: number;
+  resultName?: TransactionResult;
+
+  // data: localnet // txData: testnet
   data?: Record<string, unknown>;
+  txData?: Hex;
+  txDataDecoded?: DecodedDeployData | DecodedCallData;
+  // txReceipt: testnet
+  txReceipt?: Hash;
+
+  // messages: testnet
+  messages?: unknown[];
+
+  // queueType: testnet
+  queueType?: number;
+
+  // queuePosition: testnet
+  queuePosition?: string;
+
+  // activator: testnet
+  activator?: Address;
+
+  // lastLeader: testnet
+  lastLeader?: Address;
+
+  // status: localnet: TransactionStatus // status: testnet: number
+  status?: TransactionStatus | number;
+  statusName?: TransactionStatus;
+
+  // hash: localnet // txId: testnet// hash: localnet // txId: testnet
+  hash?: TransactionHash;
+  txId?: TransactionHash;
+
+  // readStateBlockRange: testnet
+  readStateBlockRange?: {
+    activationBlock: string;
+    processingBlock: string;
+    proposalBlock: string;
+  };
+
+  // numOfRounds: testnet
+  numOfRounds?: string;
+
+  // lastRound: testnet
+  lastRound?: {
+    round: string;
+    leaderIndex: string;
+    votesCommitted: string;
+    votesRevealed: string;
+    appealBond: string;
+    rotationsLeft: string;
+    result: number;
+    roundValidators: Address[];
+    validatorVotesHash: Hash[];
+    validatorVotes: number[];
+    validatorVotesName: VoteType[];
+  };
+
+  // consensus_data: localnet // leader_receipt: testnet
   consensus_data?: {
     final: boolean;
     leader_receipt?: {
@@ -31,6 +235,7 @@ export type GenLayerTransaction = {
       node_config: Record<string, unknown>;
       pending_transactions: unknown[];
       vote: string;
+      result: string;
     };
     validators?: Record<string, unknown>[];
     votes?: Record<string, string>;
@@ -45,4 +250,41 @@ export type GenLayerTransaction = {
   v?: number;
 };
 
-export type TransactionDataElement = string | number | bigint | boolean | Uint8Array;
+export type GenLayerRawTransaction = {
+  currentTimestamp: bigint;
+  sender: Address;
+  recipient: Address;
+  numOfInitialValidators: bigint;
+  txSlot: bigint;
+  createdTimestamp: bigint;
+  lastVoteTimestamp: bigint;
+  randomSeed: Hash;
+  result: number;
+  txData: Hex | undefined | null;
+  txReceipt: Hash;
+  messages: unknown[];
+  queueType: number;
+  queuePosition: bigint;
+  activator: Address;
+  lastLeader: Address;
+  status: number;
+  txId: Hash;
+  readStateBlockRange: {
+    activationBlock: bigint;
+    processingBlock: bigint;
+    proposalBlock: bigint;
+  };
+  numOfRounds: bigint;
+  lastRound: {
+    round: bigint;
+    leaderIndex: bigint;
+    votesCommitted: bigint;
+    votesRevealed: bigint;
+    appealBond: bigint;
+    rotationsLeft: bigint;
+    result: number;
+    roundValidators: Address[];
+    validatorVotesHash: Hash[];
+    validatorVotes: number[];
+  };
+};

package/src/utils/jsonifier.ts

@@ -0,0 +1,47 @@
+import {calldata} from "@/abi";
+
+
+export function b64ToArray(b64: string): Uint8Array {
+  return Uint8Array.from(atob(b64 as string), (c) => c.charCodeAt(0));
+}
+
+export function calldataToUserFriendlyJson(cd: Uint8Array): any {
+  return {
+    raw: Array.from(cd),
+    readable: calldata.toString(calldata.decode(cd)),
+  };
+}
+
+const RESULT_CODES = new Map([
+  [0, 'return'],
+  [1, 'rollback'],
+  [2, 'contract_error'],
+  [3, 'error'],
+  [4, 'none'],
+  [5, 'no_leaders'],
+]);
+
+export function resultToUserFriendlyJson(cd64: string): any {
+  const raw = b64ToArray(cd64);
+
+  const code = RESULT_CODES.get(raw[0]);
+  let status: string;
+  let payload: string | null = null;
+
+  if (code === undefined) {
+    status = '<unknown>';
+  } else {
+    status = code;
+    if ([1, 2].includes(raw[0])) {
+      payload = new TextDecoder('utf-8').decode(raw.slice(1));
+    } else if (raw[0] == 0) {
+      payload = calldataToUserFriendlyJson(raw.slice(1));
+    }
+  }
+
+  return {
+    raw: cd64,
+    status,
+    payload,
+  };
+}

package/src/wallet/actions.ts

@@ -1,8 +1,8 @@
-import { connect } from "./connect";
-import {GenLayerClient, SimulatorChain, Network, SnapSource} from "@/types";
-import { metamaskClient } from "@/wallet/metamaskClient";
+import {connect} from "./connect";
+import {GenLayerClient, GenLayerChain, Network, SnapSource} from "@/types";
+import {metamaskClient} from "@/wallet/metamaskClient";
 
-export function walletActions(client: GenLayerClient<SimulatorChain>) {
+export function walletActions(client: GenLayerClient<GenLayerChain>) {
   return {
     connect: (network: Network, snapSource: SnapSource) => connect(client, network, snapSource),
     metamaskClient: (snapSource: SnapSource = "npm") => metamaskClient(snapSource),