solana: add token-router-sdk

Author: a5-pickle

solana/Cargo.lock

@@ -0,0 +1,20 @@
+[package]
+name = "token-router-sdk"
+edition.workspace = true
+version.workspace = true
+authors.workspace = true
+license.workspace = true
+homepage.workspace = true
+repository.workspace = true
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[features]
+testnet = ["token-router/testnet"]
+localnet = ["token-router/localnet"]
+
+[dependencies]
+token-router = { workspace = true, features = ["cpi"] }
+
+wormhole-io.workspace = true
+anchor-lang.workspace = true

solana/modules/token-router-sdk/Cargo.toml

@@ -0,0 +1,2 @@
+mod prepared_fill;
+pub use prepared_fill::*;

solana/modules/token-router-sdk/src/accounts/mod.rs

@@ -0,0 +1,62 @@
+use std::ops::Deref;
+
+use anchor_lang::{prelude::*, Discriminator};
+use token_router::state::PreparedFillInfo;
+use wormhole_io::{Readable, TypePrefixedPayload};
+
+#[derive(Debug, AnchorSerialize, AnchorDeserialize, Clone)]
+pub struct PreparedFill<P: TypePrefixedPayload> {
+    pub info: PreparedFillInfo,
+    pub message_size: u32,
+    pub redeemer_message: P,
+}
+
+impl<P: TypePrefixedPayload> Owner for PreparedFill<P> {
+    fn owner() -> Pubkey {
+        token_router::ID
+    }
+}
+
+impl<P: TypePrefixedPayload> Discriminator for PreparedFill<P> {
+    const DISCRIMINATOR: [u8; 8] = token_router::state::PreparedFill::DISCRIMINATOR;
+}
+
+impl<P: TypePrefixedPayload> AccountSerialize for PreparedFill<P> {
+    fn try_serialize<W: std::io::prelude::Write>(&self, writer: &mut W) -> Result<()> {
+        Self::DISCRIMINATOR.serialize(writer)?;
+        self.info.serialize(writer)?;
+        self.message_size.serialize(writer)?;
+        self.redeemer_message.write(writer)?;
+        Ok(())
+    }
+}
+
+impl<P: TypePrefixedPayload> AccountDeserialize for PreparedFill<P> {
+    fn try_deserialize(buf: &mut &[u8]) -> Result<Self> {
+        let disc_len = Self::DISCRIMINATOR.len();
+        if buf.len() < disc_len {
+            return err!(ErrorCode::AccountDidNotDeserialize);
+        };
+        if Self::DISCRIMINATOR != buf[..disc_len] {
+            return err!(ErrorCode::AccountDidNotDeserialize);
+        }
+        Self::try_deserialize_unchecked(buf)
+    }
+
+    fn try_deserialize_unchecked(buf: &mut &[u8]) -> Result<Self> {
+        let mut data = &buf[Self::DISCRIMINATOR.len()..];
+        Ok(Self {
+            info: AnchorDeserialize::deserialize(&mut data)?,
+            message_size: AnchorDeserialize::deserialize(&mut data)?,
+            redeemer_message: Readable::read(&mut data)?,
+        })
+    }
+}
+
+impl<P: TypePrefixedPayload> Deref for PreparedFill<P> {
+    type Target = PreparedFillInfo;
+
+    fn deref(&self) -> &Self::Target {
+        &self.info
+    }
+}

solana/modules/token-router-sdk/src/accounts/prepared_fill.rs

@@ -0,0 +1,3 @@
+pub mod accounts;
+
+pub use token_router::cpi::*;

solana/modules/token-router-sdk/src/lib.rs

@@ -1,6 +1,6 @@
 use crate::{
     error::TokenRouterError,
-    state::{Custodian, FillType, PreparedFill},
+    state::{Custodian, FillType, PreparedFill, PreparedFillInfo},
 };
 use anchor_lang::{prelude::*, system_program};
 use anchor_spl::token;
@@ -263,14 +263,16 @@ fn handle_redeem_fill_cctp(ctx: Context<RedeemCctpFill>, args: CctpMessageArgs)
 
     // Set prepared fill data.
     ctx.accounts.prepared_fill.set_inner(PreparedFill {
-        vaa_hash: vaa.digest().0,
-        bump: ctx.bumps.prepared_fill,
-        prepared_custody_token_bump: ctx.bumps.prepared_custody_token,
-        redeemer: Pubkey::from(fill.redeemer()),
-        prepared_by: ctx.accounts.payer.key(),
-        fill_type: FillType::WormholeCctpDeposit,
-        source_chain: fill.source_chain(),
-        order_sender: fill.order_sender(),
+        info: PreparedFillInfo {
+            vaa_hash: vaa.digest().0,
+            bump: ctx.bumps.prepared_fill,
+            prepared_custody_token_bump: ctx.bumps.prepared_custody_token,
+            redeemer: Pubkey::from(fill.redeemer()),
+            prepared_by: ctx.accounts.payer.key(),
+            fill_type: FillType::WormholeCctpDeposit,
+            source_chain: fill.source_chain(),
+            order_sender: fill.order_sender(),
+        },
         redeemer_message: fill.message_to_vec(),
     });
 

solana/programs/token-router/src/processor/redeem_fill/cctp.rs

@@ -1,6 +1,6 @@
 use crate::{
     error::TokenRouterError,
-    state::{Custodian, FillType, PreparedFill},
+    state::{Custodian, FillType, PreparedFill, PreparedFillInfo},
 };
 use anchor_lang::{prelude::*, system_program};
 use anchor_spl::token;
@@ -150,14 +150,16 @@ fn handle_redeem_fast_fill(ctx: Context<RedeemFastFill>) -> Result<()> {
 
     // Set prepared fill data.
     ctx.accounts.prepared_fill.set_inner(PreparedFill {
-        vaa_hash: vaa.digest().0,
-        bump: ctx.bumps.prepared_fill,
-        prepared_custody_token_bump: ctx.bumps.prepared_custody_token,
-        redeemer: Pubkey::from(fill.redeemer()),
-        prepared_by: ctx.accounts.payer.key(),
-        fill_type: FillType::FastFill,
-        source_chain: fill.source_chain(),
-        order_sender: fill.order_sender(),
+        info: PreparedFillInfo {
+            vaa_hash: vaa.digest().0,
+            bump: ctx.bumps.prepared_fill,
+            prepared_custody_token_bump: ctx.bumps.prepared_custody_token,
+            redeemer: Pubkey::from(fill.redeemer()),
+            prepared_by: ctx.accounts.payer.key(),
+            fill_type: FillType::FastFill,
+            source_chain: fill.source_chain(),
+            order_sender: fill.order_sender(),
+        },
         redeemer_message: fill.message_to_vec(),
     });
 

solana/programs/token-router/src/processor/redeem_fill/fast.rs

@@ -7,9 +7,8 @@ pub enum FillType {
     FastFill,
 }
 
-#[account]
-#[derive(Debug)]
-pub struct PreparedFill {
+#[derive(Debug, AnchorSerialize, AnchorDeserialize, Clone, InitSpace)]
+pub struct PreparedFillInfo {
     pub vaa_hash: [u8; 32],
     pub bump: u8,
     pub prepared_custody_token_bump: u8,
@@ -21,6 +20,12 @@ pub struct PreparedFill {
     pub source_chain: u16,
     pub order_sender: [u8; 32],
     pub redeemer: Pubkey,
+}
+
+#[account]
+#[derive(Debug)]
+pub struct PreparedFill {
+    pub info: PreparedFillInfo,
     pub redeemer_message: Vec<u8>,
 }
 
@@ -31,3 +36,11 @@ impl PreparedFill {
         8 + 32 + 1 + 32 + 32 + FillType::INIT_SPACE + 8 + 2 + 32 + 4 + payload_len
     }
 }
+
+impl std::ops::Deref for PreparedFill {
+    type Target = PreparedFillInfo;
+
+    fn deref(&self) -> &Self::Target {
+        &self.info
+    }
+}

solana/programs/token-router/src/state/prepared_fill.rs

@@ -7,7 +7,7 @@ export type FillType = {
     fastFill?: {};
 };
 
-export class PreparedFill {
+export type PreparedFillInfo = {
     vaaHash: Array<number>;
     bump: number;
     preparedCustodyTokenBump: number;
@@ -16,28 +16,14 @@ export class PreparedFill {
     sourceChain: number;
     orderSender: Array<number>;
     redeemer: PublicKey;
+};
+
+export class PreparedFill {
+    info: PreparedFillInfo;
     redeemerMessage: Buffer;
 
-    constructor(
-        vaaHash: Array<number>,
-        bump: number,
-        preparedCustodyTokenBump: number,
-        redeemer: PublicKey,
-        preparedBy: PublicKey,
-        fillType: FillType,
-        amount: BN,
-        sourceChain: number,
-        orderSender: Array<number>,
-        redeemerMessage: Buffer,
-    ) {
-        this.vaaHash = vaaHash;
-        this.bump = bump;
-        this.preparedCustodyTokenBump = preparedCustodyTokenBump;
-        this.preparedBy = preparedBy;
-        this.fillType = fillType;
-        this.sourceChain = sourceChain;
-        this.orderSender = orderSender;
-        this.redeemer = redeemer;
+    constructor(info: PreparedFillInfo, redeemerMessage: Buffer) {
+        this.info = info;
         this.redeemerMessage = redeemerMessage;
     }
 

solana/ts/src/tokenRouter/state/PreparedFill.ts

@@ -364,18 +364,21 @@ describe("Matching Engine <> Token Router", function () {
 
                 {
                     const preparedFillData = await tokenRouter.fetchPreparedFill(preparedFill);
-                    const { bump, preparedCustodyTokenBump } = preparedFillData;
+                    const {
+                        info: { bump, preparedCustodyTokenBump },
+                    } = preparedFillData;
                     expect(preparedFillData).to.eql(
                         new tokenRouterSdk.PreparedFill(
-                            Array.from(vaaHash),
-                            bump,
-                            preparedCustodyTokenBump,
-                            redeemer.publicKey,
-                            payer.publicKey,
-                            { fastFill: {} },
-                            bigintToU64BN(amount),
-                            foreignChain,
-                            orderSender,
+                            {
+                                vaaHash: Array.from(vaaHash),
+                                bump,
+                                preparedCustodyTokenBump,
+                                redeemer: redeemer.publicKey,
+                                preparedBy: payer.publicKey,
+                                fillType: { fastFill: {} },
+                                sourceChain: foreignChain,
+                                orderSender,
+                            },
                             redeemerMessage,
                         ),
                     );