genlayer-js 0.18.10 → 0.18.12

package/src/client/client.ts

@@ -1,139 +0,0 @@
-import {
-  Account,
-  createClient as createViemClient,
-  createPublicClient as createPublicViemClient,
-  publicActions,
-  custom,
-  Address,
-  walletActions,
-  Transport,
-  PublicClient,
-  Chain,
-} from "viem";
-import {accountActions} from "../accounts/actions";
-import {contractActions} from "../contracts/actions";
-import {receiptActions, transactionActions} from "../transactions/actions";
-import {walletActions as genlayerWalletActions} from "../wallet/actions";
-import {stakingActions} from "../staking/actions";
-import {GenLayerClient, GenLayerChain} from "@/types";
-import {chainActions} from "@/chains/actions";
-import {localnet} from "@/chains";
-
-// Define the configuration interface for the client
-interface ClientConfig {
-  chain?: {
-    id: number;
-    name: string;
-    rpcUrls: {default: {http: readonly string[]}};
-    nativeCurrency: {name: string; symbol: string; decimals: number};
-    blockExplorers?: {default: {name: string; url: string}};
-  };
-  endpoint?: string; // Custom RPC endpoint
-  account?: Account | Address;
-  provider?: EthereumProvider; // Custom provider for wallet framework integration
-}
-
-const getCustomTransportConfig = (config: ClientConfig, chainConfig: GenLayerChain) => {
-  const isAddress = typeof config.account !== "object";
-
-  return {
-    async request({method, params = []}: {method: string; params: any[]}) {
-      if (method.startsWith("eth_") && isAddress) {
-        const provider = config.provider || (typeof window !== "undefined" ? window.ethereum : undefined);
-        if (provider) {
-          try {
-            return await provider.request({method, params});
-          } catch (err) {
-            console.warn(`Error using provider for method ${method}:`, err);
-            throw err;
-          }
-        }
-      }
-
-      {
-        try {
-          const response = await fetch(chainConfig.rpcUrls.default.http[0], {
-            method: "POST",
-            headers: {
-              "Content-Type": "application/json",
-            },
-            body: JSON.stringify({
-              jsonrpc: "2.0",
-              id: Date.now(),
-              method,
-              params,
-            }),
-          });
-
-          const data = await response.json();
-
-          if (data.error) {
-            throw data.error
-          }
-
-          return data.result;
-        } catch (err) {
-          console.error(`Error fetching ${method} from GenLayer RPC`);
-          throw err;
-        }
-      }
-    },
-  };
-};
-
-export const createClient = (config: ClientConfig = {chain: localnet}): GenLayerClient<GenLayerChain> => {
-  const chainConfig = config.chain || localnet;
-  if (config.endpoint) {
-    chainConfig.rpcUrls.default.http = [config.endpoint];
-  }
-
-  const customTransport = custom(getCustomTransportConfig(config, chainConfig as GenLayerChain), {retryCount: 0, retryDelay: 0});
-  const publicClient = createPublicClient(chainConfig as GenLayerChain, customTransport).extend(
-    publicActions,
-  );
-
-  const baseClient = createViemClient({
-    chain: chainConfig,
-    transport: customTransport,
-    ...(config.account ? {account: config.account} : {}),
-  });
-
-  const clientWithBasicActions = baseClient
-    .extend(publicActions)
-    .extend(walletActions)
-    .extend(client => accountActions(client as unknown as GenLayerClient<GenLayerChain>));
-
-  const clientWithTransactionActions = {
-    ...clientWithBasicActions,
-    ...transactionActions(clientWithBasicActions as unknown as GenLayerClient<GenLayerChain>, publicClient),
-    ...chainActions(clientWithBasicActions as unknown as GenLayerClient<GenLayerChain>),
-    ...genlayerWalletActions(clientWithBasicActions as unknown as GenLayerClient<GenLayerChain>),
-  } as unknown as GenLayerClient<GenLayerChain>;
-
-  const clientWithAllActions = {
-    ...clientWithTransactionActions,
-    ...contractActions(clientWithTransactionActions as unknown as GenLayerClient<GenLayerChain>, publicClient),
-  } as unknown as GenLayerClient<GenLayerChain>;
-
-  const clientWithReceiptActions = {
-    ...clientWithAllActions,
-    ...receiptActions(clientWithAllActions as unknown as GenLayerClient<GenLayerChain>, publicClient),
-  } as unknown as GenLayerClient<GenLayerChain>;
-
-  const finalClient = {
-    ...clientWithReceiptActions,
-    ...stakingActions(clientWithReceiptActions as unknown as GenLayerClient<GenLayerChain>, publicClient),
-  } as unknown as GenLayerClient<GenLayerChain>;
-
-  finalClient.initializeConsensusSmartContract().catch(error => {
-    console.error("Failed to initialize consensus smart contract:", error);
-  });
-  return finalClient;
-};
-
-export const createPublicClient = (
-  chainConfig: GenLayerChain,
-  customTransport: Transport,
-): PublicClient<Transport, Chain> => {
-  return createPublicViemClient({chain: chainConfig, transport: customTransport});
-};

package/src/config/snapID.ts

@@ -1,4 +0,0 @@
-export const snapID = {
-  local: 'local:http://localhost:8081',
-  npm: 'npm:genlayer-wallet-plugin'
-}

package/src/config/transactions.ts

@@ -1,9 +0,0 @@
-type TransactionsConfig = {
-  waitInterval: number;
-  retries: number;
-};
-
-export const transactionsConfig: TransactionsConfig = {
-  waitInterval: 3000,
-  retries: 10,
-};

package/src/contracts/actions.ts

@@ -1,387 +0,0 @@
-import * as calldata from "@/abi/calldata";
-import {serialize} from "@/abi/transactions";
-import {localnet} from "@/chains/localnet";
-import {
-  Account,
-  ContractSchema,
-  GenLayerChain,
-  GenLayerClient,
-  CalldataEncodable,
-  Address,
-  TransactionHashVariant,
-} from "@/types";
-import {fromHex, toHex, zeroAddress, encodeFunctionData, PublicClient, parseEventLogs} from "viem";
-import {toJsonSafeDeep, b64ToArray} from "@/utils/jsonifier";
-
-export const contractActions = (client: GenLayerClient<GenLayerChain>, publicClient: PublicClient) => {
-  return {
-    getContractCode: async (address: Address): Promise<string> => {
-      if (client.chain.id !== localnet.id) {
-        throw new Error("Getting contract code is not supported on this network");
-      }
-      const result = (await client.request({
-        method: "gen_getContractCode",
-        params: [address],
-      })) as string;
-      const codeBytes = b64ToArray(result);
-      return new TextDecoder().decode(codeBytes);
-    },
-    getContractSchema: async (address: Address): Promise<ContractSchema> => {
-      if (client.chain.id !== localnet.id) {
-        throw new Error("Contract schema is not supported on this network");
-      }
-      const schema = (await client.request({
-        method: "gen_getContractSchema",
-        params: [address],
-      })) as string;
-      return schema as unknown as ContractSchema;
-    },
-    getContractSchemaForCode: async (contractCode: string | Uint8Array): Promise<ContractSchema> => {
-      if (client.chain.id !== localnet.id) {
-        throw new Error("Contract schema is not supported on this network");
-      }
-      const schema = (await client.request({
-        method: "gen_getContractSchemaForCode",
-        params: [toHex(contractCode)],
-      })) as string;
-      return schema as unknown as ContractSchema;
-    },
-    readContract: async <RawReturn extends boolean | undefined>(args: {
-      account?: Account;
-      address: Address;
-      functionName: string;
-      args?: CalldataEncodable[];
-      kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
-      rawReturn?: RawReturn;
-      jsonSafeReturn?: boolean;
-      leaderOnly?: boolean;
-      transactionHashVariant?: TransactionHashVariant;
-    }): Promise<RawReturn extends true ? `0x${string}` : CalldataEncodable> => {
-      const {
-        account,
-        address,
-        functionName,
-        args: callArgs,
-        kwargs,
-        jsonSafeReturn = false,
-        leaderOnly = false,
-        transactionHashVariant = TransactionHashVariant.LATEST_NONFINAL,
-      } = args;
-
-      const encodedData = [calldata.encode(calldata.makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
-      const serializedData = serialize(encodedData);
-
-      const senderAddress = account?.address ?? client.account?.address ?? zeroAddress;
-
-      const requestParams = {
-        type: "read",
-        to: address,
-        from: senderAddress,
-        data: serializedData,
-        transaction_hash_variant: transactionHashVariant,
-      };
-      const result = await client.request({
-        method: "gen_call",
-        params: [requestParams],
-      });
-      const prefixedResult = `0x${result}` as `0x${string}`;
-
-      if (args.rawReturn) {
-        return prefixedResult;
-      }
-      const resultBinary = fromHex(prefixedResult, "bytes");
-      const decoded = calldata.decode(resultBinary) as any;
-      if (!jsonSafeReturn) {
-        return decoded;
-      }
-      // If jsonSafeReturn is requested, convert to JSON-safe recursively
-      return toJsonSafeDeep(decoded) as any;
-    },
-    simulateWriteContract: async <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> => {
-      const {
-        account,
-        address,
-        functionName,
-        args: callArgs,
-        kwargs,
-        leaderOnly = false,
-        transactionHashVariant = TransactionHashVariant.LATEST_NONFINAL,
-      } = args;
-
-      const encodedData = [calldata.encode(calldata.makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
-      const serializedData = serialize(encodedData);
-
-      const senderAddress = account?.address ?? client.account?.address ?? zeroAddress;
-
-      const requestParams = {
-        type: "write",
-        to: address,
-        from: senderAddress,
-        data: serializedData,
-        transaction_hash_variant: transactionHashVariant,
-      };
-      const result = await client.request({
-        method: "gen_call",
-        params: [requestParams],
-      });
-      const prefixedResult = `0x${result}` as `0x${string}`;
-
-      if (args.rawReturn) {
-        return prefixedResult;
-      }
-      const resultBinary = fromHex(prefixedResult, "bytes");
-      return calldata.decode(resultBinary) as any;
-    },
-    writeContract: async (args: {
-      account?: Account;
-      address: Address;
-      functionName: string;
-      args?: CalldataEncodable[];
-      kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
-      value: bigint;
-      leaderOnly?: boolean;
-      consensusMaxRotations?: number;
-    }): Promise<`0x${string}`> => {
-      const {
-        account,
-        address,
-        functionName,
-        args: callArgs,
-        kwargs,
-        value = 0n,
-        leaderOnly = false,
-        consensusMaxRotations = client.chain.defaultConsensusMaxRotations,
-      } = args;
-      const data = [calldata.encode(calldata.makeCalldataObject(functionName, callArgs, kwargs)), leaderOnly];
-      const serializedData = serialize(data);
-      const senderAccount = account || client.account;
-      const encodedData = _encodeAddTransactionData({
-        client,
-        senderAccount,
-        recipient: address,
-        data: serializedData,
-        consensusMaxRotations,
-      });
-      return _sendTransaction({
-        client,
-        publicClient,
-        encodedData,
-        senderAccount,
-        value,
-      });
-    },
-    deployContract: async (args: {
-      account?: Account;
-      code: string | Uint8Array;
-      args?: CalldataEncodable[];
-      kwargs?: Map<string, CalldataEncodable> | {[key: string]: CalldataEncodable};
-      leaderOnly?: boolean;
-      consensusMaxRotations?: number;
-    }) => {
-      const {
-        account,
-        code,
-        args: constructorArgs,
-        kwargs,
-        leaderOnly = false,
-        consensusMaxRotations = client.chain.defaultConsensusMaxRotations,
-      } = args;
-      const data = [
-        code,
-        calldata.encode(calldata.makeCalldataObject(undefined, constructorArgs, kwargs)),
-        leaderOnly,
-      ];
-      const serializedData = serialize(data);
-      const senderAccount = account || client.account;
-      const encodedData = _encodeAddTransactionData({
-        client,
-        senderAccount,
-        recipient: zeroAddress,
-        data: serializedData,
-        consensusMaxRotations,
-      });
-      return _sendTransaction({
-        client,
-        publicClient,
-        encodedData,
-        senderAccount,
-      });
-    },
-    appealTransaction: async (args: {
-      account?: Account;
-      txId: `0x${string}`;
-    }) => {
-      const {account, txId} = args;
-      const senderAccount = account || client.account;
-      const encodedData = _encodeSubmitAppealData({client, txId});
-      return _sendTransaction({
-        client,
-        publicClient,
-        encodedData,
-        senderAccount,
-      });
-    },
-  };
-};
-
-const validateAccount = (Account?: Account): Account => {
-  if (!Account) {
-    throw new Error(
-      "No account set. Configure the client with an account or pass an account to this function.",
-    );
-  }
-  return Account;
-};
-
-const _encodeAddTransactionData = ({
-  client,
-  senderAccount,
-  recipient,
-  data,
-  consensusMaxRotations = client.chain.defaultConsensusMaxRotations,
-}: {
-  client: GenLayerClient<GenLayerChain>;
-  senderAccount?: Account;
-  recipient?: `0x${string}`;
-  data?: `0x${string}`;
-  consensusMaxRotations?: number;
-}): `0x${string}` => {
-  const validatedSenderAccount = validateAccount(senderAccount);
-  return encodeFunctionData({
-    abi: client.chain.consensusMainContract?.abi as any,
-    functionName: "addTransaction",
-    args: [
-      validatedSenderAccount.address,
-      recipient,
-      client.chain.defaultNumberOfInitialValidators,
-      consensusMaxRotations,
-      data,
-    ],
-  });
-};
-
-const _encodeSubmitAppealData = ({
-  client,
-  txId,
-}: {
-  client: GenLayerClient<GenLayerChain>;
-  txId: `0x${string}`;
-}): `0x${string}` => {
-  return encodeFunctionData({
-    abi: client.chain.consensusMainContract?.abi as any,
-    functionName: "submitAppeal",
-    args: [txId],
-  });
-};
-
-const _sendTransaction = async ({
-  client,
-  publicClient,
-  encodedData,
-  senderAccount,
-  value = 0n,
-}: {
-  client: GenLayerClient<GenLayerChain>;
-  publicClient: PublicClient;
-  encodedData: `0x${string}`;
-  senderAccount?: Account;
-  value?: bigint;
-}) => {
-  if (!client.chain.consensusMainContract?.address) {
-    throw new Error("Consensus main contract not initialized. Please ensure client is properly initialized.");
-  }
-
-  const validatedSenderAccount = validateAccount(senderAccount);
-  const nonce = await client.getCurrentNonce({address: validatedSenderAccount.address});
-
-  let estimatedGas: bigint;
-  try {
-    estimatedGas = await client.estimateTransactionGas({
-      from: validatedSenderAccount.address,
-      to: client.chain.consensusMainContract?.address as Address,
-      data: encodedData,
-      value: value,
-    });
-  } catch (err) {
-    console.error("Gas estimation failed, using default 200_000:", err);
-    estimatedGas = 200_000n;
-  }
-
-  // For local accounts, build transaction request directly to avoid viem's
-  // prepareTransactionRequest which calls eth_fillTransaction (unsupported by GenLayer RPC)
-  if (validatedSenderAccount?.type === "local") {
-    if (!validatedSenderAccount?.signTransaction) {
-      throw new Error("Account does not support signTransaction");
-    }
-
-    const gasPriceHex = (await client.request({
-      method: "eth_gasPrice",
-    })) as string;
-
-    const transactionRequest = {
-      account: validatedSenderAccount,
-      to: client.chain.consensusMainContract?.address as Address,
-      data: encodedData,
-      type: "legacy" as const,
-      nonce: Number(nonce),
-      value: value,
-      gas: estimatedGas,
-      gasPrice: BigInt(gasPriceHex),
-      chainId: client.chain.id,
-    };
-
-    const serializedTransaction = await validatedSenderAccount.signTransaction(transactionRequest);
-    const txHash = await client.sendRawTransaction({serializedTransaction: serializedTransaction});
-    const receipt = await publicClient.waitForTransactionReceipt({hash: txHash});
-
-    if (receipt.status === "reverted") {
-      throw new Error("Transaction reverted");
-    }
-
-    const newTxEvents = parseEventLogs({
-      abi: client.chain.consensusMainContract?.abi as any,
-      eventName: "NewTransaction",
-      logs: receipt.logs,
-    }) as unknown as {args: {txId: `0x${string}`}}[];
-
-    if (newTxEvents.length === 0) {
-      throw new Error("Transaction not processed by consensus");
-    }
-
-    return newTxEvents[0].args["txId"];
-  }
-
-  // For external wallets (e.g., MetaMask via AppKit), use prepareTransactionRequest
-  // which will route eth_* calls through the provider
-  const transactionRequest = await client.prepareTransactionRequest({
-    account: validatedSenderAccount,
-    to: client.chain.consensusMainContract?.address as Address,
-    data: encodedData,
-    type: "legacy",
-    nonce: Number(nonce),
-    value: value,
-    gas: estimatedGas,
-  });
-
-  const formattedRequest = {
-    from: transactionRequest.from,
-    to: transactionRequest.to,
-    data: encodedData,
-    value: transactionRequest.value ? `0x${transactionRequest.value.toString(16)}` : "0x0",
-    gas: transactionRequest.gas ? `0x${transactionRequest.gas.toString(16)}` : "0x5208",
-  };
-
-  return await client.request({
-    method: "eth_sendTransaction",
-    params: [formattedRequest as any],
-  });
-};

package/src/global.d.ts

@@ -1,9 +0,0 @@
-// global.d.ts
-interface EthereumProvider {
-  isMetaMask?: boolean;
-  request: (args: {method: string; params?: any}) => Promise<any>;
-}
-
-interface Window {
-  ethereum?: EthereumProvider;
-}

package/src/index.ts

@@ -1,12 +0,0 @@
-// src/index.ts
-export {createClient} from "./client/client";
-export {createAccount, generatePrivateKey} from "./accounts/account";
-export {
-  decodeInputData,
-  decodeTransaction,
-  simplifyTransactionReceipt,
-  decodeLocalnetTransaction
-} from "./transactions/decoders";
-export * as chains from "./chains";
-export * as abi from "./abi";
-export {parseStakingAmount, formatStakingAmount} from "./staking";