@chainlink/ccip-sdk 0.90.2 → 0.91.0

package/src/solana/offchain.ts

@@ -1,13 +1,14 @@
-import { type BN, BorshCoder, EventParser } from '@coral-xyz/anchor'
-import { type Connection, PublicKey } from '@solana/web3.js'
+import { type BN, BorshCoder } from '@coral-xyz/anchor'
+import type { PublicKey } from '@solana/web3.js'
 import { hexlify } from 'ethers'
 
 import { getUsdcAttestation } from '../offchain.ts'
-import type { CCIPMessage, CCIPRequest, OffchainTokenData } from '../types.ts'
-import { networkInfo } from '../utils.ts'
+import type { CCIPMessage, CCIPRequest, OffchainTokenData, WithLogger } from '../types.ts'
+import { networkInfo, util } from '../utils.ts'
 import { IDL as BASE_TOKEN_POOL } from './idl/1.6.0/BASE_TOKEN_POOL.ts'
 import { IDL as CCTP_TOKEN_POOL } from './idl/1.6.0/CCIP_CCTP_TOKEN_POOL.ts'
-import { bytesToBuffer } from './utils.ts'
+import type { SolanaLog, SolanaTransaction } from './index.ts'
+import { bytesToBuffer, hexDiscriminator } from './utils.ts'
 
 interface CcipCctpMessageSentEvent {
   originalSender: PublicKey
@@ -28,33 +29,24 @@ interface CcipCctpMessageAndAttestation {
 const cctpTokenPoolCoder = new BorshCoder({
   ...CCTP_TOKEN_POOL,
   types: [...BASE_TOKEN_POOL.types, ...CCTP_TOKEN_POOL.types],
-  events: BASE_TOKEN_POOL.events,
+  events: [...BASE_TOKEN_POOL.events, ...CCTP_TOKEN_POOL.events],
   errors: [...BASE_TOKEN_POOL.errors, ...CCTP_TOKEN_POOL.errors],
 })
 
 /**
  * Analyzes a Solana transaction to extract CcipCctpMessageSentEvent, fetch Circle attestation,
  * and encode the data in the format required by the destination chain.
- *
- * @param request - CCIP request containing transaction data and chain routing info
- * @returns Array of encoded offchain token data (only one supported for Solana right now)
- *
- * @throws Error if transaction hash is missing or CcipCctpMessageSentEvent parsing fails
- *
- * @example
- * const tokenData = await fetchSolanaOffchainTokenData({
- *   lane: { sourceChainSelector: ..., destChainSelector: ... },
- *   message: { ... },
- *   log: { transactionHash: "3k81TLhJuhwB8fvurCwyMPHXR3k9Tmtqe2ZrUQ8e3rMxk9fWFJT2xVHGgKJg1785FkJcaiQkthY4m86JrESGPhMY" },
- *   tx: { logs: [...] }
- * })
+ * @param request - CCIP request containing transaction data and chain routing info.
+ * @param logger - Logger instance for logging messages.
+ * @returns Array of encoded offchain token data (only one supported for Solana right now).
+ * @throws Error if transaction hash is missing or CcipCctpMessageSentEvent parsing fails.
  */
 export async function fetchSolanaOffchainTokenData(
-  connection: Connection,
   request: Pick<CCIPRequest, 'tx' | 'lane'> & {
     message: CCIPMessage
-    log: Pick<CCIPRequest['log'], 'topics' | 'index' | 'transactionHash'>
+    log: Pick<CCIPRequest['log'], 'topics' | 'index' | 'transactionHash' | 'address'>
   },
+  { logger = console }: WithLogger = {},
 ): Promise<OffchainTokenData[]> {
   if (request.message.tokenAmounts === undefined || request.message.tokenAmounts.length === 0) {
     return []
@@ -68,17 +60,29 @@ export async function fetchSolanaOffchainTokenData(
 
   const { isTestnet } = networkInfo(request.lane.sourceChainSelector)
   const txSignature = request.log.transactionHash
-  if (!txSignature) {
-    throw new Error('Transaction hash not found for OffchainTokenData parsing')
-  }
 
   // Parse Solana transaction to find CCTP event
-  const cctpEvents = await parseCcipCctpEvents(connection, txSignature)
+  const tx = request.tx as SolanaTransaction
+  const log = request.log as SolanaLog
+  const logMessages = tx.tx.meta!.logMessages!
+  // there may have multiple ccipSend calls in same tx;
+  // use `invoke [level]` to filter only logs inside this call
+  const requestInvokeIdx = logMessages.findLastIndex(
+    (l, i) => i < log.index && l === `Program ${request.log.address} invoke [${log.level}]`,
+  )
+  const cctpEvents = []
+  for (const l of tx.logs) {
+    if (requestInvokeIdx >= l.index || l.index >= log.index) continue
+    if (l.topics[0] !== hexDiscriminator('CcipCctpMessageSentEvent')) continue
+    const decoded = cctpTokenPoolCoder.events.decode(l.data)
+    if (!decoded) throw new Error(`Failed to decode CCTP event: ${util.inspect(l)}`)
+    cctpEvents.push(decoded.data as unknown as CcipCctpMessageSentEvent)
+  }
   const offchainTokenData: OffchainTokenData[] = request.message.tokenAmounts.map(() => undefined)
 
   // If no CcipCctpMessageSentEvent found, return defaults so we don't block execution
   if (cctpEvents.length === 0) {
-    console.debug('No events')
+    logger.debug('No USDC/CCTP events found')
     return offchainTokenData
   }
 
@@ -100,89 +104,15 @@ export async function fetchSolanaOffchainTokenData(
 
       offchainTokenData[0] = { _tag: 'usdc', message, attestation }
     } catch (error) {
-      console.warn(
-        `❌ Solana CCTP: Failed to fetch attestation for ${txSignature}:`,
-        message,
-        error,
-      )
+      logger.warn(`❌ Solana CCTP: Failed to fetch attestation for ${txSignature}:`, message, error)
     }
   }
 
-  console.debug('Got Solana offchain token data', offchainTokenData)
+  logger.debug('Got Solana offchain token data', offchainTokenData)
 
   return offchainTokenData
 }
 
-/**
- * Parses CcipCctpMessageSentEvent from a Solana transaction by analyzing program logs
- *
- * @param txSignature - Solana transaction signature to analyze
- * @param sourceChainSelector - Source chain selector to determine RPC endpoint
- * @returns Array of parsed CcipCctpMessageSentEvent found in the transaction (only 1 supported though)
- *
- * @throws Error if transaction is not found or RPC fails
- *
- * @example
- * const events = await parseSolanaCctpEvents(
- *   '3k81TLhJuhwB8fvurCwyMPHXR3k9Tmtqe2ZrUQ8e3rMxk9fWFJT2xVHGgKJg1785FkJcaiQkthY4m86JrESGPhMY',
- *   16423721717087811551n // Solana Devnet
- * )
- */
-async function parseCcipCctpEvents(
-  connection: Connection,
-  txSignature: string,
-): Promise<CcipCctpMessageSentEvent[]> {
-  // Fetch transaction details using Solana RPC
-  const tx = await connection.getTransaction(txSignature, {
-    commitment: 'finalized',
-    maxSupportedTransactionVersion: 0,
-  })
-  if (!tx || !tx.meta) {
-    throw new Error(`Transaction not found: ${txSignature}`)
-  }
-
-  if (!tx.meta.logMessages?.length) {
-    throw new Error(`Transaction has no logs: ${txSignature}`)
-  }
-
-  const cctpPoolAddress = getCctpPoolAddress(tx.meta.logMessages)
-  if (!cctpPoolAddress) {
-    return []
-  }
-
-  const eventParser = new EventParser(new PublicKey(cctpPoolAddress), cctpTokenPoolCoder)
-
-  const events: CcipCctpMessageSentEvent[] = Array.from(eventParser.parseLogs(tx.meta.logMessages))
-    .filter((event) => event.name === 'CcipCctpMessageSentEvent')
-    .map((event) => event.data as unknown as CcipCctpMessageSentEvent)
-  return events
-}
-
-function getCctpPoolAddress(logs: string[]): string | null {
-  // Example logs include lines like the following (though the indexes of the "invoke [1]" are unreliable):
-  // "Program <POOL ADDRESS HERE, THIS IS WHAT WE'RE LOOKING FOR> invoke [1]",
-  // "Program log: Instruction: LockOrBurnTokens",
-  const candidateIx = logs.indexOf('Program log: Instruction: LockOrBurnTokens')
-  if (candidateIx < 1) {
-    return null
-  }
-
-  const candidateAddress = logs[candidateIx - 1].split(' ')[1]
-
-  if (!candidateAddress.toLowerCase().startsWith('ccitp')) {
-    // The vanity address of the pool includes "ccitp" (case-insensitive) as a prefix
-    return null
-  }
-
-  // basic sanity check that we have the pool address: The pool returns a value, so the logs should show that
-  const sanityCheck = logs.find((log) => log.startsWith(`Program return: ${candidateAddress} `))
-  if (!sanityCheck) {
-    return null
-  }
-
-  return candidateAddress
-}
-
 /**
  * Encodes CCTP message and attestation
  *

package/src/solana/patchBorsh.ts

@@ -1,3 +1,5 @@
+import { Buffer } from 'buffer'
+
 import { BorshInstructionCoder } from '@coral-xyz/anchor'
 import { BorshTypesCoder } from '@coral-xyz/anchor/dist/cjs/coder/borsh/types.js'
 import { sha256, toUtf8Bytes } from 'ethers'
@@ -7,61 +9,74 @@ import { camelToSnakeCase } from './utils.ts'
 
 type Layout_<T = unknown> = { encode: (type: T, buffer: Buffer) => number }
 
-// monkey patch some functions to ensure correct buffer allocation (usually, hardcoded 1000B)
-Object.assign(BorshTypesCoder.prototype, {
-  encode: function <T>(this: BorshTypesCoder, name: string, type: T): Buffer {
-    const layout = (this as unknown as { typeLayouts: Map<string, Layout_> }).typeLayouts.get(name)
-    if (!layout) {
-      throw new Error(`Unknown type: ${name}`)
-    }
-    let buffer = Buffer.alloc(512)
-    let len
-    try {
-      len = layout.encode(type, buffer)
-    } catch (err) {
-      if (err instanceof RangeError) {
-        buffer = Buffer.alloc(32000)
-        len = layout.encode(type, buffer)
-      } else {
-        throw err
-      }
-    }
-
-    return buffer.subarray(0, len)
-  },
-})
-
 function sighash(nameSpace: string, ixName: string): Buffer {
   const name = camelToSnakeCase(ixName)
   const preimage = `${nameSpace}:${name}`
   return Buffer.from(sha256(toUtf8Bytes(preimage)).slice(2, 18), 'hex')
 }
 
-Object.assign(BorshInstructionCoder.prototype, {
-  _encode: function (
-    this: BorshInstructionCoder,
-    nameSpace: string,
-    ixName: string,
-    ix: any, // eslint-disable-line @typescript-eslint/no-explicit-any
-  ): Buffer {
-    const methodName = snakeToCamel(ixName)
-    const layout = (this as unknown as { ixLayout: Map<string, Layout_> }).ixLayout.get(methodName)
-    if (!layout) {
-      throw new Error(`Unknown method: ${methodName}`)
-    }
-    let buffer = Buffer.alloc(512)
-    let len
-    try {
-      len = layout.encode(ix, buffer)
-    } catch (err) {
-      if (err instanceof RangeError) {
-        buffer = Buffer.alloc(32000)
+let patched = false
+/**
+ * Patches BorshTypesCoder to ensure correct buffer allocation for large messages.
+ * Should be called before encoding Solana CCIP messages.
+ */
+export function patchBorsh() {
+  if (patched) return
+  patched = true
+  // monkey patch some functions to ensure correct buffer allocation (usually, hardcoded 1000B)
+  Object.assign(BorshTypesCoder.prototype, {
+    encode: function <T>(this: BorshTypesCoder, name: string, type: T): Buffer {
+      const layout = (this as unknown as { typeLayouts: Map<string, Layout_> }).typeLayouts.get(
+        name,
+      )
+      if (!layout) {
+        throw new Error(`Unknown type: ${name}`)
+      }
+      let buffer = Buffer.alloc(512)
+      let len
+      try {
+        len = layout.encode(type, buffer)
+      } catch (err) {
+        if (err instanceof RangeError) {
+          buffer = Buffer.alloc(32000)
+          len = layout.encode(type, buffer)
+        } else {
+          throw err
+        }
+      }
+
+      return buffer.subarray(0, len)
+    },
+  })
+
+  Object.assign(BorshInstructionCoder.prototype, {
+    _encode: function (
+      this: BorshInstructionCoder,
+      nameSpace: string,
+      ixName: string,
+      ix: any, // eslint-disable-line @typescript-eslint/no-explicit-any
+    ): Buffer {
+      const methodName = snakeToCamel(ixName)
+      const layout = (this as unknown as { ixLayout: Map<string, Layout_> }).ixLayout.get(
+        methodName,
+      )
+      if (!layout) {
+        throw new Error(`Unknown method: ${methodName}`)
+      }
+      let buffer = Buffer.alloc(512)
+      let len
+      try {
         len = layout.encode(ix, buffer)
-      } else {
-        throw err
+      } catch (err) {
+        if (err instanceof RangeError) {
+          buffer = Buffer.alloc(32000)
+          len = layout.encode(ix, buffer)
+        } else {
+          throw err
+        }
       }
-    }
-    const data = buffer.subarray(0, len)
-    return Buffer.concat([sighash(nameSpace, ixName), data])
-  },
-})
+      const data = buffer.subarray(0, len)
+      return Buffer.concat([sighash(nameSpace, ixName), data])
+    },
+  })
+}

package/src/solana/send.ts

@@ -1,6 +1,6 @@
-import util from 'util'
+import { Buffer } from 'buffer'
 
-import { type AnchorProvider, type IdlTypes, Program } from '@coral-xyz/anchor'
+import { type IdlTypes, Program } from '@coral-xyz/anchor'
 import {
   NATIVE_MINT,
   createApproveInstruction,
@@ -12,19 +12,17 @@ import {
   type AddressLookupTableAccount,
   type Connection,
   type TransactionInstruction,
-  ComputeBudgetProgram,
   PublicKey,
-  TransactionMessage,
-  VersionedTransaction,
 } from '@solana/web3.js'
 import BN from 'bn.js'
 import { zeroPadValue } from 'ethers'
 
 import { SolanaChain } from './index.ts'
-import type { AnyMessage } from '../types.ts'
-import { toLeArray } from '../utils.ts'
+import { type AnyMessage, type WithLogger, ChainFamily } from '../types.ts'
+import { toLeArray, util } from '../utils.ts'
 import { IDL as CCIP_ROUTER_IDL } from './idl/1.6.0/CCIP_ROUTER.ts'
-import { bytesToBuffer, simulateTransaction, simulationProvider } from './utils.ts'
+import type { UnsignedSolanaTx } from './types.ts'
+import { bytesToBuffer, simulationProvider } from './utils.ts'
 
 function anyToSvmMessage(message: AnyMessage): IdlTypes<typeof CCIP_ROUTER_IDL>['SVM2AnyMessage'] {
   const feeTokenPubkey = message.feeToken ? new PublicKey(message.feeToken) : PublicKey.default
@@ -48,17 +46,22 @@ function anyToSvmMessage(message: AnyMessage): IdlTypes<typeof CCIP_ROUTER_IDL>[
   return svmMessage
 }
 
+/**
+ * Gets the fee for sending a CCIP message on Solana.
+ * @param ctx - Context object containing the Solana connection and logger.
+ * @param router - Router program address.
+ * @param destChainSelector - Destination chain selector.
+ * @param message - CCIP message to send.
+ * @returns Fee amount in native tokens.
+ */
 export async function getFee(
-  connection: Connection,
+  ctx: { connection: Connection } & WithLogger,
   router: string,
   destChainSelector: bigint,
   message: AnyMessage,
 ): Promise<bigint> {
-  const program = new Program(
-    CCIP_ROUTER_IDL,
-    new PublicKey(router),
-    simulationProvider(connection),
-  )
+  const { connection, logger = console } = ctx
+  const program = new Program(CCIP_ROUTER_IDL, new PublicKey(router), simulationProvider(ctx))
 
   // Get router config to find feeQuoter
   const [configPda] = PublicKey.findProgramAddressSync([Buffer.from('config')], program.programId)
@@ -86,7 +89,7 @@ export async function getFee(
     message.feeToken !== PublicKey.default.toBase58() &&
     message.feeToken !== linkTokenMint.toBase58()
   ) {
-    console.warn('feeToken is not default nor link =', linkTokenMint.toBase58())
+    logger.warn('feeToken is not default nor link =', linkTokenMint.toBase58())
   }
 
   // Convert feeToken to PublicKey (default to native SOL if not specified)
@@ -129,7 +132,7 @@ export async function getFee(
     .map((pubkey) => ({ pubkey, isWritable: false, isSigner: false }))
 
   // Call getFee method
-  const result: unknown = await program.methods
+  const result = (await program.methods
     .getFee(new BN(destChainSelector), svmMessage)
     .accounts({
       config: configPda,
@@ -141,13 +144,13 @@ export async function getFee(
       feeQuoterLinkTokenConfig: feeQuoterLinkTokenConfigPda,
     })
     .remainingAccounts(remainingAccounts)
-    .view()
+    .view()) as IdlTypes<typeof CCIP_ROUTER_IDL>['GetFeeResult']
 
-  if (!(result as { amount?: BN })?.amount) {
+  if (!result?.amount) {
     throw new Error(`Invalid fee result from router: ${util.inspect(result)}`)
   }
 
-  return BigInt((result as { amount: BN }).amount.toString())
+  return BigInt(result.amount.toString())
 }
 
 async function deriveAccountsCcipSend({
@@ -170,16 +173,9 @@ async function deriveAccountsCcipSend({
   let tokenIndex = 0
 
   const [configPDA] = PublicKey.findProgramAddressSync([Buffer.from('config')], router.programId)
-
-  // read-only copy of router which avoids signing every simulation
-  const roProgram = new Program(
-    router.idl,
-    router.programId,
-    simulationProvider(connection, sender),
-  )
   do {
     // Create the transaction instruction for the deriveAccountsCcipSend method
-    const response = (await roProgram.methods
+    const response = (await router.methods
       .deriveAccountsCcipSend(
         {
           destChainSelector: new BN(destChainSelector.toString()),
@@ -248,63 +244,24 @@ async function deriveAccountsCcipSend({
   }
 }
 
-export async function simulateAndSendTxs(
-  connection: Connection,
-  feePayer: AnchorProvider['wallet'],
-  instructions: TransactionInstruction[],
-  addressLookupTableAccounts?: AddressLookupTableAccount[],
-) {
-  let computeUnitLimit
-  const simulated =
-    (
-      await simulateTransaction({
-        connection,
-        payerKey: feePayer.publicKey,
-        instructions,
-        addressLookupTableAccounts,
-      })
-    ).unitsConsumed || 0
-  if (simulated > 200000) computeUnitLimit = Math.ceil(simulated * 1.1)
-
-  const txMsg = new TransactionMessage({
-    payerKey: feePayer.publicKey,
-    recentBlockhash: (await connection.getLatestBlockhash('confirmed')).blockhash,
-    instructions: [
-      ...(computeUnitLimit
-        ? [ComputeBudgetProgram.setComputeUnitLimit({ units: computeUnitLimit })]
-        : []),
-      ...instructions,
-    ],
-  })
-  const messageV0 = txMsg.compileToV0Message(addressLookupTableAccounts)
-  const tx = new VersionedTransaction(messageV0)
-
-  const signed = await feePayer.signTransaction(tx)
-  let hash
-  for (let attempt = 0; ; attempt++) {
-    try {
-      hash = await connection.sendTransaction(signed)
-      await connection.confirmTransaction(hash, 'confirmed')
-      return hash
-    } catch (error) {
-      if (attempt >= 3) throw error
-      console.error(`sendTransaction failed attempt=${attempt + 1}/3:`, error)
-    }
-  }
-}
-
-export async function ccipSend(
-  router: Program<typeof CCIP_ROUTER_IDL>,
+/**
+ * Generates unsigned instructions for sending a message with CCIP on Solana
+ * @param ctx - Context containing connection and logger.
+ * @param sender - Wallet to pay transaction fees.
+ * @param router - Router program instance.
+ * @param destChainSelector - Destination chain selector.
+ * @param message - CCIP message with fee.
+ * @param opts - Optional parameters for approval.
+ * @returns Solana unsigned txs (instructions and lookup tables)
+ */
+export async function generateUnsignedCcipSend(
+  ctx: { connection: Connection } & WithLogger,
+  sender: PublicKey,
+  router: PublicKey,
   destChainSelector: bigint,
   message: AnyMessage & { fee: bigint },
   opts?: { approveMax?: boolean },
-) {
-  const connection = router.provider.connection
-  let wallet
-  if (!(wallet = (router.provider as AnchorProvider).wallet)) {
-    throw new Error('ccipSend called without signer wallet')
-  }
-
+): Promise<UnsignedSolanaTx> {
   const amountsToApprove = (message.tokenAmounts ?? []).reduce(
     (acc, { token, amount }) => ({ ...acc, [token]: (acc[token] ?? 0n) + amount }),
     {} as Record<string, bigint>,
@@ -312,14 +269,15 @@ export async function ccipSend(
   if (message.feeToken && message.feeToken !== PublicKey.default.toBase58()) {
     amountsToApprove[message.feeToken] = (amountsToApprove[message.feeToken] ?? 0n) + message.fee
   }
+  const program = new Program(CCIP_ROUTER_IDL, router, simulationProvider(ctx, sender))
 
   const approveIxs = []
   for (const [token, amount] of Object.entries(amountsToApprove)) {
     const approveIx = await approveRouterSpender(
-      connection,
-      wallet.publicKey,
+      ctx,
+      sender,
       new PublicKey(token),
-      router.programId,
+      router,
       opts?.approveMax ? undefined : amount,
     )
     if (approveIx) approveIxs.push(approveIx)
@@ -327,13 +285,13 @@ export async function ccipSend(
 
   const svmMessage = anyToSvmMessage(message)
   const { addressLookupTableAccounts, accounts, tokenIndexes } = await deriveAccountsCcipSend({
-    router,
+    router: program,
     destChainSelector,
-    sender: wallet.publicKey,
+    sender,
     message: svmMessage,
   })
 
-  const sendIx = await router.methods
+  const sendIx = await program.methods
     .ccipSend(new BN(destChainSelector), svmMessage, tokenIndexes)
     .accountsStrict({
       config: accounts[0].pubkey,
@@ -357,33 +315,16 @@ export async function ccipSend(
     })
     .remainingAccounts(accounts.slice(18))
     .instruction()
-
-  let hash
-  try {
-    // first try to serialize and send a single tx containing approve and send ixs
-    hash = await simulateAndSendTxs(
-      connection,
-      wallet,
-      [...approveIxs, sendIx],
-      addressLookupTableAccounts,
-    )
-  } catch (err) {
-    if (
-      !approveIxs.length ||
-      !(err instanceof Error) ||
-      !['encoding overruns Uint8Array', 'too large'].some((e) => err.message.includes(e))
-    )
-      throw err
-    // if serialization fails, send approve txs separately
-    for (const approveIx of approveIxs) await simulateAndSendTxs(connection, wallet, [approveIx])
-    hash = await simulateAndSendTxs(connection, wallet, [sendIx], addressLookupTableAccounts)
+  return {
+    family: ChainFamily.Solana,
+    mainIndex: approveIxs.length,
+    instructions: [...approveIxs, sendIx],
+    lookupTables: addressLookupTableAccounts,
   }
-
-  return { hash }
 }
 
 async function approveRouterSpender(
-  connection: Connection,
+  { connection, logger = console }: { connection: Connection } & WithLogger,
   owner: PublicKey,
   token: PublicKey,
   router: PublicKey,
@@ -424,7 +365,7 @@ async function approveRouterSpender(
     undefined,
     mintInfo.owner,
   )
-  console.info(
+  logger.info(
     'Approving',
     amount ?? BigInt(Number.MAX_SAFE_INTEGER),
     'of',

package/src/solana/types.ts

@@ -1,6 +1,47 @@
+import type {
+  AddressLookupTableAccount,
+  PublicKey,
+  Transaction,
+  TransactionInstruction,
+  VersionedTransaction,
+} from '@solana/web3.js'
+
 import type { SVMExtraArgsV1 } from '../extra-args.ts'
-import type { CCIPMessage_V1_6 } from '../types.ts'
+import type { CCIPMessage_V1_6, ChainFamily } from '../types.ts'
 
-// SourceTokenData adds `destGasAmount` (decoded from source's `destExecData`);
-// not sure why they kept the "gas" name in Solana, but let's just be keep consistent
+/** Solana-specific CCIP v1.6 message type with SVM extra args. */
 export type CCIPMessage_V1_6_Solana = CCIPMessage_V1_6 & SVMExtraArgsV1
+
+/**
+ * Contains unsigned data for a Solana transaction.
+ * instructions - array of instructions; may or may not fit in a single transaction
+ * mainIndex - index of the main instruction in the array
+ * lookupTables - array of lookupTables to be used in *main* transaction
+ */
+export type UnsignedSolanaTx = {
+  family: typeof ChainFamily.Solana
+  instructions: TransactionInstruction[]
+  mainIndex?: number
+  lookupTables?: AddressLookupTableAccount[]
+}
+
+/** Minimal Solana wallet interface (anchor.Wallet=) */
+export type Wallet = {
+  readonly publicKey: PublicKey
+  signTransaction<T extends Transaction | VersionedTransaction>(tx: T): Promise<T>
+}
+
+/** Typeguard for Solana Wallet */
+export function isWallet(wallet: unknown): wallet is Wallet {
+  return (
+    typeof wallet === 'object' &&
+    wallet !== null &&
+    'publicKey' in wallet &&
+    'signTransaction' in wallet &&
+    typeof wallet.publicKey === 'object' &&
+    wallet.publicKey !== null &&
+    'toBase58' in wallet.publicKey &&
+    typeof wallet.publicKey.toBase58 === 'function' &&
+    typeof wallet.signTransaction === 'function'
+  )
+}