@chainlink/ccip-sdk 0.91.0 → 0.92.0

package/src/sui/manuallyExec/encoder.ts

@@ -0,0 +1,88 @@
+import { bcs } from '@mysten/sui/bcs'
+import type { BytesLike } from 'ethers'
+
+import { CCIPMessageInvalidError } from '../../errors/specialized.ts'
+import { decodeExtraArgs } from '../../extra-args.ts'
+import type { CCIPMessage, CCIPVersion, ExecutionReport } from '../../types.ts'
+import { bytesToBuffer, getAddressBytes, getDataBytes, networkInfo } from '../../utils.ts'
+
+const Any2SuiTokenTransferBCS = bcs.struct('Any2SuiTokenTransfer', {
+  source_pool_address: bcs.vector(bcs.u8()),
+  dest_token_address: bcs.Address,
+  dest_gas_amount: bcs.u32(),
+  extra_data: bcs.vector(bcs.u8()),
+  amount: bcs.u256(),
+})
+
+const ExecutionReportBCS = bcs.struct('ExecutionReport', {
+  source_chain_selector: bcs.u64(),
+  message_id: bcs.fixedArray(32, bcs.u8()),
+  header_source_chain_selector: bcs.u64(),
+  dest_chain_selector: bcs.u64(),
+  sequence_number: bcs.u64(),
+  nonce: bcs.u64(),
+  sender: bcs.vector(bcs.u8()),
+  data: bcs.vector(bcs.u8()),
+  receiver: bcs.Address,
+  gas_limit: bcs.u256(),
+  token_receiver: bcs.Address,
+  token_amounts: bcs.vector(Any2SuiTokenTransferBCS),
+  offchain_token_data: bcs.vector(bcs.vector(bcs.u8())),
+  proofs: bcs.vector(bcs.fixedArray(32, bcs.u8())),
+})
+
+/**
+ * Serializes an execution report for Sui manual execution.
+ * @param executionReport - The execution report to serialize.
+ * @returns Serialized execution report as Uint8Array.
+ */
+export function serializeExecutionReport(
+  executionReport: ExecutionReport<CCIPMessage<typeof CCIPVersion.V1_6>>,
+): Uint8Array {
+  const { message, offchainTokenData, proofs } = executionReport
+
+  if (!message) {
+    throw new CCIPMessageInvalidError('Message is undefined in execution report')
+  }
+
+  let gasLimit, tokenReceiver
+  if ('receiverObjectIds' in message) {
+    ;({ gasLimit, tokenReceiver } = message)
+  } else {
+    const decodedExtraArgs = decodeExtraArgs(
+      message.extraArgs,
+      networkInfo(message.sourceChainSelector).family,
+    )
+    if (decodedExtraArgs?._tag !== 'SuiExtraArgsV1')
+      throw new CCIPMessageInvalidError('Expected Sui extra args')
+    ;({ gasLimit, tokenReceiver } = decodedExtraArgs)
+  }
+
+  const reportData = {
+    source_chain_selector: message.sourceChainSelector,
+    message_id: Array.from(bytesToBuffer(message.messageId)),
+    header_source_chain_selector: message.sourceChainSelector,
+    dest_chain_selector: message.destChainSelector,
+    sequence_number: message.sequenceNumber,
+    nonce: message.nonce,
+    sender: Array.from(bytesToBuffer(message.sender)),
+    data: Array.from(bytesToBuffer(message.data)),
+    receiver: message.receiver,
+    gas_limit: gasLimit,
+    token_receiver: tokenReceiver,
+    token_amounts: message.tokenAmounts.map((token) => ({
+      source_pool_address: Array.from(getAddressBytes(token.sourcePoolAddress)),
+      dest_token_address: token.destTokenAddress,
+      dest_gas_amount: Number(token.destGasAmount || 0n), // Use actual destGasAmount from token data
+      extra_data: Array.from(getDataBytes(token.extraData)),
+      amount: BigInt(token.amount),
+    })),
+    // TODO: encode as per CCTP/LBTC TPs, when available
+    offchain_token_data: offchainTokenData.map(() => Buffer.from([])),
+    proofs: proofs.map((proof: BytesLike) => {
+      return Array.from(getDataBytes(proof))
+    }),
+  }
+
+  return ExecutionReportBCS.serialize(reportData).toBytes()
+}

package/src/sui/manuallyExec/index.ts

@@ -0,0 +1,137 @@
+import { Transaction } from '@mysten/sui/transactions'
+
+import { serializeExecutionReport } from './encoder.ts'
+import { CCIPMessageInvalidError } from '../../errors/specialized.ts'
+import { decodeExtraArgs } from '../../extra-args.ts'
+import type { ExecutionReport } from '../../types.ts'
+import { networkInfo } from '../../utils.ts'
+import type { CCIPMessage_V1_6_Sui } from '../types.ts'
+
+/** Configuration for manually executing a Sui receiver module. */
+export type ManuallyExecuteSuiReceiverConfig = {
+  moduleName: string
+  packageId: string
+}
+
+/** Configuration for a token pool in manual execution. */
+export type TokenConfig = {
+  tokenPoolPackageId: string
+  tokenPoolModule: string
+  tokenType: string
+  administrator: string
+  pendingAdministrator: string
+  tokenPoolTypeProof: string
+  lockOrBurnParams: string[]
+  releaseOrMintParams: string[]
+}
+
+/** Input parameters for building a Sui manual execution transaction. */
+export type SuiManuallyExecuteInput = {
+  offrampAddress: string
+  executionReport: ExecutionReport<CCIPMessage_V1_6_Sui>
+  ccipAddress: string
+  ccipObjectRef: string
+  offrampStateObject: string
+  receiverConfig: ManuallyExecuteSuiReceiverConfig
+  tokenConfigs?: TokenConfig[]
+  overrideReceiverObjectIds?: string[]
+}
+
+/**
+ * Builds a Sui Programmable Transaction Block for manual CCIP message execution.
+ * @param params - Input parameters for building the manual execution transaction.
+ * @returns A Transaction object ready to be signed and executed.
+ */
+export function buildManualExecutionPTB({
+  offrampAddress,
+  executionReport,
+  ccipAddress,
+  ccipObjectRef,
+  offrampStateObject,
+  receiverConfig,
+  tokenConfigs,
+  overrideReceiverObjectIds,
+}: SuiManuallyExecuteInput): Transaction {
+  const reportBytes = serializeExecutionReport(executionReport)
+
+  // Create transaction
+  const tx = new Transaction()
+
+  // Step 1: Call manually_init_execute to prepare the execution
+  const receiverParamsArg = tx.moveCall({
+    target: `${offrampAddress}::offramp::manually_init_execute`,
+    arguments: [
+      tx.object(ccipObjectRef),
+      tx.object(offrampStateObject),
+      tx.object('0x6'), // Clock object
+      tx.pure.vector('u8', Array.from(reportBytes)),
+    ],
+  })
+
+  // Get the message from the from the report using the offramp helper
+  const messageArg = tx.moveCall({
+    target: `${ccipAddress}::offramp_state_helper::extract_any2sui_message`,
+    arguments: [receiverParamsArg],
+  })
+
+  // Process token pool transfers
+  if (tokenConfigs && tokenConfigs.length > 0) {
+    if (executionReport.message.tokenAmounts.length !== tokenConfigs.length) {
+      throw new CCIPMessageInvalidError('Token amounts length does not match token configs length')
+    }
+
+    // Process each token transfer
+    for (let i = 0; i < tokenConfigs.length; i++) {
+      const tokenConfig = tokenConfigs[i]
+
+      tx.moveCall({
+        target: `${tokenConfig.tokenPoolPackageId}::${tokenConfig.tokenPoolModule}::release_or_mint`,
+        typeArguments: [tokenConfig.tokenType],
+        arguments: [
+          tx.object(ccipObjectRef), // CCIPObjectRef
+          receiverParamsArg, // ReceiverParams (mutable)
+          ...tokenConfig.releaseOrMintParams.map((param) => tx.object(param)), // Pool-specific objects (clock, deny_list, token_state, state, etc.)
+        ],
+      })
+    }
+  }
+
+  // Decode extraArgs to get receiverObjectIds
+  const decodedExtraArgs = decodeExtraArgs(
+    executionReport.message.extraArgs,
+    networkInfo(executionReport.message.destChainSelector).family,
+  )
+
+  if (!decodedExtraArgs || decodedExtraArgs._tag !== 'SuiExtraArgsV1') {
+    throw new CCIPMessageInvalidError('Expected Sui extra args')
+  }
+
+  if (decodedExtraArgs.receiverObjectIds.length === 0) {
+    throw new CCIPMessageInvalidError('No receiverObjectIds provided in SUIExtraArgsV1')
+  }
+  // Call the receiver contract
+  tx.moveCall({
+    target: `${receiverConfig.packageId}::${receiverConfig.moduleName}::ccip_receive`,
+    arguments: [
+      tx.pure.vector('u8', Buffer.from(executionReport.message.messageId.slice(2), 'hex')),
+      tx.object(ccipObjectRef),
+      messageArg,
+      // if overrideReceiverObjectIds is provided, use them; otherwise, use the ones from decodedExtraArgs (original message)
+      ...(overrideReceiverObjectIds && overrideReceiverObjectIds.length > 0
+        ? overrideReceiverObjectIds.map(tx.object)
+        : decodedExtraArgs.receiverObjectIds.map(tx.object)),
+    ],
+  })
+
+  // Step 2: Call finish_execute to complete the execution
+  tx.moveCall({
+    target: `${offrampAddress}::offramp::finish_execute`,
+    arguments: [
+      tx.object(ccipObjectRef),
+      tx.object(offrampStateObject),
+      receiverParamsArg, // ReceiverParams from manually_init_execute
+    ],
+  })
+
+  return tx
+}

package/src/sui/objects.ts

@@ -0,0 +1,358 @@
+import { bcs } from '@mysten/sui/bcs'
+import type { SuiClient } from '@mysten/sui/client'
+import { Transaction } from '@mysten/sui/transactions'
+import { normalizeSuiAddress } from '@mysten/sui/utils'
+import { blake2b } from '@noble/hashes/blake2'
+
+import { CCIPDataFormatUnsupportedError } from '../errors/index.ts'
+import type { CCIPMessage, CCIPVersion } from '../types.ts'
+
+/**
+ * Derive a dynamic field object ID using the Sui algorithm
+ * This matches the Go implementation in chainlink-sui
+ */
+export function deriveObjectID(parentAddress: string, keyBytes: Uint8Array): string {
+  // Normalize parent address to 32 bytes
+  const normalizedParent = normalizeSuiAddress(parentAddress)
+  const parentBytes = bcs.Address.serialize(normalizedParent).toBytes()
+
+  // BCS serialize the key (vector<u8>)
+  const bcsKeyBytes = bcs.vector(bcs.u8()).serialize(Array.from(keyBytes)).toBytes()
+
+  // Construct TypeTag for DerivedObjectKey<vector<u8>>
+  const suiFrameworkAddress = bcs.Address.serialize('0x2').toBytes()
+  const typeTagBytes = new Uint8Array([
+    0x07, // TypeTag::Struct
+    ...suiFrameworkAddress,
+    0x0e, // module length
+    ...new TextEncoder().encode('derived_object'),
+    0x10, // struct name length
+    ...new TextEncoder().encode('DerivedObjectKey'),
+    0x01, // type params count
+    ...[0x06, 0x01], // vector<u8> TypeTag
+  ])
+
+  // Build the hash input
+  const keyLenBytes = new Uint8Array(8)
+  new DataView(keyLenBytes.buffer).setBigUint64(0, BigInt(bcsKeyBytes.length), true)
+
+  const hashInput = new Uint8Array([
+    0xf0, // HashingIntentScope::ChildObjectId
+    ...parentBytes,
+    ...keyLenBytes,
+    ...bcsKeyBytes,
+    ...typeTagBytes,
+  ])
+
+  // Hash with Blake2b-256
+  const hash = blake2b(hashInput, { dkLen: 32 })
+
+  // Convert to address string
+  return normalizeSuiAddress('0x' + Buffer.from(hash).toString('hex'))
+}
+
+/**
+ * Get the CCIPObjectRef ID for a CCIP package
+ */
+export async function getCcipObjectRef(client: SuiClient, ccipPackageId: string): Promise<string> {
+  // Get the pointer to find the CCIPObject ID
+  const pointerResponse = await client.getOwnedObjects({
+    owner: ccipPackageId,
+    filter: {
+      StructType: `${ccipPackageId}::state_object::CCIPObjectRefPointer`,
+    },
+  })
+
+  if (pointerResponse.data.length === 0) {
+    throw new CCIPDataFormatUnsupportedError(
+      'No CCIPObjectRefPointer found for the given packageId',
+    )
+  }
+
+  // Get the pointer object to extract ccip_object_id
+  const pointerId = pointerResponse.data[0].data?.objectId
+  if (!pointerId) {
+    throw new CCIPDataFormatUnsupportedError('Pointer does not have objectId')
+  }
+
+  const pointerObject = await client.getObject({
+    id: pointerId,
+    options: { showContent: true },
+  })
+
+  if (pointerObject.data?.content?.dataType !== 'moveObject') {
+    throw new CCIPDataFormatUnsupportedError('Pointer object is not a Move object')
+  }
+
+  const ccipObjectId = (pointerObject.data.content.fields as Record<string, unknown>)[
+    'ccip_object_id'
+  ] as string
+
+  if (!ccipObjectId) {
+    throw new CCIPDataFormatUnsupportedError('Could not find ccip_object_id in pointer')
+  }
+
+  // Derive the CCIPObjectRef ID from the parent CCIPObject ID
+  return deriveObjectID(ccipObjectId, new TextEncoder().encode('CCIPObjectRef'))
+}
+
+/**
+ * Get the OffRampState object ID for an offramp package
+ */
+export async function getOffRampStateObject(
+  client: SuiClient,
+  offrampPackageId: string,
+): Promise<string> {
+  const offrampPointerResponse = await client.getOwnedObjects({
+    owner: offrampPackageId,
+    filter: {
+      StructType: `${offrampPackageId}::offramp::OffRampStatePointer`,
+    },
+  })
+
+  if (offrampPointerResponse.data.length === 0) {
+    throw new CCIPDataFormatUnsupportedError(
+      'No OffRampStatePointer found for the given offramp package',
+    )
+  }
+
+  const offrampPointerId = offrampPointerResponse.data[0].data?.objectId
+
+  if (!offrampPointerId) {
+    throw new CCIPDataFormatUnsupportedError('OffRampStatePointer does not have a valid objectId')
+  }
+
+  const offrampPointerObject = await client.getObject({
+    id: offrampPointerId,
+    options: { showContent: true },
+  })
+
+  if (offrampPointerObject.data?.content?.dataType !== 'moveObject') {
+    throw new CCIPDataFormatUnsupportedError('OffRamp pointer object is not a Move object')
+  }
+
+  const offrampObjectId = (offrampPointerObject.data.content.fields as Record<string, unknown>)[
+    'off_ramp_object_id'
+  ] as string
+
+  if (!offrampObjectId) {
+    throw new CCIPDataFormatUnsupportedError('Could not find off_ramp_object_id in pointer')
+  }
+
+  // Derive the OffRampState ID from the parent OffRamp Object ID
+  return deriveObjectID(offrampObjectId, new TextEncoder().encode('OffRampState'))
+}
+
+/**
+ * Get the receiver module configuration from the receiver registry.
+ * @param provider - Sui client
+ * @param ccipPackageId - CCIP package ID
+ * @param ccipObjectRef - CCIP object reference
+ * @param receiverPackageId - Receiver package ID
+ * @returns Receiver module name and package ID
+ */
+export async function getReceiverModule(
+  provider: SuiClient,
+  ccipPackageId: string,
+  ccipObjectRef: string,
+  receiverPackageId: string,
+) {
+  // Call get_receiver_config from receiver_registry contract
+  const tx = new Transaction()
+
+  tx.moveCall({
+    target: `${ccipPackageId}::receiver_registry::get_receiver_config`,
+    arguments: [tx.object(ccipObjectRef), tx.pure.address(receiverPackageId)],
+  })
+
+  const result = await provider.devInspectTransactionBlock({
+    transactionBlock: tx,
+    sender: '0x0000000000000000000000000000000000000000000000000000000000000000',
+  })
+
+  if (result.error) {
+    throw new CCIPDataFormatUnsupportedError(`Failed to call get_receiver_config: ${result.error}`)
+  }
+
+  if (!result.results || result.results.length === 0) {
+    throw new CCIPDataFormatUnsupportedError('No results returned from get_receiver_config')
+  }
+
+  const returnValues = result.results[0]?.returnValues
+
+  if (!returnValues || returnValues.length === 0) {
+    throw new CCIPDataFormatUnsupportedError('No return values from get_receiver_config')
+  }
+
+  // Decode the ReceiverConfig struct
+  // ReceiverConfig has two fields: module_name (String) and proof_typename (ascii::String)
+  // The struct is returned as a BCS-encoded byte array
+  const receiverConfigBytes = returnValues[0][0]
+
+  // Parse the struct:
+  // First field is module_name (String = vector<u8> with length prefix)
+  let offset = 0
+  const moduleNameLength = receiverConfigBytes[offset]
+  offset += 1
+  const moduleName = new TextDecoder().decode(
+    new Uint8Array(receiverConfigBytes.slice(offset, offset + moduleNameLength)),
+  )
+
+  return {
+    moduleName,
+    packageId: receiverPackageId,
+  }
+}
+
+/**
+ * Fetch token configurations for the given token amounts.
+ * @param client - Sui client
+ * @param ccipPackageId - CCIP package ID
+ * @param ccipObjectRef - CCIP object reference
+ * @param tokenAmounts - Token amounts from CCIP message
+ * @returns Array of token configurations
+ */
+export async function fetchTokenConfigs(
+  client: SuiClient,
+  ccipPackageId: string,
+  ccipObjectRef: string,
+  tokenAmounts: CCIPMessage<typeof CCIPVersion.V1_6>['tokenAmounts'],
+) {
+  if (tokenAmounts.length === 0) {
+    return []
+  }
+  const tokenConfigs = []
+  const tokenAddresses = [
+    ...new Set(
+      tokenAmounts.map((token) => token.destTokenAddress).filter((addr) => addr && addr !== '0x0'),
+    ),
+  ]
+
+  // Fetch token config for each unique token address
+  for (const tokenAddress of tokenAddresses) {
+    const tx = new Transaction()
+
+    // Call get_token_config_struct from token_admin_registry
+    tx.moveCall({
+      target: `${ccipPackageId}::token_admin_registry::get_token_config_struct`,
+      arguments: [tx.object(ccipObjectRef), tx.pure.address(tokenAddress)],
+    })
+
+    const result = await client.devInspectTransactionBlock({
+      transactionBlock: tx,
+      sender: '0x0000000000000000000000000000000000000000000000000000000000000000',
+    })
+
+    if (result.error) {
+      throw new CCIPDataFormatUnsupportedError(
+        `Failed to fetch token config for ${tokenAddress}: ${result.error}`,
+      )
+    }
+
+    if (!result.results || result.results.length === 0) {
+      throw new CCIPDataFormatUnsupportedError(
+        `No results returned from get_token_config_struct for ${tokenAddress}`,
+      )
+    }
+
+    const returnValues = result.results[0]?.returnValues
+
+    if (!returnValues || returnValues.length === 0) {
+      throw new CCIPDataFormatUnsupportedError(
+        `No return values from get_token_config_struct for ${tokenAddress}`,
+      )
+    }
+
+    // Parse the TokenConfig struct from BCS-encoded bytes
+    const configBytes = returnValues[0][0]
+
+    // TokenConfig structure (from token_admin_registry.go):
+    // - TokenPoolPackageId (address = 32 bytes)
+    // - TokenPoolModule (String = length + bytes)
+    // - TokenType (ascii::String = length + bytes)
+    // - Administrator (address = 32 bytes)
+    // - PendingAdministrator (address = 32 bytes)
+    // - TokenPoolTypeProof (ascii::String = length + bytes)
+    // - LockOrBurnParams (vector<address> = length + N * 32 bytes)
+    // - ReleaseOrMintParams (vector<address> = length + N * 32 bytes)
+
+    let offset = 0
+
+    // TokenPoolPackageId (32 bytes)
+    const tokenPoolPackageIdBytes = configBytes.slice(offset, offset + 32)
+    const tokenPoolPackageId = normalizeSuiAddress(
+      '0x' + Buffer.from(tokenPoolPackageIdBytes).toString('hex'),
+    )
+    offset += 32
+
+    // TokenPoolModule (String)
+    const moduleNameLength = configBytes[offset]
+    offset += 1
+    const tokenPoolModule = new TextDecoder().decode(
+      new Uint8Array(configBytes.slice(offset, offset + moduleNameLength)),
+    )
+    offset += moduleNameLength
+
+    // TokenType (ascii::String)
+    const tokenTypeLength = configBytes[offset]
+    offset += 1
+    const tokenType = new TextDecoder().decode(
+      new Uint8Array(configBytes.slice(offset, offset + tokenTypeLength)),
+    )
+    offset += tokenTypeLength
+
+    // Administrator (32 bytes)
+    const administratorBytes = configBytes.slice(offset, offset + 32)
+    const administrator = normalizeSuiAddress(
+      '0x' + Buffer.from(administratorBytes).toString('hex'),
+    )
+    offset += 32
+
+    // PendingAdministrator (32 bytes)
+    const pendingAdminBytes = configBytes.slice(offset, offset + 32)
+    const pendingAdministrator = normalizeSuiAddress(
+      '0x' + Buffer.from(pendingAdminBytes).toString('hex'),
+    )
+    offset += 32
+
+    // TokenPoolTypeProof (ascii::String)
+    const proofLength = configBytes[offset]
+    offset += 1
+    const tokenPoolTypeProof = new TextDecoder().decode(
+      new Uint8Array(configBytes.slice(offset, offset + proofLength)),
+    )
+    offset += proofLength
+
+    // LockOrBurnParams (vector<address>)
+    const lockOrBurnCount = configBytes[offset]
+    offset += 1
+    const lockOrBurnParams: string[] = []
+    for (let i = 0; i < lockOrBurnCount; i++) {
+      const addrBytes = configBytes.slice(offset, offset + 32)
+      lockOrBurnParams.push(normalizeSuiAddress('0x' + Buffer.from(addrBytes).toString('hex')))
+      offset += 32
+    }
+
+    // ReleaseOrMintParams (vector<address>)
+    const releaseOrMintCount = configBytes[offset]
+    offset += 1
+    const releaseOrMintParams: string[] = []
+    for (let i = 0; i < releaseOrMintCount; i++) {
+      const addrBytes = configBytes.slice(offset, offset + 32)
+      releaseOrMintParams.push(normalizeSuiAddress('0x' + Buffer.from(addrBytes).toString('hex')))
+      offset += 32
+    }
+
+    tokenConfigs.push({
+      tokenPoolPackageId,
+      tokenPoolModule,
+      tokenType,
+      administrator,
+      pendingAdministrator,
+      tokenPoolTypeProof,
+      lockOrBurnParams,
+      releaseOrMintParams,
+    })
+  }
+  return tokenConfigs
+}

package/src/ton/bindings/offramp.ts

@@ -0,0 +1,96 @@
+// TODO: FIXME: Remove local copies and import when chainlink-ton is published as npm package
+import type { Address, ContractProvider } from '@ton/core'
+
+/**
+ * Configuration for a source chain on the TON OffRamp contract.
+ */
+export interface SourceChainConfig {
+  router: Address
+  isEnabled: boolean
+  minSeqNr: bigint
+  isRMNVerificationDisabled: boolean
+  onRamp: Buffer
+}
+
+/**
+ * Dynamic configuration for the OffRamp contract.
+ * Contains addresses that can be updated without redeploying the contract.
+ */
+export interface DynamicConfig {
+  router: Address
+  feeQuoter: Address
+  permissionlessExecutionThresholdSeconds: number
+}
+
+/**
+ * TON OffRamp contract binding.
+ * The OffRamp receives and executes cross-chain messages on the destination (TON) chain.
+ */
+export class OffRamp {
+  readonly address: Address
+
+  /**
+   * Creates a new OffRamp instance.
+   * @param address - The OffRamp contract address on TON.
+   */
+  constructor(address: Address) {
+    this.address = address
+  }
+
+  /**
+   * Creates an OffRamp instance from a contract address.
+   * @param address - The OffRamp contract address on TON.
+   * @returns A new OffRamp instance.
+   */
+  static createFromAddress(address: Address): OffRamp {
+    return new OffRamp(address)
+  }
+
+  /**
+   * Retrieves the source chain configuration for a given chain selector.
+   *
+   * @param provider - TON contract provider for making RPC calls.
+   * @param sourceChainSelector - The CCIP chain selector of the source chain.
+   * @returns The source chain configuration.
+   * @throws Error with exitCode 266 if the source chain is not enabled.
+   */
+  async getSourceChainConfig(
+    provider: ContractProvider,
+    sourceChainSelector: bigint,
+  ): Promise<SourceChainConfig> {
+    const result = await provider.get('sourceChainConfig', [
+      { type: 'int', value: sourceChainSelector },
+    ])
+
+    // Tolk returns struct as tuple
+    const router = result.stack.readAddress()
+    const isEnabled = result.stack.readBoolean()
+    const minSeqNr = result.stack.readBigNumber()
+    const isRMNVerificationDisabled = result.stack.readBoolean()
+
+    // onRamp is stored as CrossChainAddress cell
+    const onRampCell = result.stack.readCell()
+    const onRampSlice = onRampCell.beginParse()
+
+    // Check if length-prefixed or raw format based on cell bit length
+    const cellBits = onRampCell.bits.length
+    let onRamp: Buffer
+
+    if (cellBits === 160) {
+      // Raw 20-byte EVM address (no length prefix)
+      onRamp = onRampSlice.loadBuffer(20)
+    } else {
+      // Length-prefixed format: 8-bit length + data
+      const onRampLength = onRampSlice.loadUint(8)
+      onRamp = onRampSlice.loadBuffer(onRampLength)
+    }
+
+    return {
+      router,
+      isEnabled,
+      minSeqNr,
+      isRMNVerificationDisabled,
+      onRamp,
+    }
+  }
+}