@chainlink/ccip-sdk 0.95.0 → 0.96.0

package/src/ton/index.ts

@@ -8,6 +8,7 @@ import { type Memoized, memoize } from 'micro-memoize'
 import type { PickDeep } from 'type-fest'
 
 import { streamTransactionsForAddress } from './logs.ts'
+import { generateUnsignedCcipSend, getFee as getFeeImpl } from './send.ts'
 import { type ChainContext, type GetBalanceOpts, type LogFilter, Chain } from '../chain.ts'
 import {
   CCIPArgumentInvalidError,
@@ -21,6 +22,8 @@ import {
   CCIPWalletInvalidError,
 } from '../errors/specialized.ts'
 import { type EVMExtraArgsV2, type ExtraArgs, EVMExtraArgsV2Tag } from '../extra-args.ts'
+import type { LeafHasher } from '../hasher/common.ts'
+import { buildMessageForDest } from '../requests.ts'
 import { supportedChains } from '../supported-chains.ts'
 import {
   type CCIPExecution,
@@ -34,6 +37,7 @@ import {
   type NetworkInfo,
   type OffchainTokenData,
   type WithLogger,
+  CCIPVersion,
   ChainFamily,
   ExecutionState,
 } from '../types.ts'
@@ -49,7 +53,6 @@ import { generateUnsignedExecuteReport as generateUnsignedExecuteReportImpl } fr
 import { getTONLeafHasher } from './hasher.ts'
 import { type CCIPMessage_V1_6_TON, type UnsignedTONTx, isTONWallet } from './types.ts'
 import { crc32, lookupTxByRawHash, parseJettonContent } from './utils.ts'
-import type { LeafHasher } from '../hasher/common.ts'
 export type { TONWallet, UnsignedTONTx } from './types.ts'
 
 /**
@@ -179,6 +182,7 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    * @param url - RPC endpoint URL for TonClient (v2).
    * @param ctx - Context containing logger.
    * @returns A new TONChain instance.
+   * @throws {@link CCIPHttpError} if connection to the RPC endpoint fails
    */
   static async fromUrl(url: string, ctx?: ChainContext): Promise<TONChain> {
     const { logger = console } = ctx ?? {}
@@ -219,6 +223,7 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    *
    * @param block - Logical time (lt) as number, or 'finalized' for latest block timestamp
    * @returns Unix timestamp in seconds
+   * @throws {@link CCIPNotImplementedError} if lt is not in cache
    */
   async getBlockTimestamp(block: number | 'finalized'): Promise<number> {
     if (typeof block != 'number') {
@@ -246,6 +251,8 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    * @param tx - Transaction identifier in either format
    * @returns ChainTransaction with transaction details
    *          Note: `blockNumber` contains logical time (lt), not block seqno
+   * @throws {@link CCIPArgumentInvalidError} if hash format is invalid
+   * @throws {@link CCIPTransactionNotFoundError} if transaction not found
    */
   async getTransaction(tx: string | Transaction): Promise<ChainTransaction> {
     let address
@@ -340,6 +347,7 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    * not block sequence numbers. This is because TON transaction APIs are indexed by lt.
    *
    * @param opts - Log filter options (startBlock/endBlock are interpreted as lt values)
+   * @throws {@link CCIPTopicsInvalidError} if topics format is invalid
    */
   async *getLogs(opts: LogFilter): AsyncIterableIterator<Log_> {
     let topics
@@ -362,7 +370,10 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     }
   }
 
-  /** {@inheritDoc Chain.getMessagesInBatch} */
+  /**
+   * {@inheritDoc Chain.getMessagesInBatch}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
   override async getMessagesInBatch<
     R extends PickDeep<
       CCIPRequest,
@@ -420,9 +431,14 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     return stack.readAddress().toRawString()
   }
 
-  /** {@inheritDoc Chain.getNativeTokenForRouter} */
+  /**
+   * {@inheritDoc Chain.getNativeTokenForRouter}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
   getNativeTokenForRouter(_router: string): Promise<string> {
-    return Promise.reject(new CCIPNotImplementedError('getNativeTokenForRouter'))
+    // TON native token is represented as address 0:0...01 (workchain 0, hash = 1)
+    // This is a convention for representing native TON in CCIP
+    return Promise.resolve('0:0000000000000000000000000000000000000000000000000000000000000001')
   }
 
   /** {@inheritDoc Chain.getOffRampsForRouter} */
@@ -445,7 +461,10 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     return stack.readAddress().toRawString()
   }
 
-  /** {@inheritDoc Chain.getOnRampForOffRamp} */
+  /**
+   * {@inheritDoc Chain.getOnRampForOffRamp}
+   * @throws {@link CCIPSourceChainUnsupportedError} if source chain is not configured
+   */
   async getOnRampForOffRamp(offRamp: string, sourceChainSelector: bigint): Promise<string> {
     try {
       const offRampContract = this.provider.provider(Address.parse(offRamp))
@@ -491,7 +510,10 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     return Promise.resolve(offRamp)
   }
 
-  /** {@inheritDoc Chain.getTokenForTokenPool} */
+  /**
+   * {@inheritDoc Chain.getTokenForTokenPool}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
   async getTokenForTokenPool(_tokenPool: string): Promise<string> {
     return Promise.reject(new CCIPNotImplementedError('getTokenForTokenPool'))
   }
@@ -519,12 +541,45 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     }
   }
 
-  /** {@inheritDoc Chain.getBalance} */
-  async getBalance(_opts: GetBalanceOpts): Promise<bigint> {
-    return Promise.reject(new CCIPNotImplementedError('TONChain.getBalance'))
+  /**
+   * {@inheritDoc Chain.getBalance}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
+  async getBalance(opts: GetBalanceOpts): Promise<bigint> {
+    const { holder, token } = opts
+    const holderAddress = Address.parse(holder)
+
+    if (!token) {
+      // Get native TON balance
+      const state = await this.provider.getContractState(holderAddress)
+      return state.balance
+    }
+
+    // For jetton balance, we need to:
+    // 1. Derive the jetton wallet address for this holder
+    // 2. Query the balance from that wallet contract
+    const jettonMaster = Address.parse(token)
+    const { stack } = await this.provider.runMethod(jettonMaster, 'get_wallet_address', [
+      { type: 'slice', cell: beginCell().storeAddress(holderAddress).endCell() },
+    ])
+    const jettonWalletAddress = stack.readAddress()
+
+    try {
+      const { stack: balanceStack } = await this.provider.runMethod(
+        jettonWalletAddress,
+        'get_wallet_data',
+      )
+      return balanceStack.readBigNumber() // First value is balance
+    } catch {
+      // Wallet doesn't exist yet = 0 balance
+      return 0n
+    }
   }
 
-  /** {@inheritDoc Chain.getTokenAdminRegistryFor} */
+  /**
+   * {@inheritDoc Chain.getTokenAdminRegistryFor}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
   getTokenAdminRegistryFor(_address: string): Promise<string> {
     return Promise.reject(new CCIPNotImplementedError('getTokenAdminRegistryFor'))
   }
@@ -832,6 +887,7 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
    * and raw format strings ("workchain:hash").
    * @param bytes - Bytes or string to convert.
    * @returns TON raw address string in format "workchain:hash".
+   * @throws {@link CCIPArgumentInvalidError} if bytes length is invalid
    */
   static getAddress(bytes: BytesLike): string {
     // If it's already a string address, try to parse and return raw format
@@ -951,20 +1007,107 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
   }
 
   /** {@inheritDoc Chain.getFee} */
-  async getFee(_opts: Parameters<Chain['getFee']>[0]): Promise<bigint> {
-    return Promise.reject(new CCIPNotImplementedError('getFee'))
+  async getFee({
+    router,
+    destChainSelector,
+    message,
+  }: Parameters<Chain['getFee']>[0]): Promise<bigint> {
+    return getFeeImpl(
+      this,
+      router,
+      destChainSelector,
+      buildMessageForDest(message, networkInfo(destChainSelector).family),
+    )
   }
 
   /** {@inheritDoc Chain.generateUnsignedSendMessage} */
-  generateUnsignedSendMessage(
-    _opts: Parameters<Chain['generateUnsignedSendMessage']>[0],
-  ): Promise<never> {
-    return Promise.reject(new CCIPNotImplementedError('generateUnsignedSendMessage'))
+  async generateUnsignedSendMessage({
+    router,
+    destChainSelector,
+    message,
+    sender,
+  }: Parameters<Chain['generateUnsignedSendMessage']>[0]): Promise<UnsignedTONTx> {
+    // Convert MessageInput to AnyMessage with defaults
+    const populatedMessage = buildMessageForDest(message, networkInfo(destChainSelector).family)
+
+    // Calculate fee if not provided
+    const fee =
+      message.fee ??
+      (await this.getFee({
+        router,
+        destChainSelector,
+        message: populatedMessage,
+      }))
+
+    const unsigned = generateUnsignedCcipSend(this, sender, router, destChainSelector, {
+      ...populatedMessage,
+      fee,
+    })
+
+    return {
+      family: ChainFamily.TON,
+      ...unsigned,
+    }
   }
 
   /** {@inheritDoc Chain.sendMessage} */
-  async sendMessage(_opts: Parameters<Chain['sendMessage']>[0]): Promise<CCIPRequest> {
-    return Promise.reject(new CCIPNotImplementedError('sendMessage'))
+  async sendMessage({
+    router,
+    destChainSelector,
+    message,
+    wallet,
+  }: Parameters<Chain['sendMessage']>[0]): Promise<CCIPRequest> {
+    if (!isTONWallet(wallet)) {
+      throw new CCIPWalletInvalidError(wallet)
+    }
+
+    const sender = await wallet.getAddress()
+
+    // Generate unsigned transaction with fee calculation if needed
+    const { family: _, ...unsigned } = await this.generateUnsignedSendMessage({
+      router,
+      destChainSelector,
+      message,
+      sender,
+    })
+
+    // Send transaction
+    const startTime = Math.floor(Date.now() / 1000)
+    const seqno = await wallet.sendTransaction(unsigned)
+
+    this.logger.info('CCIP send transaction submitted, seqno:', seqno)
+
+    // Wait for CCIPMessageSent event and extract the request
+    // Query the OnRamp for the CCIPMessageSent event
+    const onRamp = await this.getOnRampForRouter(router, destChainSelector)
+
+    // Poll for the message in recent logs
+    for await (const log of this.getLogs({
+      address: onRamp,
+      topics: [crc32('CCIPMessageSent')],
+      startTime,
+      watch: sleep(5 * 60e3 /* 5m timeout */),
+    })) {
+      const msg = TONChain.decodeMessage(log)
+      if (!msg) continue
+
+      // Found our message: construct and return the CCIPRequest
+      const tx = log.tx ?? (await this.getTransaction(log.transactionHash))
+
+      return {
+        lane: {
+          sourceChainSelector: this.network.chainSelector,
+          destChainSelector,
+          onRamp,
+          version: CCIPVersion.V1_6,
+        },
+        message: msg,
+        log,
+        tx,
+      }
+    }
+
+    throw new CCIPTransactionNotFoundError(seqno.toString())
   }
 
   /** {@inheritDoc Chain.getOffchainTokenData} */
@@ -972,7 +1115,10 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     return Promise.resolve(request.message.tokenAmounts.map(() => undefined))
   }
 
-  /** {@inheritDoc Chain.generateUnsignedExecuteReport} */
+  /**
+   * {@inheritDoc Chain.generateUnsignedExecuteReport}
+   * @throws {@link CCIPExtraArgsInvalidError} if extra args are not EVMExtraArgsV2 format
+   */
   generateUnsignedExecuteReport({
     offRamp,
     execReport,
@@ -994,7 +1140,11 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     })
   }
 
-  /** {@inheritDoc Chain.executeReport} */
+  /**
+   * {@inheritDoc Chain.executeReport}
+   * @throws {@link CCIPWalletInvalidError} if wallet is not a valid TON wallet
+   * @throws {@link CCIPReceiptNotFoundError} if execution receipt not found within timeout
+   */
   async executeReport(opts: Parameters<Chain['executeReport']>[0]): Promise<CCIPExecution> {
     const { offRamp, wallet } = opts
     if (!isTONWallet(wallet)) {
@@ -1039,27 +1189,42 @@ export class TONChain extends Chain<typeof ChainFamily.TON> {
     }
   }
 
-  /** {@inheritDoc Chain.getSupportedTokens} */
+  /**
+   * {@inheritDoc Chain.getSupportedTokens}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
   async getSupportedTokens(_address: string): Promise<string[]> {
     return Promise.reject(new CCIPNotImplementedError('getSupportedTokens'))
   }
 
-  /** {@inheritDoc Chain.getRegistryTokenConfig} */
+  /**
+   * {@inheritDoc Chain.getRegistryTokenConfig}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
   async getRegistryTokenConfig(_address: string, _tokenName: string): Promise<never> {
     return Promise.reject(new CCIPNotImplementedError('getRegistryTokenConfig'))
   }
 
-  /** {@inheritDoc Chain.getTokenPoolConfigs} */
-  async getTokenPoolConfigs(_tokenPool: string): Promise<never> {
-    return Promise.reject(new CCIPNotImplementedError('getTokenPoolConfigs'))
+  /**
+   * {@inheritDoc Chain.getTokenPoolConfig}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
+  async getTokenPoolConfig(_tokenPool: string): Promise<never> {
+    return Promise.reject(new CCIPNotImplementedError('getTokenPoolConfig'))
   }
 
-  /** {@inheritDoc Chain.getTokenPoolRemotes} */
+  /**
+   * {@inheritDoc Chain.getTokenPoolRemotes}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
   async getTokenPoolRemotes(_tokenPool: string): Promise<never> {
     return Promise.reject(new CCIPNotImplementedError('getTokenPoolRemotes'))
   }
 
-  /** {@inheritDoc Chain.getFeeTokens} */
+  /**
+   * {@inheritDoc Chain.getFeeTokens}
+   * @throws {@link CCIPNotImplementedError} always (not implemented for TON)
+   */
   async getFeeTokens(_router: string): Promise<never> {
     return Promise.reject(new CCIPNotImplementedError('getFeeTokens'))
   }

package/src/ton/send.ts

@@ -0,0 +1,222 @@
+import { type Cell, beginCell, toNano } from '@ton/core'
+import { type TonClient, Address } from '@ton/ton'
+import { zeroPadValue } from 'ethers'
+
+import type { UnsignedTONTx } from './types.ts'
+import { CCIPError, CCIPErrorCode } from '../errors/index.ts'
+import { EVMExtraArgsV2Tag } from '../extra-args.ts'
+import type { AnyMessage, WithLogger } from '../types.ts'
+import { bytesToBuffer, getDataBytes } from '../utils.ts'
+
+/** Opcode for Router ccipSend operation */
+export const CCIP_SEND_OPCODE = 0x31768d95
+
+/** Default gas buffer to add to fee for transaction execution */
+export const DEFAULT_GAS_BUFFER = toNano('0.5')
+
+/** Default gas limit for destination chain execution */
+export const DEFAULT_GAS_LIMIT = 200_000n
+
+/**
+ * WRAPPED_NATIVE address for TON - sentinel address representing native TON.
+ * Used as feeToken for native TON payments in FeeQuoter calls.
+ */
+export const WRAPPED_NATIVE = Address.parse(
+  '0:0000000000000000000000000000000000000000000000000000000000000001',
+)
+
+/**
+ * Encodes token amounts as a snaked cell.
+ * Empty cell for no tokens.
+ */
+function encodeTokenAmounts(
+  tokenAmounts: readonly { token: string; amount: bigint }[] | undefined,
+): Cell {
+  if (!tokenAmounts || tokenAmounts.length === 0) {
+    return beginCell().endCell()
+  }
+
+  const builder = beginCell()
+  for (const ta of tokenAmounts) {
+    builder.storeRef(
+      beginCell().storeAddress(Address.parse(ta.token)).storeUint(ta.amount, 256).endCell(),
+    )
+  }
+  return builder.endCell()
+}
+
+/**
+ * Encodes extraArgs as a Cell using the GenericExtraArgsV2 (EVMExtraArgsV2) format.
+ *
+ * Format per chainlink-ton TL-B:
+ * - tag: 32-bit opcode (0x181dcf10)
+ * - gasLimit: Maybe<uint256> (1 bit flag + 256 bits if present)
+ * - allowOutOfOrderExecution: 1 bit (must be true)
+ */
+function encodeExtraArgsCell(extraArgs: AnyMessage['extraArgs']): Cell {
+  const allowOutOfOrderExecution = true
+
+  let gasLimit = 0n
+  let hasGasLimit = false
+
+  if ('gasLimit' in extraArgs && extraArgs.gasLimit > 0n) {
+    hasGasLimit = true
+    gasLimit = extraArgs.gasLimit
+  }
+
+  const builder = beginCell()
+    .storeUint(Number(EVMExtraArgsV2Tag), 32) // 0x181dcf10
+    .storeBit(hasGasLimit)
+
+  if (hasGasLimit) {
+    builder.storeUint(gasLimit, 256)
+  }
+
+  return builder.storeBit(allowOutOfOrderExecution).endCell()
+}
+
+/**
+ * Builds the Router ccipSend message cell.
+ *
+ * Relies on TL-B structure (Router_CCIPSend) from chainlink-ton repo.
+ */
+export function buildCcipSendCell(
+  destChainSelector: bigint,
+  message: AnyMessage,
+  feeTokenAddress: Address | null = null,
+  queryId = 0n,
+): Cell {
+  // Get receiver bytes and pad to 32 bytes for cross-chain encoding
+  const paddedReceiver = bytesToBuffer(zeroPadValue(getDataBytes(message.receiver), 32))
+
+  // Data cell (ref 0)
+  const dataCell = beginCell()
+    .storeBuffer(bytesToBuffer(message.data || '0x'))
+    .endCell()
+
+  // Token amounts snaked cell (ref 1)
+  const tokenAmountsCell = encodeTokenAmounts(message.tokenAmounts)
+
+  // ExtraArgs cell (ref 2)
+  const extraArgsCell = encodeExtraArgsCell(message.extraArgs)
+
+  return beginCell()
+    .storeUint(CCIP_SEND_OPCODE, 32) // opcode
+    .storeUint(Number(queryId), 64) // queryID
+    .storeUint(destChainSelector, 64) // destChainSelector
+    .storeUint(paddedReceiver.length, 8) // receiver length in bytes
+    .storeBuffer(paddedReceiver) // receiver bytes (32 bytes, left-padded)
+    .storeRef(dataCell) // ref 0: data
+    .storeRef(tokenAmountsCell) // ref 1: tokenAmounts
+    .storeAddress(feeTokenAddress) // null = addr_none for native TON
+    .storeRef(extraArgsCell) // ref 2: extraArgs
+    .endCell()
+}
+
+/**
+ * Gets the fee for sending a CCIP message by calling FeeQuoter.validatedFee.
+ *
+ * @param ctx - Context with TonClient provider and logger
+ * @param router - Router contract address
+ * @param destChainSelector - Destination chain selector
+ * @param message - CCIP message to quote
+ * @returns Fee amount in nanotons
+ */
+export async function getFee(
+  ctx: { provider: TonClient } & WithLogger,
+  router: string,
+  destChainSelector: bigint,
+  message: AnyMessage,
+): Promise<bigint> {
+  const { provider, logger = console } = ctx
+  const routerAddress = Address.parse(router)
+
+  // FeeQuoter requires WRAPPED_NATIVE for native TON
+  const feeTokenAddress = message.feeToken ? Address.parse(message.feeToken) : WRAPPED_NATIVE
+
+  // Get FeeQuoter address via OnRamp
+  let feeQuoterAddress: Address
+  try {
+    const { stack: onRampStack } = await provider.runMethod(routerAddress, 'onRamp', [
+      { type: 'int', value: destChainSelector },
+    ])
+    const onRampAddress = onRampStack.readAddress()
+    logger.debug('OnRamp:', onRampAddress.toString())
+
+    const { stack: feeQuoterStack } = await provider.runMethod(onRampAddress, 'feeQuoter', [
+      { type: 'int', value: destChainSelector },
+    ])
+    feeQuoterAddress = feeQuoterStack.readAddress()
+    logger.debug('FeeQuoter:', feeQuoterAddress.toString())
+  } catch (e) {
+    throw new CCIPError(
+      CCIPErrorCode.CONTRACT_TYPE_INVALID,
+      `Could not get FeeQuoter address: ${e instanceof Error ? e.message : String(e)}`,
+    )
+  }
+
+  // Build stack parameters for validatedFee call
+  const paddedReceiver = bytesToBuffer(zeroPadValue(getDataBytes(message.receiver), 32))
+  const receiverSlice = beginCell().storeBuffer(paddedReceiver).endCell()
+  const dataCell = beginCell()
+    .storeBuffer(bytesToBuffer(message.data || '0x'))
+    .endCell()
+  const tokenAmountsCell = encodeTokenAmounts(message.tokenAmounts)
+  const extraArgsCell = encodeExtraArgsCell(message.extraArgs)
+  const feeTokenSlice = beginCell().storeAddress(feeTokenAddress).endCell()
+
+  const { stack: feeStack } = await provider.runMethod(feeQuoterAddress, 'validatedFee', [
+    { type: 'int', value: 0n },
+    { type: 'int', value: destChainSelector },
+    { type: 'slice', cell: receiverSlice },
+    { type: 'cell', cell: dataCell },
+    { type: 'cell', cell: tokenAmountsCell },
+    { type: 'slice', cell: feeTokenSlice },
+    { type: 'cell', cell: extraArgsCell },
+  ])
+
+  const fee = feeStack.readBigNumber()
+  if (fee < 0n) {
+    throw new CCIPError(CCIPErrorCode.MESSAGE_INVALID, `Invalid fee: ${fee}`)
+  }
+  logger.debug('CCIP fee:', fee.toString(), 'nanotons')
+  return fee
+}
+
+/**
+ * Generates an unsigned CCIP send transaction for the Router.
+ *
+ * @param ctx - Context with TonClient provider and logger
+ * @param _sender - Sender address (unused, for interface compatibility)
+ * @param router - Router contract address
+ * @param destChainSelector - Destination chain selector
+ * @param message - CCIP message with fee included
+ * @param opts - Optional gas buffer override
+ * @returns Unsigned transaction ready for signing
+ */
+export function generateUnsignedCcipSend(
+  ctx: { provider: TonClient } & WithLogger,
+  _sender: string,
+  router: string,
+  destChainSelector: bigint,
+  message: AnyMessage & { fee: bigint },
+  opts?: { gasBuffer?: bigint },
+): Omit<UnsignedTONTx, 'family'> {
+  const { logger = console } = ctx
+  const gasBuffer = opts?.gasBuffer ?? DEFAULT_GAS_BUFFER
+
+  // Router accepts addr_none for native TON (unlike FeeQuoter which needs WRAPPED_NATIVE)
+  const feeTokenAddress = message.feeToken ? Address.parse(message.feeToken) : null
+
+  const ccipSendCell = buildCcipSendCell(destChainSelector, message, feeTokenAddress)
+  const totalValue = message.fee + gasBuffer
+
+  logger.debug('Generating ccipSend tx to router:', router)
+  logger.debug('Total value:', totalValue.toString(), 'nanotons')
+
+  return {
+    to: router,
+    body: ccipSendCell,
+    value: totalValue,
+  }
+}