Add shared TP.onLockOrBurnTransferFinalize flow

krebernisak · krebernisak · commit c53ea4d82245 · 2026-06-16T14:17:16.000+02:00
diff --git a/contracts/contracts/ccip/pools/burn_mint_token_pool/contract.tolk b/contracts/contracts/ccip/pools/burn_mint_token_pool/contract.tolk
@@ -117,14 +117,11 @@ fun onLockOrBurnTransfer(
 
     val jettonClient = st.jettonClient.load();
     st.pendingBurns.set(requestMsg.queryId, BurnMintTokenPool_PendingBurn {
-        replyTo: requestMsg.replyTo,
-        request: requestMsg.request,
-        out: prepared.out.toCell(),
-        destTokenAmount: prepared.destTokenAmount,
+        forwardPayload: fwdp,
         expectedSender: jettonClient.masterAddress,
     }.toCell());
 
-    createMessage({
+    val burnMsg = createMessage({
         bounce: true,
         value: BurnMintTokenPool_BURN_VALUE,
         dest: sender,
@@ -134,7 +131,8 @@ fun onLockOrBurnTransfer(
             sendExcessesTo: contract.getAddress(),
             customPayload: null,
         },
-    }).send(SEND_MODE_PAY_FEES_SEPARATELY);
+    });
+    burnMsg.send(SEND_MODE_PAY_FEES_SEPARATELY);
 
     return st;
 }
@@ -197,30 +195,9 @@ fun onReturnExcessesBack(
         assert(sender == pending.expectedSender, Error.UnexpectedBurnConfirmationSender);
 
         st.pendingBurns.delete(msg.queryId);
-        val request = pending.request.load();
-
-        emit(TOKEN_POOL_LOCKED_OR_BURNED_TOPIC, TokenPool_LockedOrBurned {
-            remoteChainSelector: request.remoteChainSelector,
-            details: TokenPool_LockedOrBurnedDetails {
-                token: request.localToken,
-                sender: request.originalSender,
-                amount: pending.destTokenAmount,
-            }.toCell(),
-        });
 
-        if (pending.replyTo != null) {
-            createMessage({
-                bounce: true,
-                value: BurnMintTokenPool_REPLY_VALUE,
-                dest: pending.replyTo!,
-                body: TokenPool_LockOrBurnResponse {
-                    queryId: msg.queryId,
-                    out: pending.out,
-                    destTokenAmount: pending.destTokenAmount,
-                },
-            }).send(SEND_MODE_PAY_FEES_SEPARATELY | SEND_MODE_CARRY_ALL_REMAINING_MESSAGE_VALUE);
-        }
-        return;
+        var pool = loadPool(st);
+        return pool.onLockOrBurnTransferFinalize(pending.forwardPayload);
     }
 
     val mintEntry = st.pendingMints.get(msg.queryId);
@@ -250,7 +227,7 @@ fun onReturnExcessesBack(
             bounce: true,
             value: BurnMintTokenPool_REPLY_VALUE,
             dest: pending.replyTo!,
-            body: TokenPool_ReleaseOrMintResponse {
+            body: TokenPool_ReleaseOrMintFinished {
                 queryId: msg.queryId,
                 out: pending.out,
             },
diff --git a/contracts/contracts/ccip/pools/burn_mint_token_pool/types.tolk b/contracts/contracts/ccip/pools/burn_mint_token_pool/types.tolk
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: BUSL-1.1
 import "../../../lib/jetton/jetton_client"
-import "../../rmn_remote/lib"
+import "../messages"
 import "../types"
 
 const BurnMintTokenPool_CONTRACT_NAME = "link.chain.ton.ccip.BurnMintTokenPool".literalSlice();
@@ -11,15 +11,12 @@ const BurnMintTokenPool_MINT_VALUE = ton("0.1");
 const BurnMintTokenPool_REPLY_VALUE = ton("0.01");
 
 struct BurnMintTokenPool_PendingBurn {
-    replyTo: address? = null;
-    request: Cell<TokenPool_LockOrBurnInV1>;
-    out: Cell<TokenPool_LockOrBurnOutV1>;
-    destTokenAmount: uint256;
+    forwardPayload: TokenPool_LockOrBurnForwardPayload;
     expectedSender: address;
 }
 
 struct BurnMintTokenPool_PendingMint {
-    replyTo: address? = null;
+    replyTo: address?;
     request: Cell<TokenPool_ReleaseOrMintInV1>;
     out: Cell<TokenPool_ReleaseOrMintOutV1>;
     expectedSender: address;
diff --git a/contracts/contracts/ccip/pools/events.tolk b/contracts/contracts/ccip/pools/events.tolk
@@ -14,12 +14,6 @@ const TOKEN_POOL_RAMP_ACCESS_UPDATED_TOPIC = stringCrc32("TokenPool_RampAccessUp
 const TOKEN_POOL_CURSED_SUBJECTS_UPDATED_TOPIC = stringCrc32("TokenPool_CursedSubjectsUpdated");
 const TOKEN_POOL_FINALITY_CONFIG_SET_TOPIC = stringCrc32("TokenPool_FinalityConfigSet");
 
-struct TokenPool_LockedOrBurnedDetails {
-    token: address;
-    sender: address;
-    amount: uint256;
-}
-
 //   event LockedOrBurned(uint64 indexed remoteChainSelector, address token, address sender, uint256 amount);
 //   event ReleasedOrMinted(
 //     uint64 indexed remoteChainSelector, address token, address sender, address recipient, uint256 amount
@@ -29,9 +23,15 @@ struct TokenPool_LockedOrBurned {
     details: Cell<TokenPool_LockedOrBurnedDetails>;
 }
 
-struct TokenPool_ReleasedOrMintedParticipants {
+struct TokenPool_LockedOrBurnedDetails {
+    token: address;
     sender: address;
-    recipient: address;
+    amount: uint256;
+}
+
+struct TokenPool_ReleasedOrMinted {
+    remoteChainSelector: uint64;
+    details: Cell<TokenPool_ReleasedOrMintedDetails>;
 }
 
 struct TokenPool_ReleasedOrMintedDetails {
@@ -40,9 +40,9 @@ struct TokenPool_ReleasedOrMintedDetails {
     participants: Cell<TokenPool_ReleasedOrMintedParticipants>;
 }
 
-struct TokenPool_ReleasedOrMinted {
-    remoteChainSelector: uint64;
-    details: Cell<TokenPool_ReleasedOrMintedDetails>;
+struct TokenPool_ReleasedOrMintedParticipants {
+    sender: address;
+    recipient: address;
 }
 
 struct TokenPool_ChainAdded {
diff --git a/contracts/contracts/ccip/pools/lock_release_token_pool/contract.tolk b/contracts/contracts/ccip/pools/lock_release_token_pool/contract.tolk
@@ -77,8 +77,6 @@ fun onLockOrBurnTransfer(
     var isValidPayload = true; // TODO: safely inspect the payload
     val fwdps = loadForwardPayloadAsSlice(msg.forwardPayload);
     val fwdp = TokenPool_LockOrBurnForwardPayload.fromSlice(fwdps!);
-    val requestMsg = lazy fwdp.requestMsg.load();
-    val prepared = lazy fwdp.prepared.load();
 
     // TODO: can we trust (any) JettonWallet forward payloads?
     // assert(request.amount == msg.jettonAmount, TokenPool_Error.AmountMismatch);
@@ -107,29 +105,8 @@ fun onLockOrBurnTransfer(
         return st;
     }
 
-    var request = requestMsg.request.load();
-    emit(TOKEN_POOL_LOCKED_OR_BURNED_TOPIC, TokenPool_LockedOrBurned {
-        remoteChainSelector: request.remoteChainSelector,
-        details: TokenPool_LockedOrBurnedDetails {
-            token: request.localToken,
-            sender: msg.transferInitiator!,
-            amount: prepared.destTokenAmount,
-        }.toCell(),
-    });
-
-    // TODO: we should reply in any case, send a message to the OnRamp to indicate that the lockOrBurn was processed
-    if (requestMsg.replyTo != null) {
-        createMessage({
-            bounce: true,
-            value: 0,
-            dest: requestMsg.replyTo!,
-            body: TokenPool_LockOrBurnResponse {
-                queryId: requestMsg.queryId,
-                out: prepared.out.toCell(),
-                destTokenAmount: prepared.destTokenAmount,
-            },
-        }).send(SEND_MODE_CARRY_ALL_REMAINING_MESSAGE_VALUE);
-    }
+    var pool = loadPool(st);
+    pool.onLockOrBurnTransferFinalize(fwdp);
 
     return st;
 }
@@ -207,7 +184,7 @@ fun onReturnExcessesBack(
             bounce: true,
             value: LockReleaseTokenPool_REPLY_VALUE,
             dest: pending.replyTo!,
-            body: TokenPool_ReleaseOrMintResponse {
+            body: TokenPool_ReleaseOrMintFinished {
                 queryId: msg.queryId,
                 out: pending.out,
             },
diff --git a/contracts/contracts/ccip/pools/lock_release_token_pool/events.tolk b/contracts/contracts/ccip/pools/lock_release_token_pool/events.tolk
diff --git a/contracts/contracts/ccip/pools/lock_release_token_pool/types.tolk b/contracts/contracts/ccip/pools/lock_release_token_pool/types.tolk
@@ -8,7 +8,7 @@ const LockReleaseTokenPool_RELEASE_TRANSFER_VALUE = ton("0.05");
 const LockReleaseTokenPool_REPLY_VALUE = ton("0.01");
 
 struct LockReleaseTokenPool_PendingRelease {
-    replyTo: address? = null;
+    replyTo: address?;
     request: Cell<TokenPool_ReleaseOrMintInV1>;
     out: Cell<TokenPool_ReleaseOrMintOutV1>;
     expectedSender: address;
diff --git a/contracts/contracts/ccip/pools/messages.tolk b/contracts/contracts/ccip/pools/messages.tolk
@@ -110,14 +110,14 @@ struct (0xfa7da444) TokenPool_LockOrBurnWithdraw {
     request: Cell<TokenPool_LockOrBurnInV1>; // TODO: consider renaming
 }
 
-struct (0x6c060424) TokenPool_LockOrBurnResponse {
+struct (0x6c060424) TokenPool_LockOrBurnFinished {
     queryId: uint64;
     // TODO: unwrap and inline this type
     out: Cell<TokenPool_LockOrBurnOutV1>;
     destTokenAmount: uint256;
 }
 
-struct (0x78dc2232) TokenPool_ReleaseOrMintResponse {
+struct (0x78dc2232) TokenPool_ReleaseOrMintFinished {
     queryId: uint64;
     out: Cell<TokenPool_ReleaseOrMintOutV1>;
 }
@@ -129,6 +129,6 @@ struct (0xef0cb36e) TokenPool_ReleaseOrMintFailure {
 
 type TokenPool_OutMessage = 
     | TokenPool_LockOrBurnWithdraw
-    | TokenPool_LockOrBurnResponse
-    | TokenPool_ReleaseOrMintResponse
-    | TokenPool_ReleaseOrMintFailure;
+    | TokenPool_LockOrBurnFinished
+    | TokenPool_ReleaseOrMintFinished
+    | TokenPool_ReleaseOrMintFailure;
diff --git a/contracts/contracts/ccip/pools/token_pool.tolk b/contracts/contracts/ccip/pools/token_pool.tolk
@@ -639,9 +639,6 @@ fun TokenPool<T>.validateLockOrBurn(
     self.preflightCheck(request, requestedFinalityConfig, tokenArgs, destTokenAmount);
 
     return TokenPool_LockOrBurnPrepared {
-        request: request.toCell(),
-        requestedFinalityConfig,
-        tokenArgs,
         feeAmount,
         destTokenAmount,
         usingFastFinality,
@@ -713,8 +710,41 @@ fun TokenPool<T>.onLockOrBurnTransfer(
     if (self.hooks != null && self.hooks.onLockOrBurnTransfer != null) {
         self.context = self.hooks.onLockOrBurnTransfer(self.context!, sender, msg);
     }
+
+    // TODO: 
 }
 
+fun TokenPool<T>.onLockOrBurnTransferFinalize(
+    mutate self,
+    fwdPayload: TokenPool_LockOrBurnForwardPayload,
+): void {
+    val requestMsg = lazy fwdPayload.requestMsg.load();
+    val prepared = lazy fwdPayload.prepared.load();
+
+    var request = requestMsg.request.load();
+    emit(TOKEN_POOL_LOCKED_OR_BURNED_TOPIC, TokenPool_LockedOrBurned {
+        remoteChainSelector: request.remoteChainSelector,
+        details: TokenPool_LockedOrBurnedDetails {
+            token: request.localToken,
+            sender: request.originalSender,
+            amount: prepared.destTokenAmount,
+        }.toCell(),
+    });
+
+    // TODO: we should reply in any case, send a message to the OnRamp to indicate that the lockOrBurn was processed
+    if (requestMsg.replyTo != null) {
+        createMessage({
+            bounce: true,
+            value: 0,
+            dest: requestMsg.replyTo!,
+            body: TokenPool_LockOrBurnFinished {
+                queryId: requestMsg.queryId,
+                out: prepared.out.toCell(),
+                destTokenAmount: prepared.destTokenAmount,
+            },
+        }).send(SEND_MODE_CARRY_ALL_REMAINING_MESSAGE_VALUE);
+    }
+}
 
 // function lockOrBurn(
 //     Pool.LockOrBurnInV1 calldata lockOrBurnIn,
diff --git a/contracts/contracts/ccip/pools/token_pool_contract.tolk b/contracts/contracts/ccip/pools/token_pool_contract.tolk
@@ -18,8 +18,8 @@ contract TokenPool {
     // TODO: should be used in hooks of the core library,
     // but for now we need to register them here.
     forceAbiExport: TokenPool_LockOrBurn
-        | TokenPool_LockOrBurnResponse
-        | TokenPool_ReleaseOrMintResponse
+        | TokenPool_LockOrBurnFinished
+        | TokenPool_ReleaseOrMintFinished
 }
 
 fun onInternalMessage(_: InMessage) {
diff --git a/contracts/contracts/ccip/pools/types.tolk b/contracts/contracts/ccip/pools/types.tolk
@@ -78,9 +78,6 @@ struct TokenPool_TokenTransferFeeConfigArgs {
 // TODO: triage new types below
 
 struct TokenPool_LockOrBurnPrepared {
-    request: Cell<TokenPool_LockOrBurnInV1>;
-    requestedFinalityConfig: uint32;
-    tokenArgs: cell?;
     feeAmount: uint256;
     destTokenAmount: uint256;
     usingFastFinality: bool;
diff --git a/contracts/tests/ccip/pools/BurnMintTokenPool.spec.ts b/contracts/tests/ccip/pools/BurnMintTokenPool.spec.ts
@@ -19,9 +19,9 @@ import {
   TokenPool_ChainUpdate,
   TokenPool_LockOrBurn,
   TokenPool_LockOrBurnInV1,
-  TokenPool_LockOrBurnResponse,
+  TokenPool_LockOrBurnFinished,
   TokenPool_ReleaseOrMintInV1,
-  TokenPool_ReleaseOrMintResponse,
+  TokenPool_ReleaseOrMintFinished,
   TokenPool_MirroredPolicy,
   TokenPool_DynamicConfig,
 } from '../../../wrappers/gen/ccip/pools/TokenPool'
@@ -399,7 +399,8 @@ describe('BurnMintTokenPool', () => {
         responseDestination: deployer.address,
         customPayload: null,
         forwardTonAmount: toNano('0.2'),
-        forwardPayload: TokenPool_LockOrBurn.toCell( // TODO: fixme, this now requires elaborate context - TokenPool_LockOrBurnForwardPayload
+        forwardPayload: TokenPool_LockOrBurn.toCell(
+          // TODO: fixme, this now requires elaborate context - TokenPool_LockOrBurnForwardPayload
           TokenPool_LockOrBurn.create({
             queryId: 11n,
             request: {
@@ -432,7 +433,7 @@ describe('BurnMintTokenPool', () => {
       from: burnMintPool.address,
       to: deployer.address,
       success: true,
-      op: TokenPool_LockOrBurnResponse.PREFIX,
+      op: TokenPool_LockOrBurnFinished.PREFIX,
     })
   })
 
@@ -477,10 +478,10 @@ describe('BurnMintTokenPool', () => {
       from: burnMintPool.address,
       to: deployer.address,
       success: true,
-      op: TokenPool_ReleaseOrMintResponse.PREFIX,
+      op: TokenPool_ReleaseOrMintFinished.PREFIX,
       body(body) {
         if (!body) return false
-        const response = TokenPool_ReleaseOrMintResponse.fromSlice(body.beginParse())
+        const response = TokenPool_ReleaseOrMintFinished.fromSlice(body.beginParse())
         return response.queryId === 22n && response.out.ref.destinationAmount === toNano('2')
       },
     })
@@ -524,7 +525,7 @@ describe('BurnMintTokenPool', () => {
       return (
         tx.inMessage?.info?.src?.equals?.(burnMintPool.address) &&
         tx.inMessage?.body?.beginParse?.().preloadUint?.(32) ===
-          TokenPool_ReleaseOrMintResponse.PREFIX
+          TokenPool_ReleaseOrMintFinished.PREFIX
       )
     })
     expect(releaseResponses.length).toBe(0)
diff --git a/contracts/tests/ccip/pools/LockReleaseTokenPool.spec.ts b/contracts/tests/ccip/pools/LockReleaseTokenPool.spec.ts
diff --git a/contracts/wrappers/gen/ccip/pools/BurnMintTokenPool.ts b/contracts/wrappers/gen/ccip/pools/BurnMintTokenPool.ts
diff --git a/contracts/wrappers/gen/ccip/pools/LockReleaseTokenPool.ts b/contracts/wrappers/gen/ccip/pools/LockReleaseTokenPool.ts
diff --git a/contracts/wrappers/gen/ccip/pools/TokenPool.ts b/contracts/wrappers/gen/ccip/pools/TokenPool.ts
