genlayer-js 0.18.11 → 0.18.12

package/src/staking/utils.ts

@@ -1,22 +0,0 @@
-import {parseEther, formatEther} from "viem";
-
-/**
- * Parse staking amount. Use "gen" suffix for GEN tokens (e.g. "42gen"),
- * otherwise value is treated as wei (e.g. "42000000000000000000" = 42 GEN).
- */
-export function parseStakingAmount(amount: string | bigint): bigint {
-  if (typeof amount === "bigint") return amount;
-  const trimmed = amount.trim();
-  const lower = trimmed.toLowerCase();
-  if (lower.endsWith("gen")) {
-    return parseEther(lower.slice(0, -3).trim());
-  }
-  return BigInt(trimmed);
-}
-
-/**
- * Format bigint amount to human-readable GEN string.
- */
-export function formatStakingAmount(amount: bigint): string {
-  return `${formatEther(amount)} GEN`;
-}

package/src/transactions/ITransactionActions.ts

@@ -1,15 +0,0 @@
-import {TransactionHash, TransactionStatus, GenLayerTransaction} from "@/types";
-
-export type ITransactionActions = {
-  waitForTransactionReceipt: ({
-    hash,
-    status,
-    interval,
-    retries,
-  }: {
-    hash: TransactionHash;
-    status: TransactionStatus;
-    interval?: number;
-    retries?: number;
-  }) => Promise<GenLayerTransaction>;
-};

package/src/transactions/actions.ts

@@ -1,113 +0,0 @@
-import {GenLayerClient} from "../types/clients";
-import {
-  TransactionHash,
-  TransactionStatus,
-  GenLayerTransaction,
-  GenLayerRawTransaction,
-  transactionsStatusNameToNumber,
-  isDecidedState,
-} from "../types/transactions";
-import {transactionsConfig} from "../config/transactions";
-import {sleep} from "../utils/async";
-import {GenLayerChain} from "@/types";
-import {Abi, PublicClient, Address} from "viem";
-import {localnet} from "@/chains/localnet";
-import {decodeLocalnetTransaction, decodeTransaction, simplifyTransactionReceipt} from "./decoders";
-
-export const receiptActions = (client: GenLayerClient<GenLayerChain>, publicClient: PublicClient) => ({
-  waitForTransactionReceipt: async ({
-    hash,
-    status = TransactionStatus.ACCEPTED,
-    interval = transactionsConfig.waitInterval,
-    retries = transactionsConfig.retries,
-    fullTransaction = false,
-  }: {
-    hash: TransactionHash;
-    status: TransactionStatus;
-    interval?: number;
-    retries?: number;
-    fullTransaction?: boolean;
-  }): Promise<GenLayerTransaction> => {
-    const transaction = await client.getTransaction({
-      hash,
-    });
-
-    if (!transaction) {
-      throw new Error("Transaction not found");
-    }
-    const transactionStatusString = String(transaction.status);
-    const requestedStatus = transactionsStatusNameToNumber[status];
-    if (
-      transactionStatusString === requestedStatus ||
-      (status === TransactionStatus.ACCEPTED && isDecidedState(transactionStatusString))
-    ) {
-      let finalTransaction = transaction;
-      if (client.chain.id === localnet.id) {
-        finalTransaction = decodeLocalnetTransaction(transaction as unknown as GenLayerTransaction);
-      }
-      if (!fullTransaction) {
-        return simplifyTransactionReceipt(finalTransaction as GenLayerTransaction);
-      }
-      return finalTransaction;
-    }
-
-    if (retries === 0) {
-      throw new Error("Transaction status is not " + status);
-    }
-
-    await sleep(interval);
-    return receiptActions(client, publicClient).waitForTransactionReceipt({
-      hash,
-      status,
-      interval,
-      retries: retries - 1,
-      fullTransaction,
-    });
-  },
-});
-
-export const transactionActions = (client: GenLayerClient<GenLayerChain>, publicClient: PublicClient) => ({
-  getTransaction: async ({hash}: {hash: TransactionHash}): Promise<GenLayerTransaction> => {
-    if (client.chain.isStudio) {
-      const transaction = await client.getTransaction({hash});
-      const localnetStatus =
-        (transaction.status as string) === "ACTIVATED" ? TransactionStatus.PENDING : transaction.status;
-
-      transaction.status = Number(transactionsStatusNameToNumber[localnetStatus as TransactionStatus]);
-      transaction.statusName = localnetStatus as TransactionStatus;
-      return decodeLocalnetTransaction(transaction as unknown as 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);
-  },
-  estimateTransactionGas: async (transactionParams: {
-    from?: Address;
-    to: Address;
-    data?: `0x${string}`;
-    value?: bigint;
-  }): Promise<bigint> => {
-    const formattedParams = {
-      from: transactionParams.from || client.account?.address,
-      to: transactionParams.to,
-      data: transactionParams.data || "0x",
-      value: transactionParams.value
-        ? (`0x${transactionParams.value.toString(16)}` as `0x${string}`)
-        : ("0x0" as `0x${string}`),
-    };
-
-    const gasHex = (await client.request({
-      method: "eth_estimateGas",
-      params: [formattedParams],
-    })) as string;
-
-    return BigInt(gasHex);
-  },
-});

package/src/transactions/decoders.ts

@@ -1,275 +0,0 @@
-import {GenLayerTransaction, GenLayerRawTransaction, DecodedCallData, DecodedDeployData,transactionsStatusNumberToName, transactionResultNumberToName, voteTypeNumberToName, VoteType} from "../types/transactions";
-import {b64ToArray, calldataToUserFriendlyJson, resultToUserFriendlyJson} from "../utils/jsonifier";
-import {fromRlp, fromHex, Hex, Address} from "viem";
-import * as calldataAbi from "../abi/calldata";
-
-// Fields to remove from simplified transaction receipts
-const FIELDS_TO_REMOVE = [
-  "raw", "contract_state", "base64", "consensus_history", "tx_data",
-  "eq_blocks_outputs", "r", "s", "v", "created_timestamp",
-  "current_timestamp", "tx_execution_hash", "random_seed", "states",
-  "contract_code", "appeal_failed", "appeal_leader_timeout",
-  "appeal_processing_time", "appeal_undetermined", "appealed",
-  "timestamp_appeal", "config_rotation_rounds", "rotation_count",
-  "queue_position", "queue_type", "leader_timeout_validators",
-  "triggered_by", "num_of_initial_validators",
-  "timestamp_awaiting_finalization", "last_vote_timestamp",
-  "read_state_block_range", "tx_slot", "blockHash", "blockNumber",
-  "to", "transactionIndex"
-];
-
-// Field name mappings for cross-language compatibility with genlayer-py
-const FIELD_NAME_MAPPINGS: Record<string, string> = {
-  statusName: "status_name",
-  typeHex: "type"
-};
-
-export 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;
-  }
-};
-
-export 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;
-};
-
-export const simplifyTransactionReceipt = (tx: GenLayerTransaction): GenLayerTransaction => {
-  /**
-   * Simplify transaction receipt by removing non-essential fields while preserving functionality.
-   *
-   * Removes: Binary data, internal timestamps, appeal fields, processing details, historical data
-   * Preserves: Transaction IDs, status, execution results, node configs, readable data
-   */
-  const simplifyObject = (obj: any, path = ""): any => {
-    if (obj === null || obj === undefined) return obj;
-    
-    if (Array.isArray(obj)) {
-      return obj.map(item => simplifyObject(item, path)).filter(item => item !== undefined);
-    }
-    
-    if (typeof obj === "object") {
-      const result: any = {};
-      
-      for (const [key, value] of Object.entries(obj)) {
-        const currentPath = path ? `${path}.${key}` : key;
-        
-        // Always remove these fields
-        if (FIELDS_TO_REMOVE.includes(key)) {
-          continue;
-        }
-        
-        // Remove node_config only from top level (keep it in consensus_data)
-        if (key === "node_config" && !path.includes("consensus_data")) {
-          continue;
-        }
-        
-        // Special handling for consensus_data - keep execution results and votes
-        if (key === "consensus_data" && typeof value === "object" && value !== null) {
-          const simplifiedConsensus: any = {};
-          
-          // Keep votes
-          if ("votes" in value) {
-            simplifiedConsensus.votes = value.votes;
-          }
-          
-          // Process leader_receipt to keep only essential fields
-          if ("leader_receipt" in value && Array.isArray(value.leader_receipt)) {
-            simplifiedConsensus.leader_receipt = value.leader_receipt.map((receipt: any) => {
-              const simplifiedReceipt: any = {};
-              
-              // Keep essential execution info
-              ["execution_result", "genvm_result", "mode", "vote", "node_config"].forEach(field => {
-                if (field in receipt) {
-                  simplifiedReceipt[field] = receipt[field];
-                }
-              });
-              
-              // Keep readable calldata
-              if (receipt.calldata && typeof receipt.calldata === "object" && "readable" in receipt.calldata) {
-                simplifiedReceipt.calldata = { readable: receipt.calldata.readable };
-              }
-              
-              // Keep readable outputs
-              if (receipt.eq_outputs) {
-                simplifiedReceipt.eq_outputs = simplifyObject(receipt.eq_outputs, currentPath);
-              }
-              if (receipt.result) {
-                simplifiedReceipt.result = simplifyObject(receipt.result, currentPath);
-              }
-              
-              return simplifiedReceipt;
-            });
-          }
-          
-          // Process validators to keep execution results
-          if ("validators" in value && Array.isArray(value.validators)) {
-            const simplifiedValidators = value.validators.map((validator: any) => {
-              const simplifiedValidator: any = {};
-              ["execution_result", "genvm_result", "mode", "vote", "node_config"].forEach(field => {
-                if (field in validator) {
-                  simplifiedValidator[field] = validator[field];
-                }
-              });
-              return simplifiedValidator;
-            }).filter((validator: any) => Object.keys(validator).length > 0);
-            
-            if (simplifiedValidators.length > 0) {
-              simplifiedConsensus.validators = simplifiedValidators;
-            }
-          }
-          
-          result[key] = simplifiedConsensus;
-          continue;
-        }
-        
-        const simplifiedValue = simplifyObject(value, currentPath);
-        // Include the value if it's not undefined and not an empty object
-        // Special case: include numeric 0 values (like value: 0)
-        const shouldInclude = simplifiedValue !== undefined && 
-          !(typeof simplifiedValue === "object" && simplifiedValue !== null && Object.keys(simplifiedValue).length === 0);
-        
-        if (shouldInclude || simplifiedValue === 0) {
-          // Map field names for cross-language compatibility
-          const mappedKey = FIELD_NAME_MAPPINGS[key] || key;
-          result[mappedKey] = simplifiedValue;
-        }
-      }
-      
-      return result;
-    }
-    
-    return obj;
-  };
-  
-  return simplifyObject({...tx});
-};
-
-export const decodeLocalnetTransaction = (tx: GenLayerTransaction): GenLayerTransaction => {
-  if (!tx.data) return tx;
-  try {
-    const leaderReceipt = tx.consensus_data?.leader_receipt;
-    if (leaderReceipt) {
-      const receipts = Array.isArray(leaderReceipt) ? leaderReceipt : [leaderReceipt];
-      receipts.forEach((receipt) => {
-        if (receipt.result && typeof receipt.result === "string") {
-          receipt.result = resultToUserFriendlyJson(receipt.result);
-        }
-        if (receipt.calldata && typeof receipt.calldata === "string") {
-          receipt.calldata = {
-            base64: receipt.calldata as string,
-            ...calldataToUserFriendlyJson(b64ToArray(receipt.calldata as string)),
-          };
-        }
-        if (receipt.eq_outputs) {
-          const decodedOutputs: any = {};
-          for (const [key, value] of Object.entries(receipt.eq_outputs)) {
-            if (typeof value === "object" && value !== null) {
-              decodedOutputs[key] = value;
-            } else {
-              try {
-                decodedOutputs[key] = resultToUserFriendlyJson(value as string);
-              } catch (e) {
-                console.warn(`Error decoding eq_output ${key}: ${e}`);
-                decodedOutputs[key] = value;
-              }
-            }
-          }
-          receipt.eq_outputs = decodedOutputs;
-        }
-      });
-    }
-    if (tx.data?.calldata && typeof tx.data.calldata === "string") {
-      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 +0,0 @@
-export type {Account, Address} from "viem";

package/src/types/calldata.ts

@@ -1,31 +0,0 @@
-export class CalldataAddress {
-  bytes: Uint8Array;
-
-  constructor(addr: Uint8Array) {
-    if (addr.length != 20) {
-      throw new Error(`invalid address length ${addr}`);
-    }
-
-    this.bytes = addr;
-  }
-}
-
-export type CalldataEncodable =
-  | null
-  | boolean
-  | CalldataAddress
-  | number
-  | bigint
-  | string
-  | Uint8Array /// bytes
-  | Array<CalldataEncodable>
-  | Map<string, CalldataEncodable>
-  | {[key: string]: CalldataEncodable}; /// also a "map"
-
-export type MethodDescription = {
-  method: string;
-
-  args: Array<CalldataEncodable>;
-};
-
-export type TransactionDataElement = string | number | bigint | boolean | Uint8Array;

package/src/types/chains.ts

@@ -1,22 +0,0 @@
-import {Chain} from "viem";
-import {Address} from "./accounts";
-
-export type GenLayerChain = Chain & {
-  isStudio: boolean;
-  consensusMainContract: {
-    address: Address;
-    abi: readonly unknown[];
-    bytecode: string;
-  } | null;
-  consensusDataContract: {
-    address: Address;
-    abi: readonly unknown[];
-    bytecode: string;
-  } | null;
-  stakingContract: {
-    address: Address;
-    abi: readonly unknown[];
-  } | null;
-  defaultNumberOfInitialValidators: number;
-  defaultConsensusMaxRotations: number;
-};

package/src/types/clients.ts

@@ -1,106 +0,0 @@
-import {Transport, Client, PublicActions, WalletActions} from "viem";
-import {GenLayerTransaction, TransactionHash, TransactionStatus, TransactionHashVariant} from "./transactions";
-import {GenLayerChain} from "./chains";
-import {Address, Account} from "./accounts";
-import {CalldataEncodable} from "./calldata";
-import {ContractSchema} from "./contracts";
-import {Network} from "./network";
-import {SnapSource} from "@/types/snapSource";
-import {MetaMaskClientResult} from "@/types/metamaskClientResult";
-import {StakingActions} from "./staking";
-
-export type GenLayerMethod =
-  | {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: Address]}
-  | {method: "gen_getContractSchemaForCode"; params: [contractCode: string]}
-  | {method: "gen_getContractCode"; params: [address: Address]}
-  | {method: "sim_getTransactionsForAddress"; params: [address: Address, filter?: "all" | "from" | "to"]}
-  | {method: "eth_getTransactionCount"; params: [address: Address, block: string]}
-  | {method: "eth_estimateGas"; params: [transactionParams: any]}
-  | {method: "gen_call"; params: [requestParams: any]};
-
-/*
-  Take all the properties from Client<Transport, TGenLayerChain>
-  Remove getTransaction and readContract because they are redefined with custom implementations.
-  Keep transport as it's needed for viem contract interactions (e.g., staking).
-*/
-export type GenLayerClient<TGenLayerChain extends GenLayerChain> = Omit<
-  Client<Transport, TGenLayerChain>,
-  "getTransaction" | "readContract"
-> &
-  Omit<WalletActions<TGenLayerChain>, "deployContract" | "writeContract"> &
-  Omit<
-    PublicActions<Transport, TGenLayerChain>,
-    "readContract" | "getTransaction" | "waitForTransactionReceipt"
-  > & {
-    request: Client<Transport, TGenLayerChain>["request"] & {
-      <TMethod extends GenLayerMethod>(
-        args: Extract<GenLayerMethod, {method: TMethod["method"]}>,
-      ): Promise<unknown>;
-    };
-    readContract: <RawReturn extends boolean | undefined>(args: {
-      account?: Account;
-      address: Address;
-      functionName: string;
-      args?: CalldataEncodable[];
-      kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
-      rawReturn?: RawReturn;
-      jsonSafeReturn?: boolean;
-      transactionHashVariant?: TransactionHashVariant;
-    }) => Promise<RawReturn extends true ? `0x${string}` : CalldataEncodable>;
-    writeContract: (args: {
-      account?: Account;
-      address: Address;
-      functionName: string;
-      args?: CalldataEncodable[];
-      kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
-      value: bigint;
-      leaderOnly?: boolean;
-      consensusMaxRotations?: number;
-    }) => Promise<any>;
-    simulateWriteContract: <RawReturn extends boolean | undefined>(args: {
-      account?: Account;
-      address: Address;
-      functionName: string;
-      args?: CalldataEncodable[];
-      kwargs?: Map<string, CalldataEncodable> | { [key: string]: CalldataEncodable };
-      rawReturn?: RawReturn;
-      leaderOnly?: boolean;
-      transactionHashVariant?: TransactionHashVariant;
-    }) => Promise<RawReturn extends true ? `0x${string}` : CalldataEncodable>;
-    deployContract: (args: {
-      account?: Account;
-      code: string | Uint8Array;
-      args?: CalldataEncodable[];
-      kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
-      leaderOnly?: boolean;
-      consensusMaxRotations?: number;
-    }) => Promise<`0x${string}`>;
-    getTransaction: (args: {hash: TransactionHash}) => Promise<GenLayerTransaction>;
-    getCurrentNonce: (args: {address: Address}) => Promise<number>;
-    estimateTransactionGas: (transactionParams: {
-      from?: Address;
-      to: Address;
-      data?: `0x${string}`;
-      value?: bigint;
-    }) => Promise<bigint>;
-    waitForTransactionReceipt: (args: {
-      hash: TransactionHash;
-      status?: TransactionStatus;
-      interval?: number;
-      retries?: number;
-    }) => Promise<GenLayerTransaction>;
-    getContractSchema: (address: Address) => Promise<ContractSchema>;
-    getContractSchemaForCode: (contractCode: string | Uint8Array) => Promise<ContractSchema>;
-    getContractCode: (address: Address) => Promise<string>;
-    initializeConsensusSmartContract: (forceReset?: boolean) => Promise<void>;
-    connect: (network?: Network, snapSource?: SnapSource) => Promise<void>;
-    metamaskClient: (snapSource?: SnapSource) => Promise<MetaMaskClientResult>;
-    appealTransaction: (args: {
-      account?: Account;
-      txId: `0x${string}`;
-    }) => Promise<any>;
-  } & StakingActions;

package/src/types/contracts.ts

@@ -1,32 +0,0 @@
-export type ContractParamsArraySchemaElement = ContractParamsSchema | {$rep: ContractParamsSchema};
-
-export type ContractParamsSchema =
-  | "null"
-  | "bool"
-  | "int"
-  | "address"
-  | "string"
-  | "bytes"
-  | "any"
-  | "array"
-  | "dict"
-  | {$or: ContractParamsSchema[]}
-  | {$dict: ContractParamsSchema}
-  | {[key: string]: ContractParamsSchema}
-  | ContractParamsArraySchemaElement[];
-
-export interface ContractMethodBase {
-  params: [string, ContractParamsSchema][];
-  kwparams: {[key: string]: ContractParamsSchema};
-}
-
-export interface ContractMethod extends ContractMethodBase {
-  ret: ContractParamsSchema;
-  readonly: boolean;
-  payable?: boolean;
-}
-
-export type ContractSchema = {
-  ctor: ContractMethodBase;
-  methods: ContractMethod[];
-};

package/src/types/index.ts

@@ -1,9 +0,0 @@
-export * from "./accounts";
-export {CalldataEncodable, MethodDescription, CalldataAddress} from "./calldata";
-export * from "./chains";
-export * from "./clients";
-export * from "./contracts";
-export * from "./transactions";
-export * from "./network";
-export * from "./snapSource";
-export * from "./staking";

package/src/types/metamaskClientResult.ts

@@ -1,5 +0,0 @@
-export type MetaMaskClientResult = {
-  isFlask: boolean;
-  installedSnaps: Record<string, any>;
-  isGenLayerSnapInstalled: boolean;
-};

package/src/types/network.ts

@@ -1 +0,0 @@
-export type Network = "localnet" | "studionet" | "testnetAsimov" | "mainnet";

package/src/types/snapSource.ts

@@ -1 +0,0 @@
-export type SnapSource = 'npm' | 'local';