@chainlink/ccip-sdk 0.90.2 → 0.91.0

package/src/solana/utils.ts

@@ -1,3 +1,6 @@
+import { Buffer } from 'buffer'
+
+import { eventDiscriminator } from '@coral-xyz/anchor'
 import {
   type AddressLookupTableAccount,
   type Connection,
@@ -13,13 +16,35 @@ import {
 } from '@solana/web3.js'
 import { type BytesLike, dataLength, dataSlice, hexlify } from 'ethers'
 
-import type { Log_ } from '../types.ts'
+import type { Log_, WithLogger } from '../types.ts'
 import { getDataBytes, sleep } from '../utils.ts'
+import type { UnsignedSolanaTx, Wallet } from './types.ts'
+
+/**
+ * Generates a hex-encoded discriminator for a Solana event.
+ * @param eventName - Name of the event.
+ * @returns Hex-encoded discriminator string.
+ */
+export function hexDiscriminator(eventName: string): string {
+  return hexlify(eventDiscriminator(eventName))
+}
 
+/**
+ * Converts bytes to a Node.js Buffer.
+ * @param bytes - Bytes to convert.
+ * @returns Node.js Buffer.
+ */
 export function bytesToBuffer(bytes: BytesLike): Buffer {
   return Buffer.from(getDataBytes(bytes).buffer)
 }
 
+/**
+ * Waits for a Solana transaction to reach finalized status.
+ * @param connection - Solana connection instance.
+ * @param signature - Transaction signature to wait for.
+ * @param intervalMs - Polling interval in milliseconds.
+ * @param maxAttempts - Maximum polling attempts before timeout.
+ */
 export async function waitForFinalization(
   connection: Connection,
   signature: string,
@@ -39,6 +64,11 @@ export async function waitForFinalization(
   throw new Error(`Transaction ${signature} not finalized after timeout`)
 }
 
+/**
+ * Converts a camelCase string to snake_case.
+ * @param str - String to convert.
+ * @returns snake_case formatted string.
+ */
 export function camelToSnakeCase(str: string): string {
   return str
     .replace(/([A-Z]+)([A-Z][a-z]|$)/g, (_, p1: string, p2: string) => {
@@ -52,7 +82,10 @@ export function camelToSnakeCase(str: string): string {
     .replace(/^_/, '')
 }
 
-type ParsedLog = Pick<Log_, 'topics' | 'index' | 'address' | 'data'> & { data: string }
+type ParsedLog = Pick<Log_, 'topics' | 'index' | 'address' | 'data'> & {
+  data: string
+  level: number
+}
 
 /**
  * Utility function to parse Solana logs with proper address and topic extraction.
@@ -107,6 +140,7 @@ export function parseSolanaLogs(logs: readonly string[]): ParsedLog[] {
         index: i,
         address: currentProgram,
         data: logData,
+        level: programStack.length,
       })
     }
   }
@@ -114,6 +148,11 @@ export function parseSolanaLogs(logs: readonly string[]): ParsedLog[] {
   return results
 }
 
+/**
+ * Extracts error information from Solana transaction logs.
+ * @param logs_ - Raw log strings or parsed log objects.
+ * @returns Parsed error info with program and error details.
+ */
 export function getErrorFromLogs(
   logs_: readonly string[] | readonly Pick<Log_, 'address' | 'index' | 'data' | 'topics'>[] | null,
 ): { program: string; [k: string]: string } | undefined {
@@ -176,17 +215,23 @@ export function getErrorFromLogs(
   }
 }
 
-export async function simulateTransaction({
-  connection,
-  payerKey,
-  computeUnitsOverride,
-  ...rest
-}: {
-  connection: Connection
-  payerKey: PublicKey
-  computeUnitsOverride?: number
-  addressLookupTableAccounts?: AddressLookupTableAccount[]
-} & ({ instructions: TransactionInstruction[] } | { tx: Transaction | VersionedTransaction })) {
+/**
+ * Simulates a Solana transaction to estimate compute units.
+ * @param params - Simulation parameters including connection and payer.
+ * @returns Simulation result with estimated compute units.
+ */
+export async function simulateTransaction(
+  { connection, logger = console }: { connection: Connection } & WithLogger,
+  {
+    payerKey,
+    computeUnitsOverride,
+    ...rest
+  }: {
+    payerKey: PublicKey
+    computeUnitsOverride?: number
+    addressLookupTableAccounts?: AddressLookupTableAccount[]
+  } & ({ instructions: TransactionInstruction[] } | { tx: Transaction | VersionedTransaction }),
+) {
   // Add max compute units for simulation
   const maxComputeUnits = 1_400_000
   const recentBlockhash = '11111111111111111111111111111112'
@@ -228,7 +273,7 @@ export async function simulateTransaction({
   const result = await connection.simulateTransaction(tx, config)
 
   if (result.value.err) {
-    console.debug('Simulation results:', {
+    logger.debug('Simulation results:', {
       logs: result.value.logs,
       unitsConsumed: result.value.unitsConsumed,
       returnData: result.value.returnData,
@@ -249,24 +294,103 @@ export async function simulateTransaction({
 /**
  * Used as `provider` in anchor's `Program` constructor, to support `.view()` simulations
  * without * requiring a full AnchorProvider with wallet
- * @param connection - Connection to the Solana network
+ * @param ctx - Context object containing connection and logger
  * @param feePayer - Fee payer for the simulated transaction
  * @returns Value returned by the simulated method
  */
 export function simulationProvider(
-  connection: Connection,
+  ctx: { connection: Connection } & WithLogger,
   feePayer: PublicKey = new PublicKey('11111111111111111111111111111112'),
 ) {
   return {
-    connection,
+    connection: ctx.connection,
     wallet: {
       publicKey: feePayer,
     },
     simulate: async (tx: Transaction | VersionedTransaction, _signers?: Signer[]) =>
-      simulateTransaction({
-        connection,
+      simulateTransaction(ctx, {
         payerKey: feePayer,
         tx,
       }),
   }
 }
+
+/**
+ * Sign, simulate, send and confirm as many instructions as possible on each transaction
+ * @param ctx - Context object containing connection and logger
+ * @param wallet - Wallet to sign and pay for txs
+ * @param unsignedTx - instructions to sign and send
+ *   - instructions - Instructions to send; they may not fit all in a single transaction,
+ *       in which case they will be split into multiple transactions
+ *   - mainIndex - Index of the main instruction
+ *   - lookupTables - lookupTables to be used for main instruction
+ * @param computeUnits - max computeUnits limit to be used for main instruction
+ * @returns - signature of successful transaction including main instruction
+ */
+export async function simulateAndSendTxs(
+  ctx: { connection: Connection } & WithLogger,
+  wallet: Wallet,
+  { instructions, mainIndex, lookupTables }: Omit<UnsignedSolanaTx, 'family'>,
+  computeUnits?: number,
+): Promise<string> {
+  const { connection } = ctx
+  let mainHash: string
+  for (
+    let [start, end] = [0, instructions.length];
+    start < instructions.length;
+    [start, end] = [end, instructions.length]
+  ) {
+    let computeUnitLimit, lastErr, addressLookupTableAccounts, ixs, includesMain
+    do {
+      ixs = instructions.slice(start, end)
+      includesMain = mainIndex != null && start <= mainIndex && mainIndex < end
+      addressLookupTableAccounts = includesMain ? lookupTables : undefined
+
+      try {
+        const simulated =
+          (
+            await simulateTransaction(ctx, {
+              payerKey: wallet.publicKey,
+              instructions: ixs,
+              addressLookupTableAccounts,
+            })
+          ).unitsConsumed || 0
+
+        if (simulated <= 200000) {
+          computeUnitLimit = undefined
+        } else if (!includesMain || computeUnits == null || simulated <= computeUnits) {
+          computeUnitLimit = Math.ceil(simulated * 1.1)
+        } else {
+          throw new Error(
+            `Main simulation exceeds specified computeUnits limit. simulated=${simulated}, limit=${computeUnits}`,
+          )
+        }
+        break
+      } catch (err) {
+        lastErr = err
+        end-- // truncate until finding a slice which fits (both computeUnits and tx size limits)
+      }
+    } while (end > start)
+    if (end <= start) throw lastErr
+
+    const blockhash = await connection.getLatestBlockhash('confirmed')
+    const txMsg = new TransactionMessage({
+      payerKey: wallet.publicKey,
+      recentBlockhash: blockhash.blockhash,
+      instructions: [
+        ...(computeUnitLimit
+          ? [ComputeBudgetProgram.setComputeUnitLimit({ units: computeUnitLimit })]
+          : []),
+        ...ixs,
+      ],
+    })
+    const messageV0 = txMsg.compileToV0Message(addressLookupTableAccounts)
+    const tx = new VersionedTransaction(messageV0)
+
+    const signed = await wallet.signTransaction(tx)
+    const signature = await connection.sendTransaction(signed)
+    await connection.confirmTransaction({ signature, ...blockhash }, 'confirmed')
+    if (includesMain) mainHash = signature
+  }
+  return mainHash!
+}

package/src/sui/hasher.ts

@@ -6,6 +6,11 @@ import { type LeafHasher, LEAF_DOMAIN_SEPARATOR } from '../hasher/common.ts'
 import { type CCIPMessage, type CCIPMessage_V1_6, CCIPVersion } from '../types.ts'
 import type { CCIPMessage_V1_6_Sui } from './types.ts'
 
+/**
+ * Creates a leaf hasher for Sui CCIP messages.
+ * @param lane - Lane configuration with selectors and onRamp.
+ * @returns Leaf hasher function for the specified version.
+ */
 export function getSuiLeafHasher<V extends CCIPVersion = CCIPVersion>({
   sourceChainSelector,
   destChainSelector,
@@ -28,6 +33,12 @@ export function getSuiLeafHasher<V extends CCIPVersion = CCIPVersion>({
   }
 }
 
+/**
+ * Computes the leaf hash for a v1.6 Sui CCIP message.
+ * @param message - CCIP message to hash.
+ * @param metadataHash - Pre-computed metadata hash for the lane.
+ * @returns Keccak256 hash of the message.
+ */
 export function hashV16SuiMessage(
   message: CCIPMessage_V1_6 | CCIPMessage_V1_6_Sui,
   metadataHash: string,
@@ -76,6 +87,13 @@ export function hashV16SuiMessage(
   return keccak256(outerHash)
 }
 
+/**
+ * Computes the metadata hash for Sui CCIP lane.
+ * @param sourceChainSelector - Source chain selector.
+ * @param destChainSelector - Destination chain selector.
+ * @param onRamp - OnRamp address.
+ * @returns Keccak256 hash of the lane metadata.
+ */
 export const hashSuiMetadata = (
   sourceChainSelector: bigint,
   destChainSelector: bigint,

package/src/sui/index.ts

@@ -1,56 +1,93 @@
 import { type BytesLike, isBytesLike } from 'ethers'
+import type { PickDeep } from 'type-fest'
 
 import { AptosChain } from '../aptos/index.ts'
-import { type ChainTransaction, type LogFilter, Chain, ChainFamily } from '../chain.ts'
+import { type LogFilter, Chain } from '../chain.ts'
 import type { EVMExtraArgsV2, ExtraArgs, SVMExtraArgsV1 } from '../extra-args.ts'
+import { getSuiLeafHasher } from './hasher.ts'
 import type { LeafHasher } from '../hasher/common.ts'
 import { supportedChains } from '../supported-chains.ts'
-import type {
-  AnyMessage,
-  CCIPRequest,
-  CommitReport,
-  ExecutionReceipt,
-  ExecutionReport,
-  Lane,
-  Log_,
-  NetworkInfo,
-  OffchainTokenData,
+import {
+  type AnyMessage,
+  type CCIPRequest,
+  type ChainTransaction,
+  type CommitReport,
+  type ExecutionReceipt,
+  type ExecutionReport,
+  type Lane,
+  type Log_,
+  type NetworkInfo,
+  type OffchainTokenData,
+  type WithLogger,
+  ChainFamily,
 } from '../types.ts'
 import type { CCIPMessage_V1_6_Sui } from './types.ts'
 
+/**
+ * Sui chain implementation supporting Sui networks.
+ * Note: This implementation is currently a placeholder.
+ */
 export class SuiChain extends Chain<typeof ChainFamily.Sui> {
+  static {
+    supportedChains[ChainFamily.Sui] = SuiChain
+  }
   static readonly family = ChainFamily.Sui
   static readonly decimals = 8
 
-  readonly network: NetworkInfo<typeof ChainFamily.Sui>
-
-  constructor() {
-    super()
-    throw new Error('Not implemented')
+  /**
+   * Creates a new SuiChain instance.
+   * @param network - Sui network configuration.
+   */
+  constructor(network: NetworkInfo<typeof ChainFamily.Sui>, ctx?: WithLogger) {
+    super(network, ctx)
   }
 
-  static async fromUrl(_url: string): Promise<SuiChain> {
+  /**
+   * Creates a SuiChain instance from an RPC URL.
+   * @param _url - RPC endpoint URL.
+   * @returns A new SuiChain instance.
+   */
+  static async fromUrl(_url: string, _ctx?: WithLogger): Promise<SuiChain> {
     return Promise.reject(new Error('Not implemented'))
   }
 
-  async destroy(): Promise<void> {
-    // Nothing to cleanup for Aptos implementation
-  }
-
+  /** {@inheritDoc Chain.getBlockTimestamp} */
   async getBlockTimestamp(_version: number | 'finalized'): Promise<number> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.getTransaction} */
   async getTransaction(_hash: string | number): Promise<ChainTransaction> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.getLogs} */
   // eslint-disable-next-line require-yield
   async *getLogs(_opts: LogFilter & { versionAsHash?: boolean }) {
     await Promise.resolve()
     throw new Error('Not implemented')
   }
 
+  /** {@inheritDoc Chain.fetchRequestsInTx} */
+  override async fetchRequestsInTx(_tx: string | ChainTransaction): Promise<CCIPRequest[]> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  /** {@inheritDoc Chain.fetchAllMessagesInBatch} */
+  override async fetchAllMessagesInBatch<
+    R extends PickDeep<
+      CCIPRequest,
+      'lane' | `log.${'topics' | 'address' | 'blockNumber'}` | 'message.header.sequenceNumber'
+    >,
+  >(
+    _request: R,
+    _commit: Pick<CommitReport, 'minSeqNr' | 'maxSeqNr'>,
+    _opts?: { page?: number },
+  ): Promise<R['message'][]> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  /** {@inheritDoc Chain.typeAndVersion} */
   async typeAndVersion(
     _address: string,
   ): Promise<
@@ -60,55 +97,71 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.getRouterForOnRamp} */
   getRouterForOnRamp(_onRamp: string, _destChainSelector: bigint): Promise<string> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.getRouterForOffRamp} */
   getRouterForOffRamp(_offRamp: string, _sourceChainSelector: bigint): Promise<string> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.getNativeTokenForRouter} */
   getNativeTokenForRouter(_router: string): Promise<string> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.getOffRampsForRouter} */
   getOffRampsForRouter(_router: string, _sourceChainSelector: bigint): Promise<string[]> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.getOnRampForRouter} */
   getOnRampForRouter(_router: string, _destChainSelector: bigint): Promise<string> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.getOnRampForOffRamp} */
   async getOnRampForOffRamp(_offRamp: string, _sourceChainSelector: bigint): Promise<string> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.getCommitStoreForOffRamp} */
   getCommitStoreForOffRamp(_offRamp: string): Promise<string> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.getTokenForTokenPool} */
   async getTokenForTokenPool(_tokenPool: string): Promise<string> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.getTokenInfo} */
   async getTokenInfo(_token: string): Promise<{ symbol: string; decimals: number }> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.getTokenAdminRegistryFor} */
   getTokenAdminRegistryFor(_address: string): Promise<string> {
     return Promise.reject(new Error('Not implemented'))
   }
 
-  async getWalletAddress(_opts?: { wallet?: unknown }): Promise<string> {
-    return Promise.reject(new Error('Not implemented'))
-  }
-
   // Static methods for decoding
+  /**
+   * Decodes a CCIP message from a Sui log event.
+   * @param _log - Log event data.
+   * @returns Decoded CCIPMessage or undefined if not valid.
+   */
   static decodeMessage(_log: Log_): CCIPMessage_V1_6_Sui | undefined {
     throw new Error('Not implemented')
   }
 
+  /**
+   * Decodes extra arguments from Sui CCIP messages.
+   * @param extraArgs - Encoded extra arguments bytes.
+   * @returns Decoded extra arguments or undefined if unknown format.
+   */
   static decodeExtraArgs(
     extraArgs: BytesLike,
   ):
@@ -118,39 +171,79 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
     return AptosChain.decodeExtraArgs(extraArgs)
   }
 
+  /**
+   * Encodes extra arguments for Sui CCIP messages.
+   * @param extraArgs - Extra arguments to encode.
+   * @returns Encoded extra arguments as hex string.
+   */
   static encodeExtraArgs(extraArgs: ExtraArgs): string {
     return AptosChain.encodeExtraArgs(extraArgs)
   }
 
+  /**
+   * Decodes commit reports from a Sui log event.
+   * @param _log - Log event data.
+   * @param _lane - Lane info for filtering.
+   * @returns Array of CommitReport or undefined if not valid.
+   */
   static decodeCommits(_log: Log_, _lane?: Lane): CommitReport[] | undefined {
     throw new Error('Not implemented')
   }
 
+  /**
+   * Decodes an execution receipt from a Sui log event.
+   * @param _log - Log event data.
+   * @returns ExecutionReceipt or undefined if not valid.
+   */
   static decodeReceipt(_log: Log_): ExecutionReceipt | undefined {
     throw new Error('Not implemented')
   }
 
+  /**
+   * Converts bytes to a Sui address.
+   * @param bytes - Bytes to convert.
+   * @returns Sui address.
+   */
   static getAddress(bytes: BytesLike): string {
     return AptosChain.getAddress(bytes)
   }
 
-  static getDestLeafHasher(_lane: Lane): LeafHasher {
-    throw new Error('Not implemented')
+  /**
+   * Gets the leaf hasher for Sui destination chains.
+   * @param lane - Lane configuration.
+   * @returns Leaf hasher function.
+   */
+  static getDestLeafHasher(lane: Lane, _ctx?: WithLogger): LeafHasher {
+    return getSuiLeafHasher(lane)
   }
 
+  /** {@inheritDoc Chain.getFee} */
   async getFee(_router: string, _destChainSelector: bigint, _message: AnyMessage): Promise<bigint> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.generateUnsignedSendMessage} */
+  override generateUnsignedSendMessage(
+    _sender: string,
+    _router: string,
+    _destChainSelector: bigint,
+    _message: AnyMessage & { fee?: bigint },
+    _opts?: { approveMax?: boolean },
+  ): Promise<never> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  /** {@inheritDoc Chain.sendMessage} */
   async sendMessage(
     _router: string,
     _destChainSelector: bigint,
     _message: AnyMessage & { fee: bigint },
     _opts?: { wallet?: unknown; approveMax?: boolean },
-  ): Promise<ChainTransaction> {
+  ): Promise<CCIPRequest> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.fetchOffchainTokenData} */
   fetchOffchainTokenData(request: CCIPRequest): Promise<OffchainTokenData[]> {
     if (!('receiverObjectIds' in request.message)) {
       throw new Error('Invalid message, not v1.6 Sui')
@@ -159,6 +252,17 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
     return Promise.resolve(request.message.tokenAmounts.map(() => undefined))
   }
 
+  /** {@inheritDoc Chain.generateUnsignedExecuteReport} */
+  override generateUnsignedExecuteReport(
+    _payer: string,
+    _offRamp: string,
+    _execReport: ExecutionReport,
+    _opts: object,
+  ): Promise<never> {
+    return Promise.reject(new Error('Not implemented'))
+  }
+
+  /** {@inheritDoc Chain.executeReport} */
   async executeReport(
     _offRamp: string,
     _execReport: ExecutionReport,
@@ -167,6 +271,11 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /**
+   * Parses raw Sui data into typed structures.
+   * @param data - Raw data to parse.
+   * @returns Parsed data or undefined.
+   */
   static parse(data: unknown) {
     if (isBytesLike(data)) {
       const parsedExtraArgs = this.decodeExtraArgs(data)
@@ -174,25 +283,28 @@ export class SuiChain extends Chain<typeof ChainFamily.Sui> {
     }
   }
 
+  /** {@inheritDoc Chain.getSupportedTokens} */
   async getSupportedTokens(_address: string): Promise<string[]> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.getRegistryTokenConfig} */
   async getRegistryTokenConfig(_address: string, _tokenName: string): Promise<never> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.getTokenPoolConfigs} */
   async getTokenPoolConfigs(_tokenPool: string): Promise<never> {
     return Promise.reject(new Error('Not implemented'))
   }
 
+  /** {@inheritDoc Chain.getTokenPoolRemotes} */
   async getTokenPoolRemotes(_tokenPool: string): Promise<never> {
     return Promise.reject(new Error('Not implemented'))
   }
 
-  async listFeeTokens(_router: string): Promise<never> {
+  /** {@inheritDoc Chain.getFeeTokens} */
+  async getFeeTokens(_router: string): Promise<never> {
     return Promise.reject(new Error('Not implemented'))
   }
 }
-
-supportedChains[ChainFamily.Sui] = SuiChain

package/src/sui/types.ts

@@ -5,6 +5,7 @@ import { type SuiExtraArgsV1, SuiExtraArgsV1Tag } from '../extra-args.ts'
 import type { CCIPMessage_V1_6 } from '../types.ts'
 import { getAddressBytes, getDataBytes } from '../utils.ts'
 
+/** Sui-specific CCIP v1.6 message type with Sui extra args. */
 export type CCIPMessage_V1_6_Sui = CCIPMessage_V1_6 & SuiExtraArgsV1
 
 export const SuiExtraArgsV1Codec = bcs.struct('SuiExtraArgsV1', {
@@ -14,6 +15,11 @@ export const SuiExtraArgsV1Codec = bcs.struct('SuiExtraArgsV1', {
   receiverObjectIds: bcs.vector(bcs.vector(bcs.u8())),
 })
 
+/**
+ * Encodes Sui v1 extra arguments using BCS encoding.
+ * @param args - Sui extra arguments to encode.
+ * @returns Encoded bytes with tag prefix.
+ */
 export function encodeSuiExtraArgsV1(args: SuiExtraArgsV1): string {
   const tokenReceiver = getAddressBytes(args.tokenReceiver)
   const receiverObjectIds = args.receiverObjectIds.map((id) => getDataBytes(id))

package/src/supported-chains.ts

@@ -1,4 +1,5 @@
-import type { ChainFamily, ChainStatic } from './chain.ts'
+import type { ChainStatic } from './chain.ts'
+import type { ChainFamily } from './types.ts'
 
 // global record; can be mutated when implementing or extending a Chain family support
 export const supportedChains: Partial<{ [F in ChainFamily]: ChainStatic<F> }> = {}