@layerzerolabs/oft-solana-contracts 1.2.11

package/Anchor.toml

@@ -0,0 +1,7 @@
+[toolchain]
+anchor_version = "1.0.2"
+solana_version = "3.1.10"
+
+[provider]
+cluster = "Localnet"
+wallet = "/dev/null"

package/Cargo.toml

@@ -0,0 +1,33 @@
+[package]
+name = "oft"
+version = "0.1.0"
+description = "Reusable OFT crate for Anchor programs"
+edition = "2021"
+
+[lib]
+crate-type = ["lib"]
+name = "oft"
+
+[profile.release]
+overflow-checks = true
+
+[features]
+default = []
+idl-build = ["anchor-lang/idl-build", "anchor-spl/idl-build"]
+
+[lints.rust]
+unexpected_cfgs = { level = "allow", check-cfg = [
+    "cfg(feature, values(\"anchor-debug\"))",
+] }
+
+[dependencies]
+anchor-lang = { version = "1.0.2", features = ["event-cpi"] }
+anchor-spl = { version = "1.0.2" }
+oft-macros = { path = "macros" }
+spl-type-length-value = { version = "0.9.1", features = ["derive"] }
+spl-discriminator = "0.5.2"
+
+
+
+[dev-dependencies]
+oapp = { path = "dependencies/oapp-solana-contracts" }

package/macros/Cargo.lock

@@ -0,0 +1,128 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "anchor-trait"
+version = "0.1.0"
+dependencies = [
+ "itertools",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "darling"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "itertools"
+version = "0.14.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b192c782037fadd9cfa75548310488aabdbf3d2da73885b31bd0abd03351285"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "oft-macros"
+version = "0.1.0"
+dependencies = [
+ "anchor-trait",
+ "darling",
+ "itertools",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"

package/macros/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "oft-macros"
+version = "0.1.0"
+description = "Procedural macros for OFT in Anchor programs"
+edition = "2021"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+darling = "0.20"
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = { version = "2.0", features = ["full", "parsing"] }
+itertools = "0.14"
+anchor-trait = { path = "../dependencies/framework-solana-anchor-trait" }

package/macros/src/instructions/mod.rs

@@ -0,0 +1,26 @@
+mod oft_type;
+mod quote_oft;
+mod quote_send;
+mod send;
+mod shared_decimals;
+mod token;
+
+use anchor_trait::declare_instructions;
+
+/// OFT codegen context type used to bind `InstructionSpec` and `InstructionSet`.
+///
+/// The current OFT instruction specs do not read shared context data, so this
+/// remains empty until a generated instruction needs domain-specific inputs.
+pub(crate) struct CodegenContext {}
+
+declare_instructions! {
+    name    = OftInstructionSet;
+    context = CodegenContext;
+
+    OftType                  => oft_type,
+    Token                    => token,
+    SharedDecimals           => shared_decimals,
+    QuoteOft                 => quote_oft,
+    QuoteSend                => quote_send,
+    Send                     => send,
+}

package/macros/src/instructions/oft_type.rs

@@ -0,0 +1,17 @@
+//! Code generator for the `oft_type` instruction.
+//!
+//! Solana: returns the OFT mode.
+//! No default implementation — users MUST provide a custom handler.
+
+use crate::instructions::CodegenContext;
+use anchor_trait::InstructionSpec;
+use quote::quote;
+
+pub(super) fn spec() -> InstructionSpec<CodegenContext> {
+    InstructionSpec {
+        params_type: None,
+        return_type: quote!(::oft::types::OftType),
+        is_view: true,
+        default_impl: None,
+    }
+}

package/macros/src/instructions/quote_oft.rs

@@ -0,0 +1,17 @@
+//! Code generator for the `quote_oft` instruction.
+//!
+//! EVM: IOFT.quoteOFT(SendParam) → (OFTLimit, OFTFeeDetail[], OFTReceipt)
+//! No default implementation — users MUST provide a custom handler.
+
+use crate::instructions::CodegenContext;
+use anchor_trait::InstructionSpec;
+use quote::quote;
+
+pub(super) fn spec() -> InstructionSpec<CodegenContext> {
+    InstructionSpec {
+        params_type: Some(quote!(::oft::types::QuoteOFTParams)),
+        return_type: quote!(::oft::types::QuoteOFTResult),
+        is_view: true,
+        default_impl: None,
+    }
+}

package/macros/src/instructions/quote_send.rs

@@ -0,0 +1,17 @@
+//! Code generator for the `quote_send` instruction.
+//!
+//! EVM: IOFT.quoteSend(SendParam, bool _payInLzToken) → MessagingFee
+//! No default implementation — users MUST provide a custom handler.
+
+use crate::instructions::CodegenContext;
+use anchor_trait::InstructionSpec;
+use quote::quote;
+
+pub(super) fn spec() -> InstructionSpec<CodegenContext> {
+    InstructionSpec {
+        params_type: Some(quote!(::oft::types::QuoteSendParams)),
+        return_type: quote!((::oapp::endpoint::types::MessagingFee)),
+        is_view: true,
+        default_impl: None,
+    }
+}

package/macros/src/instructions/send.rs

@@ -0,0 +1,17 @@
+//! Code generator for the `send` instruction.
+//!
+//! EVM: IOFT.send(SendParam, MessagingFee, address _refundAddress) → (MessagingReceipt, OFTReceipt)
+//! No default implementation — users MUST provide a custom handler.
+
+use crate::instructions::CodegenContext;
+use anchor_trait::InstructionSpec;
+use quote::quote;
+
+pub(super) fn spec() -> InstructionSpec<CodegenContext> {
+    InstructionSpec {
+        params_type: Some(quote!(::oft::types::SendParams)),
+        return_type: quote!((::oapp::endpoint::types::MessagingReceipt, ::oft::types::OFTReceipt)),
+        is_view: false,
+        default_impl: None,
+    }
+}

package/macros/src/instructions/shared_decimals.rs

@@ -0,0 +1,17 @@
+//! Code generator for the `shared_decimals` instruction.
+//!
+//! EVM: IOFT.sharedDecimals() → uint8
+//! No default implementation — users MUST provide a custom handler.
+
+use crate::instructions::CodegenContext;
+use anchor_trait::InstructionSpec;
+use quote::quote;
+
+pub(super) fn spec() -> InstructionSpec<CodegenContext> {
+    InstructionSpec {
+        params_type: None,
+        return_type: quote!(u8),
+        is_view: true,
+        default_impl: None,
+    }
+}

package/macros/src/instructions/token.rs

@@ -0,0 +1,17 @@
+//! Code generator for the `oft_token` instruction.
+//!
+//! EVM: IOFT.token() → address
+//! No default implementation — users MUST provide a custom handler.
+
+use crate::instructions::CodegenContext;
+use anchor_trait::InstructionSpec;
+use quote::quote;
+
+pub(super) fn spec() -> InstructionSpec<CodegenContext> {
+    InstructionSpec {
+        params_type: None,
+        return_type: quote!(Pubkey),
+        is_view: true,
+        default_impl: None,
+    }
+}

package/macros/src/lib.rs

@@ -0,0 +1,38 @@
+use proc_macro::TokenStream;
+
+mod instructions;
+mod oft;
+
+/// Attribute macro for generating OApp program entrypoints via the new oapp2 pipeline.
+///
+/// This macro is introduced as a clean-slate path and is intentionally separate
+/// from `#[oapp]`.
+///
+/// # Attributes
+///
+/// - `state = <path>`: required. The OFT program state account type.
+/// - `role_type = <path>`: required. The RBAC role enum type.
+///
+/// The role enum should implement `rbac::RoleType`. With the built-in derive,
+/// the `#[default]` variant is the default-admin role and must use discriminant
+/// `0`.
+///
+/// ```ignore
+/// #[oft(state = OFTStore, role_type = crate::RoleType)]
+/// mod oft_instructions {}
+/// ```
+#[proc_macro_attribute]
+pub fn oft(attr: TokenStream, item: TokenStream) -> TokenStream {
+    oft::expand(attr.into(), item.into())
+        .unwrap_or_else(|err| err.to_compile_error())
+        .into()
+}
+
+/// This attribute is used to override the default OFT instruction handlers.
+///
+/// The attribute itself is a no-op; `#[oft]` detects it and routes the
+/// overridden handler into generated instruction entrypoints.
+#[proc_macro_attribute]
+pub fn oft_instruction(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    item
+}

package/macros/src/oft.rs

@@ -0,0 +1,61 @@
+//! Top-level `#[oft]` attribute macro implementation.
+//!
+//! Flow: parse attribute inputs, then collect overrides → generate instructions → assemble.
+
+use crate::instructions::{CodegenContext, OftInstructionSet};
+use anchor_trait::{generate_instructions, Assembly, InstructionOverrides, OverrideConfig};
+use darling::{ast::NestedMeta, FromMeta};
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::{ItemMod, Path};
+
+// ---------------------------------------------------------------------------
+// Attribute parsing
+// ---------------------------------------------------------------------------
+
+#[derive(FromMeta)]
+struct OFTAttr {
+    /// The program state account TYPE (e.g., OFTStore).
+    state: Path,
+    /// The RBAC role enum TYPE.
+    role_type: Path,
+}
+
+const OVERRIDE_CONFIG: OverrideConfig =
+    OverrideConfig { attr_name: "oft_instruction", domain: "OFT" };
+
+// ---------------------------------------------------------------------------
+// Entry point
+// ---------------------------------------------------------------------------
+
+pub fn expand(attr: TokenStream, item: TokenStream) -> syn::Result<TokenStream> {
+    // Parse attribute inputs and the annotated module.
+    let attr_args = NestedMeta::parse_meta_list(attr)?;
+    let attrs = OFTAttr::from_list(&attr_args)?;
+    let module = syn::parse2::<ItemMod>(item)?;
+
+    let oft_type = &attrs.state;
+    let role_type = &attrs.role_type;
+
+    // 1. Collect overrides
+    let overrides = InstructionOverrides::collect(&module, OVERRIDE_CONFIG)?;
+
+    // 2. Generate instructions
+    let codegen_ctx = CodegenContext {};
+    let instructions = generate_instructions::<OftInstructionSet>(&codegen_ctx, &overrides)?;
+
+    // 3. Assemble output
+    let extra_mod_attrs = quote! {
+        #[::oapp::oapp(state = #oft_type, role_type = #role_type)]
+    };
+
+    Ok(Assembly {
+        prelude: TokenStream::new(),
+        overrides,
+        instructions,
+        extra_mod_attrs,
+        source_mod: module,
+        extend_macro_name: None,
+    }
+    .assemble())
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@layerzerolabs/oft-solana-contracts",
+  "version": "1.2.11",
+  "private": false,
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "src",
+    "macros",
+    "Cargo.toml",
+    "Anchor.toml",
+    "rust-toolchain.toml",
+    "rustfmt.toml"
+  ],
+  "dependencies": {
+    "@layerzerolabs/oapp-solana-contracts": "1.2.11",
+    "@layerzerolabs/framework-solana-anchor-trait": "1.2.11"
+  },
+  "devDependencies": {
+    "@layerzerolabs/build-utils-rust": "1.2.11",
+    "@layerzerolabs/tsup-configuration": "1.2.11",
+    "@layerzerolabs/typescript-configuration": "1.2.11",
+    "@layerzerolabs/vm-tooling-solana": "1.2.11"
+  },
+  "publishConfig": {
+    "access": "restricted",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "externalRepoConfig": {
+    "targets": [
+      "audit-external",
+      "usdai-internal"
+    ]
+  },
+  "implicitDependencies": {
+    "@layerzerolabs/framework-solana-anchor-trait": "workspace:*",
+    "@layerzerolabs/oapp-solana-contracts": "workspace:*"
+  },
+  "scripts": {
+    "build": "pnpm resolve-dependencies && pnpm exec lz-tool --script 'cargo build' anchor",
+    "build:native": "pnpm resolve-dependencies && pnpm exec lz-tool --docker-platform native --script 'cargo build' anchor",
+    "check": "pnpm exec lz-tool --script 'cargo check' anchor",
+    "clean": "rm -rf dependencies target",
+    "format": "pnpm exec lz-tool --script 'cargo +nightly-2025-06-01 fmt' anchor",
+    "format:check": "pnpm exec lz-tool --script 'cargo +nightly-2025-06-01 fmt -- --check' anchor",
+    "lint": "pnpm resolve-dependencies && pnpm exec lz-tool --script 'cargo +nightly-2025-06-01 fmt -- --check && cargo clippy --all-targets' anchor",
+    "resolve-dependencies": "pnpm exec build-utils-rust resolve",
+    "test": "pnpm test:rust",
+    "test:rust": "pnpm resolve-dependencies && pnpm exec lz-tool --script 'cargo test -p oft --lib --tests' anchor",
+    "test:snapshot:check": "pnpm exec turbo-snapshot check",
+    "test:snapshot:update": "pnpm exec turbo-snapshot update"
+  }
+}

package/rust-toolchain.toml

@@ -0,0 +1,3 @@
+[toolchain]
+channel = "1.92.0"
+components = ["rustfmt", "clippy"]

package/rustfmt.toml

@@ -0,0 +1,23 @@
+# Basic
+hard_tabs = false
+max_width = 100
+use_small_heuristics = "Max"
+# Imports
+imports_granularity = "Crate"
+reorder_imports = true
+# Consistency
+newline_style = "Unix"
+# Format comments
+comment_width = 100
+wrap_comments = true
+# Misc
+chain_width = 80
+spaces_around_ranges = false
+binop_separator = "Front"
+reorder_impl_items = false
+match_arm_leading_pipes = "Preserve"
+match_arm_blocks = true
+match_block_trailing_comma = true
+trailing_comma = "Vertical"
+trailing_semicolon = true
+use_field_init_shorthand = true

package/src/events.rs

@@ -0,0 +1,45 @@
+use anchor_lang::prelude::*;
+
+// ================================ OFT Events ================================
+// EVM alignment: IOFT.sol
+//
+// Every event carries an `oft_store` pubkey: a single OFT program manages many
+// independent OFTStore instances (one per OFT deployment, mirroring how the
+// SPL Token program manages many `Mint` accounts), so events carry the store
+// pubkey to let off-chain consumers attribute each event to the right instance.
+//
+// In OFTSent / OFTReceived, `oft_store` is appended LAST (unlike newer events
+// where it is the first field). Defensive choice: these two events predated
+// the field, and appending preserves the existing prefix layout in case any
+// decoder relies on field order. Do not reorder.
+
+#[event]
+pub struct OFTSent {
+    pub guid: [u8; 32],
+    pub dst_eid: u32,
+    // `from` is the token account. `sender` is the signer/authority at send time.
+    // Token account authority can change later, so `sender` gives indexers a stable initiator
+    // record.
+    pub from: Pubkey,
+    pub amount_sent_ld: u64,
+    pub amount_received_ld: u64,
+    pub sender: Pubkey,
+    pub oft_store: Pubkey,
+}
+
+#[event]
+pub struct OFTReceived {
+    pub guid: [u8; 32],
+    pub src_eid: u32,
+    pub to: Pubkey,
+    pub amount_received_ld: u64,
+    pub oft_store: Pubkey,
+}
+
+// ================================ ALT Events ================================
+
+#[event]
+pub struct AddressLookupTablesSet {
+    pub oft_store: Pubkey,
+    pub alts: Vec<Pubkey>,
+}

package/src/lib.rs

@@ -0,0 +1,8 @@
+pub mod events;
+pub mod oft_info;
+pub mod types;
+
+// Re-export procedural macros
+pub use oft_macros::*;
+
+pub const OFT_SEED: &[u8] = b"OFT";

package/src/oft_info.rs

@@ -0,0 +1,93 @@
+use anchor_lang::prelude::{borsh, AnchorDeserialize, AnchorSerialize, InitSpace};
+use anchor_spl::token_interface::spl_token_metadata_interface::solana_borsh;
+use spl_discriminator::SplDiscriminate;
+use spl_type_length_value::SplBorshVariableLenPack;
+
+pub const OFT_INFO_SCHEMA_VERSION: u8 = 1;
+
+/// TLV entry type for the OFT layer.
+///
+/// `OftInfo` is the OFT-family record inside the flat OAppInfo TLV container.
+/// `OAppBase.app_discriminator` can route to this entry, and this entry owns the
+/// `project_discriminator` route field for implementation-specific records such
+/// as `ConsoleOftInfo`.
+#[derive(
+    Clone, AnchorSerialize, AnchorDeserialize, InitSpace, SplDiscriminate, SplBorshVariableLenPack,
+)]
+#[discriminator_hash_input("oft::info")]
+pub struct OftInfo {
+    /// Borsh schema version of this entry. Bumps when fields are added,
+    /// removed, reordered, or change type. The SDK reads this first to select
+    /// the correct parser for the remaining bytes.
+    pub schema_version: u8,
+    /// SPL discriminator of the implementation-specific TLV entry, if any.
+    pub project_discriminator: [u8; 8],
+}
+
+impl OftInfo {
+    /// Creates an `OftInfo` at the current schema version with the given
+    /// project discriminator.
+    pub fn new(project_discriminator: [u8; 8]) -> Self {
+        Self { schema_version: OFT_INFO_SCHEMA_VERSION, project_discriminator }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use anchor_lang::Space;
+    use oapp::oapp_info::{TlvSpace, TLV_HEADER_BYTES};
+    use spl_type_length_value::{
+        state::{TlvState, TlvStateBorrowed, TlvStateMut},
+        variable_len_pack::VariableLenPack,
+    };
+
+    fn write_entry(entry: OftInfo) -> Vec<u8> {
+        let mut buf = vec![0u8; OftInfo::TLV_SPACE];
+        let mut state = TlvStateMut::unpack(&mut buf[..]).unwrap();
+        let len = entry.get_packed_len().unwrap();
+        state.alloc::<OftInfo>(len, false).unwrap();
+        state.pack_first_variable_len_value(&entry).unwrap();
+        buf
+    }
+
+    fn read_entry(buf: &[u8]) -> OftInfo {
+        let state = TlvStateBorrowed::unpack(buf).unwrap();
+        state.get_first_variable_len_value::<OftInfo>().unwrap()
+    }
+
+    const TEST_DISC_A: [u8; 8] = [1, 2, 3, 4, 5, 6, 7, 8];
+    const TEST_DISC_B: [u8; 8] = [10, 20, 30, 40, 50, 60, 70, 80];
+
+    #[test]
+    fn entry_packed_len_matches_tlv_space() {
+        let entry = OftInfo::new(TEST_DISC_A);
+        assert_eq!(entry.get_packed_len().unwrap(), OftInfo::INIT_SPACE);
+        assert_eq!(entry.get_packed_len().unwrap() + TLV_HEADER_BYTES, OftInfo::TLV_SPACE);
+    }
+
+    #[test]
+    fn tlv_round_trip_default_versions() {
+        let entry = OftInfo::new(TEST_DISC_A);
+        let buf = write_entry(entry);
+        let out = read_entry(&buf);
+
+        assert_eq!(out.schema_version, OFT_INFO_SCHEMA_VERSION);
+        assert_eq!(out.project_discriminator, TEST_DISC_A);
+    }
+
+    #[test]
+    fn tlv_round_trip_different_discriminators() {
+        let entry_a = OftInfo::new(TEST_DISC_A);
+        let entry_b = OftInfo::new(TEST_DISC_B);
+
+        let buf_a = write_entry(entry_a);
+        let buf_b = write_entry(entry_b);
+        let out_a = read_entry(&buf_a);
+        let out_b = read_entry(&buf_b);
+
+        assert_eq!(out_a.project_discriminator, TEST_DISC_A);
+        assert_eq!(out_b.project_discriminator, TEST_DISC_B);
+        assert_ne!(out_a.project_discriminator, out_b.project_discriminator);
+    }
+}

package/src/types.rs

@@ -0,0 +1,151 @@
+use anchor_lang::prelude::*;
+
+// ================================ OFT (IOFT) ================================
+// EVM alignment: IOFT.sol
+
+/// Token custody model for the OFT.
+///
+/// Consuming programs store this in their runtime state; it is not part of the
+/// `OftInfo` discovery entry.
+#[derive(InitSpace, Clone, AnchorSerialize, AnchorDeserialize, PartialEq, Eq)]
+#[borsh(use_discriminant = true)]
+#[repr(u8)]
+pub enum OftType {
+    /// Tokens are minted on receive and burned on send.
+    BurnMint = 0,
+    /// Tokens are unlocked on receive and locked on send.
+    LockUnlock = 1,
+}
+
+/// Struct representing OFT receipt information.
+/// EVM: OFTReceipt
+#[derive(Clone, AnchorSerialize, AnchorDeserialize)]
+pub struct OFTReceipt {
+    /// Amount of tokens ACTUALLY debited from the sender in local decimals.
+    pub amount_sent_ld: u64,
+    /// Amount of tokens to be received on the remote side.
+    /// In non-default implementations, this COULD differ from `amount_sent_ld`.
+    pub amount_received_ld: u64,
+}
+
+/// Struct representing OFT limit information.
+/// These amounts can change dynamically and are up to the specific OFT implementation.
+/// EVM: OFTLimit
+#[derive(Clone, AnchorSerialize, AnchorDeserialize)]
+pub struct OFTLimit {
+    /// Minimum amount in local decimals that can be sent to the recipient.
+    pub min_amount_ld: u64,
+    /// Maximum amount in local decimals that can be sent to the recipient.
+    pub max_amount_ld: u64,
+}
+
+/// Struct representing OFT fee details.
+/// Future-proof mechanism to provide a standardized way to communicate fees to things like a UI.
+/// EVM: OFTFeeDetail
+#[derive(Clone, AnchorSerialize, AnchorDeserialize)]
+pub struct OFTFeeDetail {
+    /// Amount of the fee in local decimals. Negative values represent rebates.
+    pub fee_amount_ld: i128,
+    /// Description of the fee.
+    pub description: String,
+}
+
+/// Return type for the `quoteOFT` operation.
+/// Provides limits, fee breakdown, and receipt data for an OFT quote.
+/// EVM: IOFT.quoteOFT(SendParam calldata _sendParam) returns (OFTLimit, OFTFeeDetail[], OFTReceipt)
+#[derive(Clone, AnchorSerialize, AnchorDeserialize)]
+pub struct QuoteOFTResult {
+    /// The OFT limit information (min/max amounts).
+    pub oft_limit: OFTLimit,
+    /// The details of OFT fees.
+    pub oft_fee_details: Vec<OFTFeeDetail>,
+    /// The OFT receipt information.
+    pub oft_receipt: OFTReceipt,
+}
+
+/// Parameters for the `send()` operation.
+/// Combines the EVM `SendParam` struct with `MessagingFee` fields.
+/// EVM: IOFT.send(SendParam calldata _sendParam, MessagingFee calldata _fee, address
+/// _refundAddress)
+///
+/// Note: Unlike the EVM `SendParam`, this struct does not include an `oftCmd` field.
+/// Custom OFT implementations that need OFT commands should pass them via a separate PDA account.
+#[derive(Clone, AnchorSerialize, AnchorDeserialize)]
+pub struct SendParams {
+    /// Destination endpoint ID.
+    pub dst_eid: u32,
+    /// Recipient address (bytes32).
+    pub to: [u8; 32],
+    /// Amount to send in local decimals.
+    pub amount_ld: u64,
+    /// Minimum amount to send in local decimals (slippage protection).
+    pub min_amount_ld: u64,
+    /// Additional options supplied by the caller to be used in the LayerZero message.
+    pub extra_options: Vec<u8>,
+    /// The composed message for the send() operation. `None` if no composed message.
+    pub compose_msg: Option<Vec<u8>>,
+    /// The native fee for the LayerZero message (from MessagingFee.nativeFee).
+    pub native_fee: u64,
+    /// The lzToken fee for the LayerZero message (from MessagingFee.lzTokenFee).
+    pub lz_token_fee: u64,
+}
+
+/// Parameters for the `quoteSend()` operation.
+/// Provides a quote for the send() operation.
+/// EVM: IOFT.quoteSend(SendParam calldata _sendParam, bool _payInLzToken) returns (MessagingFee)
+///
+/// Note: Unlike the EVM `SendParam`, this struct does not include an `oftCmd` field.
+/// Custom OFT implementations that need OFT commands should pass them via a separate PDA account.
+#[derive(Clone, AnchorSerialize, AnchorDeserialize)]
+pub struct QuoteSendParams {
+    /// Destination endpoint ID.
+    pub dst_eid: u32,
+    /// Recipient address (bytes32).
+    pub to: [u8; 32],
+    /// Amount to send in local decimals.
+    pub amount_ld: u64,
+    /// Minimum amount to send in local decimals (slippage protection).
+    pub min_amount_ld: u64,
+    /// Additional options supplied by the caller to be used in the LayerZero message.
+    pub extra_options: Vec<u8>,
+    /// The composed message for the send() operation. `None` if no composed message.
+    pub compose_msg: Option<Vec<u8>>,
+    /// Flag indicating whether the caller is paying in the LZ token.
+    pub pay_in_lz_token: bool,
+}
+
+/// Parameters for the `quoteOFT()` operation.
+/// Describes the transfer inputs used to quote OFT limits, fees, and receipt amounts.
+/// EVM: IOFT.quoteOFT(SendParam calldata _sendParam)
+///
+/// Note: Unlike the EVM `SendParam`, this struct does not include an `oftCmd` field.
+/// Custom OFT implementations that need OFT commands should pass them via a separate PDA account.
+#[derive(Clone, AnchorSerialize, AnchorDeserialize)]
+pub struct QuoteOFTParams {
+    /// Destination endpoint ID.
+    pub dst_eid: u32,
+    /// Recipient address (bytes32).
+    pub to: [u8; 32],
+    /// Amount to send in local decimals.
+    pub amount_ld: u64,
+    /// Minimum amount to send in local decimals (slippage protection).
+    pub min_amount_ld: u64,
+    /// Additional options supplied by the caller to be used in the LayerZero message.
+    pub extra_options: Vec<u8>,
+    /// The composed message for the send() operation. `None` if no composed message.
+    pub compose_msg: Option<Vec<u8>>,
+    /// Deprecated: retained for backward compatibility with deployed programs. Not used by the
+    /// quoteOFT operation.
+    pub pay_in_lz_token: bool,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn oft_type_enum_values() {
+        assert_eq!(OftType::BurnMint as u8, 0);
+        assert_eq!(OftType::LockUnlock as u8, 1);
+    }
+}