[NONEVM-2960] [Router] get fee before calling CCIPSend (offchain) (#333)

* ref: cross-chain address encoding and expose feequoter addr getter on OnRamp

* feat: off chain getValidatedFee

* chore: rm unsued function

* ref: use stack getter

* ref: stack codec

* ref: move offchain get fee helper

Author: patricios-space

contracts/contracts/ccip/fee_quoter/contract.tolk

@@ -220,11 +220,11 @@ fun DestChainConfig.getValidatedGasPrice(self): (uint112, uint112) {
     return (price.executionGasPrice, price.dataAvailabilityGasPrice)
 }
 
+// Note: Equivalent to validatedFee for cell encoding instead of using stack
 get fun validatedFeeCell(msg: Cell<Router_CCIPSend>): coins {
     return validatedFee(msg.load());
 }
 
-
 get fun validatedFee(msg: Router_CCIPSend): coins {
     var st = lazy Storage.load();
 

contracts/contracts/ccip/onramp/contract.tolk

@@ -274,6 +274,13 @@ get fun destChainConfig(destChainSelector: uint64): OnRamp_DestChainConfig {
     return st.destChainConfigs.mustGet(destChainSelector,Error.UnknownDestChainSelector as int);
 }
 
+// We are taking destChainSelector as param to enable future per-destination feeQuoters
+get fun feeQuoter(destChainSelector: int): address {
+    val st = lazy OnRamp_Storage.load();
+    val config = st.config.load();
+    return config.feeQuoter;
+}
+
 // vec<address>
 get fun allowedSendersList(destChainSelector: uint64): tuple? {
     val st = lazy OnRamp_Storage.load();

contracts/src/ccipSend/fee.ts

@@ -0,0 +1,22 @@
+import { Address, ContractProvider } from '@ton/core'
+import * as rt from '../../wrappers/ccip/Router'
+import * as onr from '../../wrappers/ccip/OnRamp'
+import * as fq from '../../wrappers/ccip/FeeQuoter'
+import { Blockchain } from '@ton/sandbox'
+
+// Gets the validated fee for a CCIPSend message with off-chain getters
+export async function getValidatedFee(
+  blockchain: Blockchain,
+  router: Address,
+  msg: rt.CCIPSend,
+): Promise<bigint> {
+  const routerContract = blockchain.openContract(rt.Router.createFromAddress(router))
+  const orAddress = await routerContract.getOnRamp(msg.destChainSelector)
+  const onRampContract = blockchain.openContract(onr.OnRamp.createFromAddress(orAddress))
+  const feeQuoterAddress = await onRampContract.getFeeQuoter(msg.destChainSelector)
+  const feeQuoterContract = blockchain.openContract(
+    fq.FeeQuoter.createFromAddress(feeQuoterAddress),
+  )
+  const fee = await feeQuoterContract.getValidatedFee(msg)
+  return fee
+}

contracts/tests/ccip/CCIPRouter.spec.ts

@@ -29,6 +29,7 @@ import * as ownable2step from '../../wrappers/libraries/access/Ownable2Step'
 import * as UpgradeableSpec from '../lib/versioning/UpgradeableSpec'
 import * as TypeAndVersionSpec from '../lib/versioning/TypeAndVersionSpec'
 import { dump } from '../utils/prettyPrint'
+import { getValidatedFee } from '../../src/ccipSend/fee'
 
 const CHAINSEL_EVM_TEST_90000001 = 909606746561742123n
 const CHAINSEL_EVM_TEST_90000002 = 5548718428018410741n
@@ -119,7 +120,7 @@ describe('Router', () => {
       print: true,
       blockchainLogs: false,
       vmLogs: 'none',
-      debugLogs: false,
+      debugLogs: true,
     }
     deployer = await blockchain.treasury('deployer')
     sender = await blockchain.treasury('sender')
@@ -648,9 +649,9 @@ describe('Router', () => {
         .asCell(),
     }
 
-    const amount = await getValidatedFee(sender.getSender(), feeQuoter, ccipSend, Cell.EMPTY)
-    console.log('Validated fee:', amount.fee, 'TON')
-    const totalSendValue = amount.fee + toNano('0.5')
+    const fee = await getValidatedFee(blockchain, router.address, ccipSend)
+    console.log('Validated fee:', fee, 'TON')
+    const totalSendValue = fee + toNano('0.5')
 
     // router.ccipSend
     {
@@ -1054,49 +1055,3 @@ function verifyBodyIsRouterCCIPSendACK(
 
   return verifyBodyMessage(body, rt.builder.message.out.ccipSendACK, validations)
 }
-
-/**
- * Requests validateMessage
- */
-async function getValidatedFee(
-  sender: Sender,
-  feeQuoter: SandboxContract<fq.FeeQuoter>,
-  msg: rt.CCIPSend,
-  metadata: Cell,
-): Promise<sendExecutor.MessageValidated> {
-  const res = await feeQuoter.sendGetValidatedFee(sender, {
-    value: toNano('1'),
-    msg: {
-      msg,
-      metadata,
-    },
-  })
-
-  // request
-  expect(res.transactions).toHaveTransaction({
-    from: sender.address,
-    to: feeQuoter.address,
-    success: true,
-  })
-  // response
-  expect(res.transactions).toHaveTransaction({
-    from: feeQuoter.address,
-    to: sender.address,
-    success: true,
-  })
-
-  const tx = res.transactions.find(
-    (tx) =>
-      tx.inMessage?.info.type === 'internal' && tx.inMessage.info.src.equals(feeQuoter.address),
-  )
-
-  if (!tx || tx.inMessage === undefined || tx.inMessage?.info.type !== 'internal') {
-    throw new Error('Failed to find response transaction')
-  }
-  const resp = tx.inMessage
-
-  const body = resp.body.beginParse()
-  expect(body.preloadUint(32)).toBe(sendExecutor.Opcodes.messageValidated)
-  const messageValidated = fq.builder.message.out.messageValidated.load(resp.body.beginParse())
-  return messageValidated
-}

contracts/wrappers/ccip/FeeQuoter.ts

@@ -12,11 +12,12 @@ import {
   SendMode,
   Builder,
   Slice,
+  TupleItem,
 } from '@ton/core'
 
 import * as ownable2step from '../libraries/access/Ownable2Step'
 import * as withdrawable from '../libraries/funding/Withdrawable'
-import { CellCodec } from '../utils'
+import { CellCodec, StackCodec } from '../utils'
 import { asSnakeData, fromSnakeData } from '../../src/utils'
 import * as upgradeable from '../libraries/versioning/Upgradeable'
 import * as typeAndVersion from '../libraries/versioning/TypeAndVersion'
@@ -387,6 +388,36 @@ export const builder = {
     }
   })(),
 }
+
+export const stackBuilder = {
+  data: {
+    ccipSend: ((): StackCodec<rt.CCIPSend> => {
+      return {
+        encode: function (data: rt.CCIPSend): TupleItem[] {
+          return [
+            { type: 'int', value: BigInt(data.queryID ?? 0) },
+            { type: 'int', value: data.destChainSelector },
+            {
+              type: 'slice',
+              cell: beginCell().storeBuffer(data.receiver, data.receiver.length).endCell(),
+            },
+            { type: 'cell', cell: data.data },
+            {
+              type: 'cell',
+              cell: asSnakeData(data.tokenAmounts, rt.builder.data.tokenAmount.encode),
+            },
+            { type: 'slice', cell: beginCell().storeAddress(data.feeToken).endCell() },
+            { type: 'cell', cell: data.extraArgs },
+          ]
+        },
+        load: function (src: TupleItem[]): rt.CCIPSend {
+          throw new Error('Function not implemented.')
+        },
+      }
+    })(),
+  },
+}
+
 export abstract class Params {}
 
 export abstract class Opcodes {
@@ -504,6 +535,20 @@ export class FeeQuoter
     return upgradeable.sendUpgrade(provider, via, value, body)
   }
 
+  async getValidatedFeeCell(provider: ContractProvider, msg: rt.CCIPSend): Promise<bigint> {
+    const result = await provider.get('validatedFeeCell', [
+      { type: 'cell', cell: rt.builder.message.in.ccipSend.encode(msg).asCell() },
+    ])
+
+    return result.stack.readBigNumber()
+  }
+
+  async getValidatedFee(provider: ContractProvider, msg: rt.CCIPSend): Promise<bigint> {
+    const result = await provider.get('validatedFee', stackBuilder.data.ccipSend.encode(msg))
+
+    return result.stack.readBigNumber()
+  }
+
   getTypeAndVersion(provider: ContractProvider): Promise<{ type: string; version: string }> {
     return typeAndVersion.getTypeAndVersion(provider)
   }

contracts/wrappers/ccip/OnRamp.ts

@@ -267,6 +267,12 @@ export class OnRamp implements Contract, withdrawable.Interface {
     return upgradeable.sendUpgrade(provider, via, value, body)
   }
 
+  getFeeQuoter(provider: ContractProvider, destChainSelector: bigint): Promise<Address> {
+    return provider.get('feeQuoter', [{ type: 'int', value: destChainSelector }]).then((res) => {
+      return res.stack.readAddress()
+    })
+  }
+
   getTypeAndVersion(provider: ContractProvider): Promise<{ type: string; version: string }> {
     return typeAndVersion.getTypeAndVersion(provider)
   }

contracts/wrappers/ccip/Router.ts

@@ -390,6 +390,22 @@ export type CCIPReceiveConfirm = {
   rootId: bigint
 }
 
+const crossChainAddressCodec: CellCodec<Buffer> = {
+  encode: (addr: Buffer): Builder => {
+    if (addr.byteLength > 64) {
+      throw new Error('CrossChainAddress too long')
+    }
+    return beginCell().storeUint(addr.length, 8).storeBuffer(addr, addr.length)
+  },
+  load: (src: Slice): Buffer => {
+    const len = Number(src.loadUint(8))
+    if (len > 64) {
+      throw new Error('CrossChainAddress too long')
+    }
+    return src.loadBuffer(len)
+  },
+}
+
 export const builder = {
   data: (() => {
     const contractData: CellCodec<Storage> = {
@@ -496,33 +512,30 @@ export const builder = {
       extraArgs,
       onRamps,
       offRamps,
+      crossChainAddress: crossChainAddressCodec,
     }
   })(),
   message: {
     in: (() => {
       const ccipSend: CellCodec<CCIPSend> = {
         encode: (opts: CCIPSend): Builder => {
-          return (
-            beginCell()
-              .storeUint(Opcodes.ccipSend, 32)
-              .storeUint(opts.queryID ?? 0, 64)
-              .storeUint(opts.destChainSelector, 64)
-              // CrossChainAddress TODO: assert =< 64
-              .storeUint(opts.receiver.byteLength, 8)
-              .storeBuffer(opts.receiver, opts.receiver.byteLength)
-              .storeRef(opts.data)
-              .storeRef(asSnakeData(opts.tokenAmounts, tokenAmountCodec.encode)) // TODO: pack inputs
-              .storeAddress(opts.feeToken)
-
-              .storeRef(opts.extraArgs)
-          )
+          return beginCell()
+            .storeUint(Opcodes.ccipSend, 32)
+            .storeUint(opts.queryID ?? 0, 64)
+            .storeUint(opts.destChainSelector, 64)
+            .storeBuilder(crossChainAddressCodec.encode(opts.receiver))
+            .storeRef(opts.data)
+            .storeRef(asSnakeData(opts.tokenAmounts, tokenAmountCodec.encode)) // TODO: pack inputs
+            .storeAddress(opts.feeToken)
+
+            .storeRef(opts.extraArgs)
         },
         load: function (src: Slice): CCIPSend {
           src.skip(32)
           return {
             queryID: src.loadUint(64),
             destChainSelector: src.loadUintBig(64),
-            receiver: src.loadBuffer(src.loadUint(8)),
+            receiver: crossChainAddressCodec.load(src),
             data: src.loadRef(),
             tokenAmounts: fromSnakeData(src.loadRef(), tokenAmountCodec.load),
             feeToken: src.loadAddress(),

contracts/wrappers/utils.ts

@@ -1,4 +1,4 @@
-import { Builder, Slice } from '@ton/core'
+import { Builder, Slice, TupleItem } from '@ton/core'
 import { createHash } from 'crypto'
 
 /// Returns the facility ID for the given CRC16 key (e.g. stringCrc16("com.chainlink.ton.mcms.Timelock")).
@@ -29,3 +29,8 @@ export interface CellCodec<T> {
   encode: (data: T) => Builder
   load: (src: Slice) => T
 }
+
+export interface StackCodec<T> {
+  encode: (data: T) => TupleItem[]
+  load: (src: TupleItem[]) => T
+}