add nft bridge skeleton

Change-Id: I69449e95415cd94b7de4528fe4002b241e1e6b95

docs/devnet.md

@@ -8,6 +8,7 @@
 | Token Bridge       | ETH             | 0x0290FB167208Af455bB137780163b7B7a9a10C16                                                            |                                                                                                                                                                |
 | Test Wallet        | SOL             | 6sbzC1eH4FTujJXWj51eQe25cYvr4xfXbJ1vAj7j2k5J                                                          | Key in `solana/keys/solana-devnet.json`                                                                                                                                        |
 | Example Token      | SOL             | 2WDq7wSs9zYrpx2kbHDA4RUTRch2CCTP6ZWaH4GNfnQQ                                                          | Tokens minted to Test Wallet                                                                                                                                   |
+| Example NFT        | SOL             | BVxyYhm498L79r4HMQ9sxZ5bi41DmJmeWZ7SCS7Cyvna                                                          | One minted to Test Wallet                                                                                                                                      |
 | Bridge Core        | SOL             | Bridge1p5gheXUvJ6jGWGeCsgPKgnE3YgdGKRVCMY9o                                                           |                                                                                                                                                                |
 | Token Bridge       | SOL             | B6RHG3mfcckmrYN1UhmJzyS1XX3fZKbkeUcpJe9Sy3FE                                                          |                                                                                                                                                                |
 | Test Wallet        | Terra           | terra1x46rqay4d3cssq8gxxvqz8xt6nwlz4td20k38v                                                          | Mnemonic: `notice oak worry limit wrap speak medal online prefer cluster roof addict wrist behave treat actual wasp year salad speed social layer crew genius` |

solana/devnet_setup.sh

@@ -15,6 +15,11 @@ cat <<EOF > token.json
 [179,228,102,38,68,102,75,133,127,56,63,167,143,42,59,29,220,215,100,149,220,241,176,204,154,241,168,147,195,139,55,100,22,88,9,115,146,64,160,172,3,185,132,64,254,137,133,84,142,58,166,131,205,13,77,157,245,181,101,150,105,250,163,1]
 EOF
 
+# Static key for the NFT mint so it always has the same address
+cat <<EOF > nft.json
+[155,117,110,235,96,214,56,128,109,79,49,209,212,13,134,5,43,123,213,68,21,156,128,100,95,8,43,51,188,230,21,197,156,0,108,72,200,203,243,56,73,203,7,163,249,54,21,156,197,35,249,89,28,177,153,154,189,69,137,14,197,254,233,183]
+EOF
+
 # Constants
 cli_address=6sbzC1eH4FTujJXWj51eQe25cYvr4xfXbJ1vAj7j2k5J
 bridge_address=Bridge1p5gheXUvJ6jGWGeCsgPKgnE3YgdGKRVCMY9o
@@ -44,7 +49,21 @@ echo "Created token account $account"
 spl-token mint "$token" 10000000000 "$account"
 
 # Create meta for token
-token-bridge-client create-meta "$token" "Solana Test Token" "SOLT"
+token-bridge-client create-meta "$token" "Solana Test Token" "SOLT" ""
+
+# Create a new SPL NFT
+nft=$(spl-token create-token --decimals 0 -- nft.json | grep 'Creating token' | awk '{ print $3 }')
+echo "Created NFT $nft"
+
+# Create NFT account
+nft_account=$(spl-token create-account "$nft" | grep 'Creating account' | awk '{ print $3 }')
+echo "Created NFT account $nft_account"
+
+# Mint new NFT owned by our CLI account
+spl-token mint "$nft" 1 "$nft_account"
+
+# Create meta for token
+token-bridge-client create-meta "$nft" "Not a PUNK" "PUNK" "https://wrappedpunks.com:3000/api/punks/metadata/39"
 
 # Create the bridge contract at a known address
 # OK to fail on subsequent attempts (already created).

solana/modules/nft_bridge/Cargo.toml

@@ -0,0 +1,5 @@
+[workspace]
+members = ["program"]
+
+[patch.crates-io]
+memmap2 = { path = "../../bridge/memmap2-rs" }

solana/modules/nft_bridge/program/Cargo.toml

@@ -0,0 +1,43 @@
+[package]
+name = "nft-bridge"
+version = "0.1.0"
+description = "Created with Rocksalt"
+edition = "2018"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+name = "nft_bridge"
+
+[features]
+no-entrypoint = ["solitaire/no-entrypoint", "rand"]
+trace = ["solitaire/trace"]
+wasm = ["no-entrypoint"]
+client = ["solitaire-client", "solitaire/client", "no-entrypoint"]
+cpi = ["no-entrypoint"]
+default = []
+
+[dependencies]
+bridge = { path = "../../../bridge/program", features = ["no-entrypoint", "cpi"] }
+borsh = "0.8.1"
+byteorder = "1.4.3"
+rocksalt = { path = "../../../solitaire/rocksalt" }
+solitaire = { path = "../../../solitaire/program" }
+sha3 = "0.9.1"
+solana-program = "*"
+spl-token = { version = "=3.1.0", features = ["no-entrypoint"] }
+spl-associated-token-account = { version = "1.0.2" }
+primitive-types = { version = "0.9.0", default-features = false }
+solitaire-client = { path = "../../../solitaire/client", optional = true }
+spl-token-metadata = { path = "../../token_bridge/token-metadata" }
+wasm-bindgen = { version = "0.2.74", features = ["serde-serialize"] }
+serde = { version = "1.0", features = ["derive"] }
+rand = { version = "0.7.3", optional = true }
+
+[dev-dependencies]
+hex = "*"
+hex-literal = "0.3.1"
+libsecp256k1 = { version = "0.3.5", features = [] }
+solana-client = "1.7.0"
+solana-sdk = "=1.7.0"
+spl-token = { version = "=3.1.0", features = ["no-entrypoint"] }
+spl-token-metadata = { path = "../../token_bridge/token-metadata" }

solana/modules/nft_bridge/program/Xargo.toml

@@ -0,0 +1,2 @@
+[target.bpfel-unknown-unknown.dependencies.std]
+features = []

solana/modules/nft_bridge/program/src/accounts.rs

@@ -0,0 +1,112 @@
+use crate::types::*;
+use bridge::{
+    api::ForeignAddress,
+    types::BridgeData,
+    vaa::{
+        DeserializePayload,
+        PayloadMessage,
+    },
+};
+use primitive_types::U256;
+use solana_program::pubkey::Pubkey;
+use solitaire::{
+    processors::seeded::Seeded,
+    *,
+};
+
+pub type AuthoritySigner<'b> = Derive<Info<'b>, "authority_signer">;
+pub type CustodySigner<'b> = Derive<Info<'b>, "custody_signer">;
+pub type MintSigner<'b> = Derive<Info<'b>, "mint_signer">;
+
+pub type CoreBridge<'a, const State: AccountState> = Data<'a, BridgeData, { State }>;
+
+pub type EmitterAccount<'b> = Derive<Info<'b>, "emitter">;
+
+pub type ConfigAccount<'b, const State: AccountState> =
+    Derive<Data<'b, Config, { State }>, "config">;
+
+pub type CustodyAccount<'b, const State: AccountState> = Data<'b, SplAccount, { State }>;
+
+pub struct CustodyAccountDerivationData {
+    pub mint: Pubkey,
+}
+
+impl<'b, const State: AccountState> Seeded<&CustodyAccountDerivationData>
+    for CustodyAccount<'b, { State }>
+{
+    fn seeds(accs: &CustodyAccountDerivationData) -> Vec<Vec<u8>> {
+        vec![accs.mint.to_bytes().to_vec()]
+    }
+}
+
+pub type WrappedMint<'b, const State: AccountState> = Data<'b, SplMint, { State }>;
+
+pub struct WrappedDerivationData {
+    pub token_chain: ChainID,
+    pub token_address: ForeignAddress,
+    pub token_id: U256,
+}
+
+impl<'b, const State: AccountState> Seeded<&WrappedDerivationData> for WrappedMint<'b, { State }> {
+    fn seeds(data: &WrappedDerivationData) -> Vec<Vec<u8>> {
+        let mut token_id = vec![0u8; 32];
+        data.token_id.to_big_endian(&mut token_id);
+        vec![
+            String::from("wrapped").as_bytes().to_vec(),
+            data.token_chain.to_be_bytes().to_vec(),
+            data.token_address.to_vec(),
+            token_id,
+        ]
+    }
+}
+
+pub type WrappedTokenMeta<'b, const State: AccountState> = Data<'b, WrappedMeta, { State }>;
+
+pub struct WrappedMetaDerivationData {
+    pub mint_key: Pubkey,
+}
+
+impl<'b, const State: AccountState> Seeded<&WrappedMetaDerivationData>
+    for WrappedTokenMeta<'b, { State }>
+{
+    fn seeds(data: &WrappedMetaDerivationData) -> Vec<Vec<u8>> {
+        vec![
+            String::from("meta").as_bytes().to_vec(),
+            data.mint_key.to_bytes().to_vec(),
+        ]
+    }
+}
+
+/// Registered chain endpoint
+pub type Endpoint<'b, const State: AccountState> = Data<'b, EndpointRegistration, { State }>;
+
+pub struct EndpointDerivationData {
+    pub emitter_chain: u16,
+    pub emitter_address: ForeignAddress,
+}
+
+/// Seeded implementation based on an incoming VAA
+impl<'b, const State: AccountState> Seeded<&EndpointDerivationData> for Endpoint<'b, { State }> {
+    fn seeds(data: &EndpointDerivationData) -> Vec<Vec<u8>> {
+        vec![
+            data.emitter_chain.to_be_bytes().to_vec(),
+            data.emitter_address.to_vec(),
+        ]
+    }
+}
+
+pub type SplTokenMeta<'b> = Info<'b>;
+
+pub struct SplTokenMetaDerivationData {
+    pub mint: Pubkey,
+}
+
+impl<'b> Seeded<&SplTokenMetaDerivationData> for SplTokenMeta<'b> {
+    fn seeds(data: &SplTokenMetaDerivationData) -> Vec<Vec<u8>> {
+        vec![
+            "metadata".as_bytes().to_vec(),
+            spl_token_metadata::id().as_ref().to_vec(),
+            data.mint.as_ref().to_vec(),
+        ]
+    }
+}

solana/modules/nft_bridge/program/src/api.rs

@@ -0,0 +1,9 @@
+pub mod complete_transfer;
+pub mod governance;
+pub mod initialize;
+pub mod transfer;
+
+pub use complete_transfer::*;
+pub use governance::*;
+pub use initialize::*;
+pub use transfer::*;

solana/modules/nft_bridge/program/src/api/complete_transfer.rs

@@ -0,0 +1,323 @@
+use crate::{
+    accounts::{
+        ConfigAccount,
+        CustodyAccount,
+        CustodyAccountDerivationData,
+        CustodySigner,
+        Endpoint,
+        EndpointDerivationData,
+        MintSigner,
+        SplTokenMeta,
+        SplTokenMetaDerivationData,
+        WrappedDerivationData,
+        WrappedMetaDerivationData,
+        WrappedMint,
+        WrappedTokenMeta,
+    },
+    messages::PayloadTransfer,
+    types::*,
+    TokenBridgeError::*,
+};
+use bridge::{
+    vaa::ClaimableVAA,
+    CHAIN_ID_SOLANA,
+};
+use solana_program::{
+    account_info::AccountInfo,
+    program::{
+        invoke,
+        invoke_signed,
+    },
+    program_error::ProgramError,
+    pubkey::Pubkey,
+};
+use solitaire::{
+    processors::seeded::{
+        invoke_seeded,
+        Seeded,
+    },
+    CreationLamports::Exempt,
+    *,
+};
+use spl_token::state::{
+    Account,
+    Mint,
+};
+use std::ops::{
+    Deref,
+    DerefMut,
+};
+
+#[derive(FromAccounts)]
+pub struct CompleteNative<'b> {
+    pub payer: Mut<Signer<AccountInfo<'b>>>,
+    pub config: ConfigAccount<'b, { AccountState::Initialized }>,
+
+    pub vaa: ClaimableVAA<'b, PayloadTransfer>,
+    pub chain_registration: Endpoint<'b, { AccountState::Initialized }>,
+
+    pub to: Mut<Data<'b, SplAccount, { AccountState::MaybeInitialized }>>,
+    pub to_authority: MaybeMut<Info<'b>>,
+    pub custody: Mut<CustodyAccount<'b, { AccountState::Initialized }>>,
+    pub mint: Data<'b, SplMint, { AccountState::Initialized }>,
+
+    pub custody_signer: CustodySigner<'b>,
+}
+
+impl<'a> From<&CompleteNative<'a>> for EndpointDerivationData {
+    fn from(accs: &CompleteNative<'a>) -> Self {
+        EndpointDerivationData {
+            emitter_chain: accs.vaa.meta().emitter_chain,
+            emitter_address: accs.vaa.meta().emitter_address,
+        }
+    }
+}
+
+impl<'a> From<&CompleteNative<'a>> for CustodyAccountDerivationData {
+    fn from(accs: &CompleteNative<'a>) -> Self {
+        CustodyAccountDerivationData {
+            mint: *accs.mint.info().key,
+        }
+    }
+}
+
+impl<'b> InstructionContext<'b> for CompleteNative<'b> {}
+
+#[derive(BorshDeserialize, BorshSerialize, Default)]
+pub struct CompleteNativeData {}
+
+pub fn complete_native(
+    ctx: &ExecutionContext,
+    accs: &mut CompleteNative,
+    data: CompleteNativeData,
+) -> Result<()> {
+    // Verify the chain registration
+    let derivation_data: EndpointDerivationData = (&*accs).into();
+    accs.chain_registration
+        .verify_derivation(ctx.program_id, &derivation_data)?;
+
+    // Verify that the custody account is derived correctly
+    let derivation_data: CustodyAccountDerivationData = (&*accs).into();
+    accs.custody
+        .verify_derivation(ctx.program_id, &derivation_data)?;
+
+    // Verify mints
+    if *accs.mint.info().key != accs.custody.mint {
+        return Err(InvalidMint.into());
+    }
+    if *accs.custody_signer.key != accs.custody.owner {
+        return Err(WrongAccountOwner.into());
+    }
+
+    // Verify VAA
+    if accs.vaa.token_address != accs.mint.info().key.to_bytes() {
+        return Err(InvalidMint.into());
+    }
+    if accs.vaa.token_chain != CHAIN_ID_SOLANA {
+        return Err(InvalidChain.into());
+    }
+    if accs.vaa.to_chain != CHAIN_ID_SOLANA {
+        return Err(InvalidChain.into());
+    }
+
+    // Prevent vaa double signing
+    accs.vaa.verify(ctx.program_id)?;
+    accs.vaa.claim(ctx, accs.payer.key)?;
+
+    if !accs.to.is_initialized() {
+        let associated_addr = spl_associated_token_account::get_associated_token_address(
+            accs.to_authority.info().key,
+            accs.mint.info().key,
+        );
+        if *accs.to_authority.info().key != associated_addr {
+            return Err(InvalidAssociatedAccount.into());
+        }
+        // Create associated token account
+        let ix = spl_associated_token_account::create_associated_token_account(
+            accs.payer.info().key,
+            accs.to_authority.info().key,
+            accs.mint.info().key,
+        );
+        invoke(&ix, ctx.accounts)?;
+    } else if *accs.mint.info().key != accs.to.mint {
+        return Err(InvalidMint.into());
+    }
+
+    // Transfer tokens
+    let transfer_ix = spl_token::instruction::transfer(
+        &spl_token::id(),
+        accs.custody.info().key,
+        accs.to.info().key,
+        accs.custody_signer.key,
+        &[],
+        1,
+    )?;
+    invoke_seeded(&transfer_ix, ctx, &accs.custody_signer, None)?;
+
+    Ok(())
+}
+
+#[derive(FromAccounts)]
+pub struct CompleteWrapped<'b> {
+    pub payer: Mut<Signer<AccountInfo<'b>>>,
+    pub config: ConfigAccount<'b, { AccountState::Initialized }>,
+
+    // Signed message for the transfer
+    pub vaa: ClaimableVAA<'b, PayloadTransfer>,
+
+    pub chain_registration: Endpoint<'b, { AccountState::Initialized }>,
+
+    pub to: Mut<Data<'b, SplAccount, { AccountState::MaybeInitialized }>>,
+    pub to_authority: MaybeMut<Info<'b>>,
+    pub mint: Mut<WrappedMint<'b, { AccountState::MaybeInitialized }>>,
+    pub meta: Mut<WrappedTokenMeta<'b, { AccountState::MaybeInitialized }>>,
+
+    /// SPL Metadata for the associated Mint
+    pub spl_metadata: Mut<SplTokenMeta<'b>>,
+
+    pub mint_authority: MintSigner<'b>,
+}
+
+impl<'a> From<&CompleteWrapped<'a>> for EndpointDerivationData {
+    fn from(accs: &CompleteWrapped<'a>) -> Self {
+        EndpointDerivationData {
+            emitter_chain: accs.vaa.meta().emitter_chain,
+            emitter_address: accs.vaa.meta().emitter_address,
+        }
+    }
+}
+
+impl<'a> From<&CompleteWrapped<'a>> for WrappedDerivationData {
+    fn from(accs: &CompleteWrapped<'a>) -> Self {
+        WrappedDerivationData {
+            token_chain: accs.vaa.token_chain,
+            token_address: accs.vaa.token_address,
+            token_id: accs.vaa.token_id,
+        }
+    }
+}
+
+impl<'a> From<&CompleteWrapped<'a>> for WrappedMetaDerivationData {
+    fn from(accs: &CompleteWrapped<'a>) -> Self {
+        WrappedMetaDerivationData {
+            mint_key: *accs.mint.info().key,
+        }
+    }
+}
+
+impl<'b> InstructionContext<'b> for CompleteWrapped<'b> {}
+
+#[derive(BorshDeserialize, BorshSerialize, Default)]
+pub struct CompleteWrappedData {}
+
+pub fn complete_wrapped(
+    ctx: &ExecutionContext,
+    accs: &mut CompleteWrapped,
+    data: CompleteWrappedData,
+) -> Result<()> {
+    // Verify the chain registration
+    let derivation_data: EndpointDerivationData = (&*accs).into();
+    accs.chain_registration
+        .verify_derivation(ctx.program_id, &derivation_data)?;
+
+    // Verify mint
+    let derivation_data: WrappedDerivationData = (&*accs).into();
+    accs.mint
+        .verify_derivation(ctx.program_id, &derivation_data)?;
+
+    // Verify VAA
+    if accs.vaa.to_chain != CHAIN_ID_SOLANA {
+        return Err(InvalidChain.into());
+    }
+
+    accs.vaa.verify(ctx.program_id)?;
+    accs.vaa.claim(ctx, accs.payer.key)?;
+
+    // Initialize the NFT if it doesn't already exist
+    if !accs.meta.is_initialized() {
+        // Create mint account
+        accs.mint
+            .create(&((&*accs).into()), ctx, accs.payer.key, Exempt);
+
+        // Initialize mint
+        let init_ix = spl_token::instruction::initialize_mint(
+            &spl_token::id(),
+            accs.mint.info().key,
+            accs.mint_authority.key,
+            None,
+            0,
+        )?;
+        invoke_signed(&init_ix, ctx.accounts, &[])?;
+
+        // Create meta account
+        accs.meta
+            .create(&((&*accs).into()), ctx, accs.payer.key, Exempt);
+
+        // Initialize spl meta
+        accs.spl_metadata.verify_derivation(
+            &spl_token_metadata::id(),
+            &SplTokenMetaDerivationData {
+                mint: *accs.mint.info().key,
+            },
+        )?;
+
+        let mut name = accs.vaa.name.clone();
+        name.truncate(32);
+        let mut symbol = accs.vaa.symbol.clone();
+        symbol.truncate(10);
+
+        let spl_token_metadata_ix = spl_token_metadata::instruction::create_metadata_accounts(
+            spl_token_metadata::id(),
+            *accs.spl_metadata.key,
+            *accs.mint.info().key,
+            *accs.mint_authority.info().key,
+            *accs.payer.info().key,
+            *accs.mint_authority.info().key,
+            name,
+            symbol,
+            accs.vaa.uri.clone(),
+            None,
+            0,
+            false,
+            true,
+        );
+        invoke_seeded(&spl_token_metadata_ix, ctx, &accs.mint_authority, None)?;
+
+        // Populate meta account
+        accs.meta.chain = accs.vaa.token_chain;
+        accs.meta.token_address = accs.vaa.token_address;
+        accs.meta.token_id = accs.vaa.token_id.0;
+    }
+
+    if !accs.to.is_initialized() {
+        let associated_addr = spl_associated_token_account::get_associated_token_address(
+            accs.to_authority.info().key,
+            accs.mint.info().key,
+        );
+        if *accs.to_authority.info().key != associated_addr {
+            return Err(InvalidAssociatedAccount.into());
+        }
+        // Create associated token account
+        let ix = spl_associated_token_account::create_associated_token_account(
+            accs.payer.info().key,
+            accs.to_authority.info().key,
+            accs.mint.info().key,
+        );
+        invoke(&ix, ctx.accounts)?;
+    } else if *accs.mint.info().key != accs.to.mint {
+        return Err(InvalidMint.into());
+    }
+
+    // Mint tokens
+    let mint_ix = spl_token::instruction::mint_to(
+        &spl_token::id(),
+        accs.mint.info().key,
+        accs.to.info().key,
+        accs.mint_authority.key,
+        &[],
+        1,
+    )?;
+    invoke_seeded(&mint_ix, ctx, &accs.mint_authority, None)?;
+
+    Ok(())
+}

solana/modules/nft_bridge/program/src/api/governance.rs

@@ -0,0 +1,177 @@
+use crate::{
+    accounts::{
+        ConfigAccount,
+        Endpoint,
+        EndpointDerivationData,
+    },
+    messages::{
+        GovernancePayloadUpgrade,
+        PayloadGovernanceRegisterChain,
+    },
+    types::*,
+    TokenBridgeError::{
+        InvalidChain,
+        InvalidGovernanceKey,
+    },
+};
+use bridge::{
+    vaa::{
+        ClaimableVAA,
+        DeserializePayload,
+        PayloadMessage,
+    },
+    CHAIN_ID_SOLANA,
+};
+use solana_program::{
+    account_info::AccountInfo,
+    program::invoke_signed,
+    program_error::ProgramError,
+    pubkey::Pubkey,
+    sysvar::{
+        clock::Clock,
+        rent::Rent,
+    },
+};
+use solitaire::{
+    processors::seeded::Seeded,
+    CreationLamports::Exempt,
+    *,
+};
+use std::ops::{
+    Deref,
+    DerefMut,
+};
+
+// Confirm that a ClaimableVAA came from the correct chain, signed by the right emitter.
+fn verify_governance<'a, T>(vaa: &ClaimableVAA<'a, T>) -> Result<()>
+where
+    T: DeserializePayload,
+{
+    let expected_emitter = std::env!("EMITTER_ADDRESS");
+    let current_emitter = format!(
+        "{}",
+        Pubkey::new_from_array(vaa.message.meta().emitter_address)
+    );
+    // Fail if the emitter is not the known governance key, or the emitting chain is not Solana.
+    if expected_emitter != current_emitter || vaa.message.meta().emitter_chain != CHAIN_ID_SOLANA {
+        Err(InvalidGovernanceKey.into())
+    } else {
+        Ok(())
+    }
+}
+
+#[derive(FromAccounts)]
+pub struct UpgradeContract<'b> {
+    /// Payer for account creation (vaa-claim)
+    pub payer: Mut<Signer<Info<'b>>>,
+
+    /// GuardianSet change VAA
+    pub vaa: ClaimableVAA<'b, GovernancePayloadUpgrade>,
+
+    /// PDA authority for the loader
+    pub upgrade_authority: Derive<Info<'b>, "upgrade">,
+
+    /// Spill address for the upgrade excess lamports
+    pub spill: Mut<Info<'b>>,
+
+    /// New contract address.
+    pub buffer: Mut<Info<'b>>,
+
+    /// Required by the upgradeable uploader.
+    pub program_data: Mut<Info<'b>>,
+
+    /// Our own address, required by the upgradeable loader.
+    pub own_address: Mut<Info<'b>>,
+
+    // Various sysvar/program accounts needed for the upgradeable loader.
+    pub rent: Sysvar<'b, Rent>,
+    pub clock: Sysvar<'b, Clock>,
+    pub bpf_loader: Info<'b>,
+    pub system: Info<'b>,
+}
+
+impl<'b> InstructionContext<'b> for UpgradeContract<'b> {
+}
+
+#[derive(BorshDeserialize, BorshSerialize, Default)]
+pub struct UpgradeContractData {}
+
+pub fn upgrade_contract(
+    ctx: &ExecutionContext,
+    accs: &mut UpgradeContract,
+    _data: UpgradeContractData,
+) -> Result<()> {
+    verify_governance(&accs.vaa)?;
+    accs.vaa.verify(&ctx.program_id)?;
+
+    accs.vaa.claim(ctx, accs.payer.key)?;
+
+    let upgrade_ix = solana_program::bpf_loader_upgradeable::upgrade(
+        ctx.program_id,
+        &accs.vaa.message.new_contract,
+        accs.upgrade_authority.key,
+        accs.spill.key,
+    );
+
+    let seeds = accs
+        .upgrade_authority
+        .self_bumped_seeds(None, ctx.program_id);
+    let seeds: Vec<&[u8]> = seeds.iter().map(|item| item.as_slice()).collect();
+    let seeds = seeds.as_slice();
+    invoke_signed(&upgrade_ix, ctx.accounts, &[seeds])?;
+
+    Ok(())
+}
+
+#[derive(FromAccounts)]
+pub struct RegisterChain<'b> {
+    pub payer: Mut<Signer<AccountInfo<'b>>>,
+    pub config: ConfigAccount<'b, { AccountState::Initialized }>,
+
+    pub endpoint: Mut<Endpoint<'b, { AccountState::Uninitialized }>>,
+
+    pub vaa: ClaimableVAA<'b, PayloadGovernanceRegisterChain>,
+}
+
+impl<'a> From<&RegisterChain<'a>> for EndpointDerivationData {
+    fn from(accs: &RegisterChain<'a>) -> Self {
+        EndpointDerivationData {
+            emitter_chain: accs.vaa.chain,
+            emitter_address: accs.vaa.endpoint_address,
+        }
+    }
+}
+
+impl<'b> InstructionContext<'b> for RegisterChain<'b> {
+}
+
+#[derive(BorshDeserialize, BorshSerialize, Default)]
+pub struct RegisterChainData {}
+
+pub fn register_chain(
+    ctx: &ExecutionContext,
+    accs: &mut RegisterChain,
+    data: RegisterChainData,
+) -> Result<()> {
+    let derivation_data: EndpointDerivationData = (&*accs).into();
+    accs.endpoint
+        .verify_derivation(ctx.program_id, &derivation_data)?;
+
+    // Claim VAA
+    verify_governance(&accs.vaa)?;
+    accs.vaa.verify(&ctx.program_id)?;
+    accs.vaa.claim(ctx, accs.payer.key)?;
+
+    if accs.vaa.chain == CHAIN_ID_SOLANA {
+        return Err(InvalidChain.into());
+    }
+
+    // Create endpoint
+    accs.endpoint
+        .create(&((&*accs).into()), ctx, accs.payer.key, Exempt);
+
+    accs.endpoint.chain = accs.vaa.chain;
+    accs.endpoint.contract = accs.vaa.endpoint_address;
+
+    Ok(())
+}

solana/modules/nft_bridge/program/src/api/initialize.rs

@@ -0,0 +1,44 @@
+use crate::{
+    accounts::ConfigAccount,
+    types::*,
+};
+use solana_program::{
+    account_info::AccountInfo,
+    msg,
+    program_error::ProgramError,
+    pubkey::Pubkey,
+};
+use solitaire::{
+    CreationLamports::Exempt,
+    *,
+};
+use std::ops::{
+    Deref,
+    DerefMut,
+};
+
+#[derive(FromAccounts)]
+pub struct Initialize<'b> {
+    pub payer: Mut<Signer<AccountInfo<'b>>>,
+
+    pub config: Mut<ConfigAccount<'b, { AccountState::Uninitialized }>>,
+}
+
+#[derive(BorshDeserialize, BorshSerialize, Default)]
+pub struct InitializeData {
+    pub bridge: Pubkey,
+}
+
+impl<'b> InstructionContext<'b> for Initialize<'b> {
+}
+
+pub fn initialize(
+    ctx: &ExecutionContext,
+    accs: &mut Initialize,
+    data: InitializeData,
+) -> Result<()> {
+    // Create the config account
+    accs.config.create(ctx, accs.payer.key, Exempt)?;
+    accs.config.wormhole_bridge = data.bridge;
+    Ok(())
+}

solana/modules/nft_bridge/program/src/api/transfer.rs

@@ -0,0 +1,404 @@
+use crate::{
+    accounts::{
+        AuthoritySigner,
+        ConfigAccount,
+        CoreBridge,
+        CustodyAccount,
+        CustodyAccountDerivationData,
+        CustodySigner,
+        EmitterAccount,
+        MintSigner,
+        SplTokenMeta,
+        SplTokenMetaDerivationData,
+        WrappedDerivationData,
+        WrappedMetaDerivationData,
+        WrappedMint,
+        WrappedTokenMeta,
+    },
+    messages::PayloadTransfer,
+    types::*,
+    TokenBridgeError,
+    TokenBridgeError::{
+        InvalidMetadata,
+        TokenNotNFT,
+        WrongAccountOwner,
+    },
+};
+use bridge::{
+    accounts::Bridge,
+    api::{
+        PostMessage,
+        PostMessageData,
+    },
+    types::ConsistencyLevel,
+    vaa::SerializePayload,
+};
+use primitive_types::U256;
+use solana_program::{
+    account_info::AccountInfo,
+    instruction::{
+        AccountMeta,
+        Instruction,
+    },
+    program::{
+        invoke,
+        invoke_signed,
+    },
+    program_error::ProgramError,
+    program_option::COption,
+    pubkey::Pubkey,
+    sysvar::clock::Clock,
+};
+use solitaire::{
+    processors::seeded::{
+        invoke_seeded,
+        Seeded,
+    },
+    CreationLamports::Exempt,
+    *,
+};
+use spl_token::{
+    error::TokenError::OwnerMismatch,
+    state::{
+        Account,
+        Mint,
+    },
+};
+use spl_token_metadata::state::Metadata;
+use std::ops::{
+    Deref,
+    DerefMut,
+};
+
+#[derive(FromAccounts)]
+pub struct TransferNative<'b> {
+    pub payer: Mut<Signer<AccountInfo<'b>>>,
+
+    pub config: ConfigAccount<'b, { AccountState::Initialized }>,
+
+    pub from: Mut<Data<'b, SplAccount, { AccountState::Initialized }>>,
+
+    pub mint: Mut<Data<'b, SplMint, { AccountState::Initialized }>>,
+    /// SPL Metadata for the associated Mint
+    pub spl_metadata: SplTokenMeta<'b>,
+
+    pub custody: Mut<CustodyAccount<'b, { AccountState::MaybeInitialized }>>,
+
+    // This could allow someone to race someone else's tx if they do the approval in a separate tx.
+    // Therefore the approval must be set in the same tx.
+    pub authority_signer: AuthoritySigner<'b>,
+
+    pub custody_signer: CustodySigner<'b>,
+
+    /// CPI Context
+    pub bridge: Mut<CoreBridge<'b, { AccountState::Initialized }>>,
+
+    /// Account to store the posted message
+    pub message: Signer<Mut<Info<'b>>>,
+
+    /// Emitter of the VAA
+    pub emitter: EmitterAccount<'b>,
+
+    /// Tracker for the emitter sequence
+    pub sequence: Mut<Info<'b>>,
+
+    /// Account to collect tx fee
+    pub fee_collector: Mut<Info<'b>>,
+
+    pub clock: Sysvar<'b, Clock>,
+}
+
+impl<'a> From<&TransferNative<'a>> for CustodyAccountDerivationData {
+    fn from(accs: &TransferNative<'a>) -> Self {
+        CustodyAccountDerivationData {
+            mint: *accs.mint.info().key,
+        }
+    }
+}
+
+impl<'a> From<&TransferNative<'a>> for SplTokenMetaDerivationData {
+    fn from(accs: &TransferNative<'a>) -> Self {
+        SplTokenMetaDerivationData {
+            mint: *accs.mint.info().key,
+        }
+    }
+}
+
+impl<'b> InstructionContext<'b> for TransferNative<'b> {
+}
+
+#[derive(BorshDeserialize, BorshSerialize, Default)]
+pub struct TransferNativeData {
+    pub nonce: u32,
+    pub target_address: Address,
+    pub target_chain: ChainID,
+}
+
+pub fn transfer_native(
+    ctx: &ExecutionContext,
+    accs: &mut TransferNative,
+    data: TransferNativeData,
+) -> Result<()> {
+    // Verify that the custody account is derived correctly
+    let derivation_data: CustodyAccountDerivationData = (&*accs).into();
+    accs.custody
+        .verify_derivation(ctx.program_id, &derivation_data)?;
+
+    let derivation_data: SplTokenMetaDerivationData = (&*accs).into();
+    accs.spl_metadata
+        .verify_derivation(&spl_token_metadata::id(), &derivation_data)?;
+
+    // Verify mints
+    if accs.from.mint != *accs.mint.info().key {
+        return Err(TokenBridgeError::InvalidMint.into());
+    }
+
+    // Token must have metadata
+    if !accs.spl_metadata.data_is_empty() {
+        return Err(TokenNotNFT.into());
+    }
+
+    if *accs.spl_metadata.owner != spl_token_metadata::id() {
+        return Err(WrongAccountOwner.into());
+    }
+
+    // Verify that the token is not a wrapped token
+    if let COption::Some(mint_authority) = accs.mint.mint_authority {
+        if mint_authority == MintSigner::key(None, ctx.program_id) {
+            return Err(TokenBridgeError::TokenNotNative.into());
+        }
+    }
+
+    if !accs.custody.is_initialized() {
+        accs.custody
+            .create(&(&*accs).into(), ctx, accs.payer.key, Exempt)?;
+
+        let init_ix = spl_token::instruction::initialize_account(
+            &spl_token::id(),
+            accs.custody.info().key,
+            accs.mint.info().key,
+            accs.custody_signer.key,
+        )?;
+        invoke_signed(&init_ix, ctx.accounts, &[])?;
+    }
+
+    // Transfer tokens
+    let transfer_ix = spl_token::instruction::transfer(
+        &spl_token::id(),
+        accs.from.info().key,
+        accs.custody.info().key,
+        accs.authority_signer.key,
+        &[],
+        1,
+    )?;
+    invoke_seeded(&transfer_ix, ctx, &accs.authority_signer, None)?;
+
+    // Pay fee
+    let transfer_ix = solana_program::system_instruction::transfer(
+        accs.payer.key,
+        accs.fee_collector.key,
+        accs.bridge.config.fee,
+    );
+    invoke(&transfer_ix, ctx.accounts)?;
+
+    let metadata: Metadata =
+        Metadata::from_account_info(accs.spl_metadata.info()).ok_or(InvalidMetadata)?;
+
+    // Post message
+    let payload = PayloadTransfer {
+        token_address: accs.mint.info().key.to_bytes(),
+        token_chain: 1,
+        to: data.target_address,
+        to_chain: data.target_chain,
+        symbol: metadata.data.symbol,
+        name: metadata.data.name,
+        uri: metadata.data.uri,
+        token_id: U256::from(0), // TODO
+    };
+    let params = (
+        bridge::instruction::Instruction::PostMessage,
+        PostMessageData {
+            nonce: data.nonce,
+            payload: payload.try_to_vec()?,
+            consistency_level: ConsistencyLevel::Confirmed,
+        },
+    );
+
+    let ix = Instruction::new_with_bytes(
+        accs.config.wormhole_bridge,
+        params.try_to_vec()?.as_slice(),
+        vec![
+            AccountMeta::new(*accs.bridge.info().key, false),
+            AccountMeta::new(*accs.message.key, true),
+            AccountMeta::new_readonly(*accs.emitter.key, true),
+            AccountMeta::new(*accs.sequence.key, false),
+            AccountMeta::new(*accs.payer.key, true),
+            AccountMeta::new(*accs.fee_collector.key, false),
+            AccountMeta::new_readonly(*accs.clock.info().key, false),
+            AccountMeta::new_readonly(solana_program::system_program::id(), false),
+            AccountMeta::new_readonly(solana_program::sysvar::rent::ID, false),
+        ],
+    );
+    invoke_seeded(&ix, ctx, &accs.emitter, None)?;
+
+    Ok(())
+}
+
+#[derive(FromAccounts)]
+pub struct TransferWrapped<'b> {
+    pub payer: Mut<Signer<AccountInfo<'b>>>,
+    pub config: ConfigAccount<'b, { AccountState::Initialized }>,
+
+    pub from: Mut<Data<'b, SplAccount, { AccountState::Initialized }>>,
+    pub from_owner: MaybeMut<Signer<Info<'b>>>,
+    pub mint: Mut<WrappedMint<'b, { AccountState::Initialized }>>,
+    pub wrapped_meta: WrappedTokenMeta<'b, { AccountState::Initialized }>,
+    /// SPL Metadata for the associated Mint
+    pub spl_metadata: SplTokenMeta<'b>,
+
+    pub authority_signer: AuthoritySigner<'b>,
+
+    /// CPI Context
+    pub bridge: Mut<CoreBridge<'b, { AccountState::Initialized }>>,
+
+    /// Account to store the posted message
+    pub message: Signer<Mut<Info<'b>>>,
+
+    /// Emitter of the VAA
+    pub emitter: EmitterAccount<'b>,
+
+    /// Tracker for the emitter sequence
+    pub sequence: Mut<Info<'b>>,
+
+    /// Account to collect tx fee
+    pub fee_collector: Mut<Info<'b>>,
+
+    pub clock: Sysvar<'b, Clock>,
+}
+
+impl<'a> From<&TransferWrapped<'a>> for WrappedMetaDerivationData {
+    fn from(accs: &TransferWrapped<'a>) -> Self {
+        WrappedMetaDerivationData {
+            mint_key: *accs.mint.info().key,
+        }
+    }
+}
+
+impl<'a> From<&TransferWrapped<'a>> for SplTokenMetaDerivationData {
+    fn from(accs: &TransferWrapped<'a>) -> Self {
+        SplTokenMetaDerivationData {
+            mint: *accs.mint.info().key,
+        }
+    }
+}
+
+impl<'b> InstructionContext<'b> for TransferWrapped<'b> {
+}
+
+#[derive(BorshDeserialize, BorshSerialize, Default)]
+pub struct TransferWrappedData {
+    pub nonce: u32,
+    pub target_address: Address,
+    pub target_chain: ChainID,
+}
+
+pub fn transfer_wrapped(
+    ctx: &ExecutionContext,
+    accs: &mut TransferWrapped,
+    data: TransferWrappedData,
+) -> Result<()> {
+    // Verify that the from account is owned by the from_owner
+    if &accs.from.owner != accs.from_owner.key {
+        return Err(WrongAccountOwner.into());
+    }
+
+    // Verify mints
+    if accs.mint.info().key != &accs.from.mint {
+        return Err(TokenBridgeError::InvalidMint.into());
+    }
+
+    // Verify that meta is correct
+    let derivation_data: WrappedMetaDerivationData = (&*accs).into();
+    accs.wrapped_meta
+        .verify_derivation(ctx.program_id, &derivation_data)?;
+
+    // Burn tokens
+    let burn_ix = spl_token::instruction::burn(
+        &spl_token::id(),
+        accs.from.info().key,
+        accs.mint.info().key,
+        accs.authority_signer.key,
+        &[],
+        1,
+    )?;
+    invoke_seeded(&burn_ix, ctx, &accs.authority_signer, None)?;
+
+    // Pay fee
+    let transfer_ix = solana_program::system_instruction::transfer(
+        accs.payer.key,
+        accs.fee_collector.key,
+        accs.bridge.config.fee,
+    );
+
+    invoke(&transfer_ix, ctx.accounts)?;
+
+    // Enfoce wrapped meta to be uninitialized.
+    let derivation_data: WrappedMetaDerivationData = (&*accs).into();
+    accs.wrapped_meta
+        .verify_derivation(ctx.program_id, &derivation_data)?;
+
+    // Token must have metadata
+    if !accs.spl_metadata.data_is_empty() {
+        return Err(TokenNotNFT.into());
+    }
+
+    let derivation_data: SplTokenMetaDerivationData = (&*accs).into();
+    accs.spl_metadata
+        .verify_derivation(&spl_token_metadata::id(), &derivation_data)?;
+
+    if *accs.spl_metadata.owner != spl_token_metadata::id() {
+        return Err(WrongAccountOwner.into());
+    }
+
+    let metadata: Metadata =
+        Metadata::from_account_info(accs.spl_metadata.info()).ok_or(InvalidMetadata)?;
+
+    // Post message
+    let payload = PayloadTransfer {
+        token_address: accs.wrapped_meta.token_address,
+        token_chain: accs.wrapped_meta.chain,
+        token_id: U256(accs.wrapped_meta.token_id),
+        to: data.target_address,
+        to_chain: data.target_chain,
+        symbol: metadata.data.symbol,
+        name: metadata.data.name,
+        uri: metadata.data.uri,
+    };
+    let params = (
+        bridge::instruction::Instruction::PostMessage,
+        PostMessageData {
+            nonce: data.nonce,
+            payload: payload.try_to_vec()?,
+            consistency_level: ConsistencyLevel::Confirmed,
+        },
+    );
+
+    let ix = Instruction::new_with_bytes(
+        accs.config.wormhole_bridge,
+        params.try_to_vec()?.as_slice(),
+        vec![
+            AccountMeta::new(*accs.bridge.info().key, false),
+            AccountMeta::new(*accs.message.key, true),
+            AccountMeta::new_readonly(*accs.emitter.key, true),
+            AccountMeta::new(*accs.sequence.key, false),
+            AccountMeta::new(*accs.payer.key, true),
+            AccountMeta::new(*accs.fee_collector.key, false),
+            AccountMeta::new_readonly(*accs.clock.info().key, false),
+            AccountMeta::new_readonly(solana_program::system_program::id(), false),
+            AccountMeta::new_readonly(solana_program::sysvar::rent::ID, false),
+        ],
+    );
+    invoke_seeded(&ix, ctx, &accs.emitter, None)?;
+
+    Ok(())
+}

solana/modules/nft_bridge/program/src/instructions.rs

@@ -0,0 +1,462 @@
+use crate::{
+    accounts::{
+        AuthoritySigner,
+        ConfigAccount,
+        CustodyAccount,
+        CustodyAccountDerivationData,
+        CustodySigner,
+        EmitterAccount,
+        Endpoint,
+        EndpointDerivationData,
+        MintSigner,
+        SplTokenMeta,
+        SplTokenMetaDerivationData,
+        WrappedDerivationData,
+        WrappedMetaDerivationData,
+        WrappedMint,
+        WrappedTokenMeta,
+    },
+    api::{
+        complete_transfer::{
+            CompleteNativeData,
+            CompleteWrappedData,
+        },
+        RegisterChainData,
+        TransferNativeData,
+        TransferWrappedData,
+        UpgradeContractData,
+    },
+    messages::{
+        PayloadGovernanceRegisterChain,
+        PayloadTransfer,
+    },
+};
+use borsh::BorshSerialize;
+use bridge::{
+    accounts::{
+        Bridge,
+        Claim,
+        ClaimDerivationData,
+        FeeCollector,
+        PostedVAA,
+        PostedVAADerivationData,
+        Sequence,
+        SequenceDerivationData,
+    },
+    api::ForeignAddress,
+    instructions::hash_vaa,
+    types::{
+        BridgeConfig,
+        PostedVAAData,
+    },
+    vaa::{
+        ClaimableVAA,
+        PayloadMessage,
+        SerializePayload,
+    },
+    PostVAA,
+    PostVAAData,
+    CHAIN_ID_SOLANA,
+};
+use primitive_types::U256;
+use solana_program::{
+    instruction::{
+        AccountMeta,
+        Instruction,
+    },
+    pubkey::Pubkey,
+};
+use solitaire::{
+    processors::seeded::Seeded,
+    AccountState,
+};
+use spl_token::state::Mint;
+use std::str::FromStr;
+
+pub fn initialize(
+    program_id: Pubkey,
+    payer: Pubkey,
+    bridge: Pubkey,
+) -> solitaire::Result<Instruction> {
+    let config_key = ConfigAccount::<'_, { AccountState::Uninitialized }>::key(None, &program_id);
+    Ok(Instruction {
+        program_id,
+        accounts: vec![
+            AccountMeta::new(payer, true),
+            AccountMeta::new(config_key, false),
+            // Dependencies
+            AccountMeta::new(solana_program::sysvar::rent::id(), false),
+            AccountMeta::new(solana_program::system_program::id(), false),
+        ],
+        data: (crate::instruction::Instruction::Initialize, bridge).try_to_vec()?,
+    })
+}
+
+pub fn complete_native(
+    program_id: Pubkey,
+    bridge_id: Pubkey,
+    payer: Pubkey,
+    message_key: Pubkey,
+    vaa: PostVAAData,
+    to_authority: Pubkey,
+    mint: Pubkey,
+    data: CompleteNativeData,
+) -> solitaire::Result<Instruction> {
+    let config_key = ConfigAccount::<'_, { AccountState::Uninitialized }>::key(None, &program_id);
+    let (message_acc, claim_acc) = claimable_vaa(program_id, message_key, vaa.clone());
+    let endpoint = Endpoint::<'_, { AccountState::Initialized }>::key(
+        &EndpointDerivationData {
+            emitter_chain: vaa.emitter_chain,
+            emitter_address: vaa.emitter_address,
+        },
+        &program_id,
+    );
+    let custody_key = CustodyAccount::<'_, { AccountState::Initialized }>::key(
+        &CustodyAccountDerivationData { mint },
+        &program_id,
+    );
+    let custody_signer_key = CustodySigner::key(None, &program_id);
+    let associated_addr =
+        spl_associated_token_account::get_associated_token_address(&to_authority, &mint);
+
+    Ok(Instruction {
+        program_id,
+        accounts: vec![
+            AccountMeta::new(payer, true),
+            AccountMeta::new_readonly(config_key, false),
+            message_acc,
+            claim_acc,
+            AccountMeta::new_readonly(endpoint, false),
+            AccountMeta::new(associated_addr, false),
+            AccountMeta::new_readonly(to_authority, false),
+            AccountMeta::new(custody_key, false),
+            AccountMeta::new_readonly(mint, false),
+            AccountMeta::new_readonly(custody_signer_key, false),
+            // Dependencies
+            AccountMeta::new_readonly(solana_program::sysvar::rent::id(), false),
+            AccountMeta::new_readonly(solana_program::system_program::id(), false),
+            // Program
+            AccountMeta::new_readonly(bridge_id, false),
+            AccountMeta::new_readonly(spl_token::id(), false),
+            AccountMeta::new_readonly(spl_associated_token_account::id(), false),
+        ],
+        data: (crate::instruction::Instruction::CompleteNative, data).try_to_vec()?,
+    })
+}
+
+pub fn complete_wrapped(
+    program_id: Pubkey,
+    bridge_id: Pubkey,
+    payer: Pubkey,
+    message_key: Pubkey,
+    vaa: PostVAAData,
+    payload: PayloadTransfer,
+    to_authority: Pubkey,
+    data: CompleteWrappedData,
+) -> solitaire::Result<Instruction> {
+    let config_key = ConfigAccount::<'_, { AccountState::Uninitialized }>::key(None, &program_id);
+    let (message_acc, claim_acc) = claimable_vaa(program_id, message_key, vaa.clone());
+    let endpoint = Endpoint::<'_, { AccountState::Initialized }>::key(
+        &EndpointDerivationData {
+            emitter_chain: vaa.emitter_chain,
+            emitter_address: vaa.emitter_address,
+        },
+        &program_id,
+    );
+    let mint_key = WrappedMint::<'_, { AccountState::Uninitialized }>::key(
+        &WrappedDerivationData {
+            token_chain: payload.token_chain,
+            token_address: payload.token_address,
+            token_id: payload.token_id,
+        },
+        &program_id,
+    );
+    let mint_authority_key = MintSigner::key(None, &program_id);
+
+    let mint_meta_key = WrappedTokenMeta::<'_, { AccountState::Uninitialized }>::key(
+        &WrappedMetaDerivationData { mint_key },
+        &program_id,
+    );
+    // SPL Metadata
+    let spl_metadata = SplTokenMeta::key(
+        &SplTokenMetaDerivationData { mint: mint_key },
+        &spl_token_metadata::id(),
+    );
+    let associated_addr =
+        spl_associated_token_account::get_associated_token_address(&to_authority, &mint_key);
+
+    Ok(Instruction {
+        program_id,
+        accounts: vec![
+            AccountMeta::new(payer, true),
+            AccountMeta::new_readonly(config_key, false),
+            message_acc,
+            claim_acc,
+            AccountMeta::new_readonly(endpoint, false),
+            AccountMeta::new(associated_addr, false),
+            AccountMeta::new_readonly(to_authority, false),
+            AccountMeta::new(mint_key, false),
+            AccountMeta::new(mint_meta_key, false),
+            AccountMeta::new(spl_metadata, false),
+            AccountMeta::new_readonly(mint_authority_key, false),
+            // Dependencies
+            AccountMeta::new_readonly(solana_program::sysvar::rent::id(), false),
+            AccountMeta::new_readonly(solana_program::system_program::id(), false),
+            // Program
+            AccountMeta::new_readonly(bridge_id, false),
+            AccountMeta::new_readonly(spl_token::id(), false),
+            AccountMeta::new_readonly(spl_associated_token_account::id(), false),
+        ],
+        data: (crate::instruction::Instruction::CompleteWrapped, data).try_to_vec()?,
+    })
+}
+
+pub fn register_chain(
+    program_id: Pubkey,
+    bridge_id: Pubkey,
+    payer: Pubkey,
+    message_key: Pubkey,
+    vaa: PostVAAData,
+    payload: PayloadGovernanceRegisterChain,
+    data: RegisterChainData,
+) -> solitaire::Result<Instruction> {
+    let config_key = ConfigAccount::<'_, { AccountState::Uninitialized }>::key(None, &program_id);
+    let (message_acc, claim_acc) = claimable_vaa(program_id, message_key, vaa);
+    let endpoint = Endpoint::<'_, { AccountState::Initialized }>::key(
+        &EndpointDerivationData {
+            emitter_chain: payload.chain,
+            emitter_address: payload.endpoint_address,
+        },
+        &program_id,
+    );
+
+    Ok(Instruction {
+        program_id,
+        accounts: vec![
+            AccountMeta::new(payer, true),
+            AccountMeta::new_readonly(config_key, false),
+            AccountMeta::new(endpoint, false),
+            message_acc,
+            claim_acc,
+            // Dependencies
+            AccountMeta::new(solana_program::sysvar::rent::id(), false),
+            AccountMeta::new(solana_program::system_program::id(), false),
+            // Program
+            AccountMeta::new_readonly(bridge_id, false),
+        ],
+        data: (crate::instruction::Instruction::RegisterChain, data).try_to_vec()?,
+    })
+}
+
+fn claimable_vaa(
+    bridge_id: Pubkey,
+    message_key: Pubkey,
+    vaa: PostVAAData,
+) -> (AccountMeta, AccountMeta) {
+    let claim_key = Claim::<'_, { AccountState::Initialized }>::key(
+        &ClaimDerivationData {
+            emitter_address: vaa.emitter_address,
+            emitter_chain: vaa.emitter_chain,
+            sequence: vaa.sequence,
+        },
+        &bridge_id,
+    );
+
+    (
+        AccountMeta::new_readonly(message_key, false),
+        AccountMeta::new(claim_key, false),
+    )
+}
+
+pub fn transfer_native(
+    program_id: Pubkey,
+    bridge_id: Pubkey,
+    payer: Pubkey,
+    message_key: Pubkey,
+    from: Pubkey,
+    mint: Pubkey,
+    data: TransferNativeData,
+) -> solitaire::Result<Instruction> {
+    let config_key = ConfigAccount::<'_, { AccountState::Uninitialized }>::key(None, &program_id);
+    let custody_key = CustodyAccount::<'_, { AccountState::Initialized }>::key(
+        &CustodyAccountDerivationData { mint },
+        &program_id,
+    );
+
+    let authority_signer_key = AuthoritySigner::key(None, &program_id);
+    let custody_signer_key = CustodySigner::key(None, &program_id);
+    let emitter_key = EmitterAccount::key(None, &program_id);
+
+    // SPL Metadata
+    let spl_metadata = SplTokenMeta::key(
+        &SplTokenMetaDerivationData { mint: mint },
+        &spl_token_metadata::id(),
+    );
+
+    // Bridge keys
+    let bridge_config = Bridge::<'_, { AccountState::Uninitialized }>::key(None, &bridge_id);
+    let sequence_key = Sequence::key(
+        &SequenceDerivationData {
+            emitter_key: &emitter_key,
+        },
+        &bridge_id,
+    );
+    let fee_collector_key = FeeCollector::key(None, &bridge_id);
+
+    Ok(Instruction {
+        program_id,
+        accounts: vec![
+            AccountMeta::new(payer, true),
+            AccountMeta::new_readonly(config_key, false),
+            AccountMeta::new(from, false),
+            AccountMeta::new(mint, false),
+            AccountMeta::new_readonly(spl_metadata, false),
+            AccountMeta::new(custody_key, false),
+            AccountMeta::new_readonly(authority_signer_key, false),
+            AccountMeta::new_readonly(custody_signer_key, false),
+            AccountMeta::new(bridge_config, false),
+            AccountMeta::new(message_key, true),
+            AccountMeta::new_readonly(emitter_key, false),
+            AccountMeta::new(sequence_key, false),
+            AccountMeta::new(fee_collector_key, false),
+            AccountMeta::new_readonly(solana_program::sysvar::clock::id(), false),
+            // Dependencies
+            AccountMeta::new_readonly(solana_program::sysvar::rent::id(), false),
+            AccountMeta::new_readonly(solana_program::system_program::id(), false),
+            // Program
+            AccountMeta::new_readonly(bridge_id, false),
+            AccountMeta::new_readonly(spl_token::id(), false),
+        ],
+        data: (crate::instruction::Instruction::TransferNative, data).try_to_vec()?,
+    })
+}
+
+pub fn transfer_wrapped(
+    program_id: Pubkey,
+    bridge_id: Pubkey,
+    payer: Pubkey,
+    message_key: Pubkey,
+    from: Pubkey,
+    from_owner: Pubkey,
+    token_chain: u16,
+    token_address: ForeignAddress,
+    token_id: U256,
+    data: TransferWrappedData,
+) -> solitaire::Result<Instruction> {
+    let config_key = ConfigAccount::<'_, { AccountState::Uninitialized }>::key(None, &program_id);
+
+    let wrapped_mint_key = WrappedMint::<'_, { AccountState::Uninitialized }>::key(
+        &WrappedDerivationData {
+            token_chain,
+            token_address,
+            token_id,
+        },
+        &program_id,
+    );
+    let wrapped_meta_key = WrappedTokenMeta::<'_, { AccountState::Uninitialized }>::key(
+        &WrappedMetaDerivationData {
+            mint_key: wrapped_mint_key,
+        },
+        &program_id,
+    );
+
+    let authority_signer = AuthoritySigner::key(None, &program_id);
+    let emitter_key = EmitterAccount::key(None, &program_id);
+
+    // SPL Metadata
+    let spl_metadata = SplTokenMeta::key(
+        &SplTokenMetaDerivationData {
+            mint: wrapped_mint_key,
+        },
+        &spl_token_metadata::id(),
+    );
+
+    // Bridge keys
+    let bridge_config = Bridge::<'_, { AccountState::Uninitialized }>::key(None, &bridge_id);
+    let sequence_key = Sequence::key(
+        &SequenceDerivationData {
+            emitter_key: &emitter_key,
+        },
+        &bridge_id,
+    );
+    let fee_collector_key = FeeCollector::key(None, &bridge_id);
+
+    Ok(Instruction {
+        program_id,
+        accounts: vec![
+            AccountMeta::new(payer, true),
+            AccountMeta::new_readonly(config_key, false),
+            AccountMeta::new(from, false),
+            AccountMeta::new_readonly(from_owner, true),
+            AccountMeta::new(wrapped_mint_key, false),
+            AccountMeta::new_readonly(wrapped_meta_key, false),
+            AccountMeta::new_readonly(spl_metadata, false),
+            AccountMeta::new_readonly(authority_signer, false),
+            AccountMeta::new(bridge_config, false),
+            AccountMeta::new(message_key, true),
+            AccountMeta::new_readonly(emitter_key, false),
+            AccountMeta::new(sequence_key, false),
+            AccountMeta::new(fee_collector_key, false),
+            AccountMeta::new_readonly(solana_program::sysvar::clock::id(), false),
+            // Dependencies
+            AccountMeta::new_readonly(solana_program::sysvar::rent::id(), false),
+            AccountMeta::new_readonly(solana_program::system_program::id(), false),
+            // Program
+            AccountMeta::new_readonly(bridge_id, false),
+            AccountMeta::new_readonly(spl_token::id(), false),
+        ],
+        data: (crate::instruction::Instruction::TransferWrapped, data).try_to_vec()?,
+    })
+}
+
+pub fn upgrade_contract(
+    program_id: Pubkey,
+    payer: Pubkey,
+    payload_message: Pubkey,
+    emitter: Pubkey,
+    new_contract: Pubkey,
+    spill: Pubkey,
+    sequence: u64,
+) -> Instruction {
+    let claim = Claim::<'_, { AccountState::Uninitialized }>::key(
+        &ClaimDerivationData {
+            emitter_address: emitter.to_bytes(),
+            emitter_chain: CHAIN_ID_SOLANA,
+            sequence,
+        },
+        &program_id,
+    );
+
+    let (upgrade_authority, _) = Pubkey::find_program_address(&["upgrade".as_bytes()], &program_id);
+
+    let (program_data, _) = Pubkey::find_program_address(
+        &[program_id.as_ref()],
+        &solana_program::bpf_loader_upgradeable::id(),
+    );
+
+    Instruction {
+        program_id,
+
+        accounts: vec![
+            AccountMeta::new(payer, true),
+            AccountMeta::new_readonly(payload_message, false),
+            AccountMeta::new(claim, false),
+            AccountMeta::new_readonly(upgrade_authority, false),
+            AccountMeta::new(spill, false),
+            AccountMeta::new(new_contract, false),
+            AccountMeta::new(program_data, false),
+            AccountMeta::new(program_id, false),
+            AccountMeta::new_readonly(solana_program::sysvar::rent::id(), false),
+            AccountMeta::new_readonly(solana_program::sysvar::clock::id(), false),
+            AccountMeta::new_readonly(solana_program::bpf_loader_upgradeable::id(), false),
+            AccountMeta::new_readonly(solana_program::system_program::id(), false),
+        ],
+
+        data: (
+            crate::instruction::Instruction::UpgradeContract,
+            UpgradeContractData {},
+        )
+            .try_to_vec()
+            .unwrap(),
+    }
+}

solana/modules/nft_bridge/program/src/lib.rs

@@ -0,0 +1,78 @@
+#![feature(const_generics)]
+#![allow(warnings)]
+
+// #![cfg(all(target_arch = "bpf", not(feature = "no-entrypoint")))]
+
+#[cfg(feature = "no-entrypoint")]
+pub mod instructions;
+
+#[cfg(feature = "wasm")]
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+extern crate wasm_bindgen;
+
+#[cfg(feature = "wasm")]
+#[cfg(all(target_arch = "wasm32", target_os = "unknown"))]
+pub mod wasm;
+
+pub mod accounts;
+pub mod api;
+pub mod messages;
+pub mod types;
+
+pub use api::{
+    complete_native,
+    complete_wrapped,
+    initialize,
+    register_chain,
+    transfer_native,
+    transfer_wrapped,
+    upgrade_contract,
+    CompleteNative,
+    CompleteNativeData,
+    CompleteWrapped,
+    CompleteWrappedData,
+    Initialize,
+    InitializeData,
+    RegisterChain,
+    RegisterChainData,
+    TransferNative,
+    TransferNativeData,
+    TransferWrapped,
+    TransferWrappedData,
+    UpgradeContract,
+    UpgradeContractData,
+};
+
+use solitaire::*;
+use std::error::Error;
+
+pub enum TokenBridgeError {
+    AlreadyExecuted,
+    InvalidChain,
+    InvalidGovernanceKey,
+    InvalidMetadata,
+    InvalidMint,
+    InvalidPayload,
+    InvalidUTF8String,
+    TokenNotNative,
+    UninitializedMint,
+    WrongAccountOwner,
+    TokenNotNFT,
+    InvalidAssociatedAccount,
+}
+
+impl From<TokenBridgeError> for SolitaireError {
+    fn from(t: TokenBridgeError) -> SolitaireError {
+        SolitaireError::Custom(t as u64)
+    }
+}
+
+solitaire! {
+    Initialize(InitializeData) => initialize,
+    CompleteNative(CompleteNativeData) => complete_native,
+    CompleteWrapped(CompleteWrappedData) => complete_wrapped,
+    TransferWrapped(TransferWrappedData) => transfer_wrapped,
+    TransferNative(TransferNativeData) => transfer_native,
+    RegisterChain(RegisterChainData) => register_chain,
+    UpgradeContract(UpgradeContractData) => upgrade_contract,
+}

solana/modules/nft_bridge/program/src/messages.rs

@@ -0,0 +1,320 @@
+use crate::{
+    types::{
+        Address,
+        ChainID,
+    },
+    TokenBridgeError,
+};
+use borsh::{
+    BorshDeserialize,
+    BorshSerialize,
+};
+use bridge::{
+    vaa::{
+        DeserializePayload,
+        SerializePayload,
+    },
+    DeserializeGovernancePayload,
+    SerializeGovernancePayload,
+};
+use byteorder::{
+    BigEndian,
+    ReadBytesExt,
+    WriteBytesExt,
+};
+use primitive_types::U256;
+use solana_program::{
+    native_token::Sol,
+    program_error::{
+        ProgramError,
+        ProgramError::InvalidAccountData,
+    },
+    pubkey::Pubkey,
+};
+use solitaire::SolitaireError;
+use std::{
+    error::Error,
+    io::{
+        Cursor,
+        Read,
+        Write,
+    },
+    str::Utf8Error,
+    string::FromUtf8Error,
+};
+
+pub const MODULE: &str = "NFTBridge";
+
+#[derive(PartialEq, Debug, Clone)]
+pub struct PayloadTransfer {
+    // Address of the token. Left-zero-padded if shorter than 32 bytes
+    pub token_address: Address,
+    // Chain ID of the token
+    pub token_chain: ChainID,
+    // Symbol of the token
+    pub symbol: String,
+    // Name of the token
+    pub name: String,
+    // TokenID of the token (big-endian uint256)
+    pub token_id: U256,
+    // URI of the token metadata
+    pub uri: String,
+    // Address of the recipient. Left-zero-padded if shorter than 32 bytes
+    pub to: Address,
+    // Chain ID of the recipient
+    pub to_chain: ChainID,
+}
+
+impl DeserializePayload for PayloadTransfer {
+    fn deserialize(buf: &mut &[u8]) -> Result<Self, SolitaireError> {
+        let mut v = Cursor::new(buf);
+
+        if v.read_u8()? != 1 {
+            return Err(SolitaireError::Custom(0));
+        };
+
+        let mut token_address = Address::default();
+        v.read_exact(&mut token_address)?;
+
+        let token_chain = v.read_u16::<BigEndian>()?;
+
+        let mut symbol_data: [u8; 32] = [0; 32];
+        v.read_exact(&mut symbol_data)?;
+        let mut symbol = String::from_utf8(symbol_data.to_vec())
+            .map_err::<SolitaireError, _>(|_| TokenBridgeError::InvalidUTF8String.into())?;
+        symbol = symbol.chars().filter(|c| c != &'\0').collect();
+
+        let mut name_data: [u8; 32] = [0; 32];
+        v.read_exact(&mut name_data)?;
+        let mut name = String::from_utf8(name_data.to_vec())
+            .map_err::<SolitaireError, _>(|_| TokenBridgeError::InvalidUTF8String.into())?;
+        name = name.chars().filter(|c| c != &'\0').collect();
+
+        let mut id_data: [u8; 32] = [0; 32];
+        v.read_exact(&mut id_data)?;
+        let token_id = U256::from_big_endian(&id_data);
+
+        let uri_len = v.read_u8()?;
+        let mut uri_bytes = vec![0u8; uri_len as usize];
+        v.read_exact(uri_bytes.as_mut_slice())?;
+        let uri = String::from_utf8(uri_bytes).unwrap();
+
+        let mut to = Address::default();
+        v.read_exact(&mut to)?;
+
+        let to_chain = v.read_u16::<BigEndian>()?;
+
+        if v.position() != v.into_inner().len() as u64 {
+            return Err(InvalidAccountData.into());
+        }
+
+        Ok(PayloadTransfer {
+            token_address,
+            token_chain,
+            to,
+            to_chain,
+            symbol,
+            name,
+            token_id,
+            uri,
+        })
+    }
+}
+
+impl SerializePayload for PayloadTransfer {
+    fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), SolitaireError> {
+        // Payload ID
+        writer.write_u8(1)?;
+
+        writer.write(&self.token_address)?;
+        writer.write_u16::<BigEndian>(self.token_chain)?;
+
+        let mut symbol: [u8; 32] = [0; 32];
+        for i in 0..self.symbol.len() {
+            symbol[i] = self.symbol.as_bytes()[i];
+        }
+        writer.write(&symbol);
+
+        let mut name: [u8; 32] = [0; 32];
+        for i in 0..self.name.len() {
+            name[i] = self.name.as_bytes()[i];
+        }
+        writer.write(&name);
+
+        let mut id_data: [u8; 32] = [0; 32];
+        self.token_id.to_big_endian(&mut id_data);
+        writer.write(&id_data)?;
+
+        writer.write_u8(self.uri.len() as u8)?;
+        writer.write(self.uri.as_bytes())?;
+
+        writer.write(&self.to)?;
+        writer.write_u16::<BigEndian>(self.to_chain)?;
+
+        Ok(())
+    }
+}
+
+#[derive(PartialEq, Debug)]
+pub struct PayloadGovernanceRegisterChain {
+    // Chain ID of the chain to be registered
+    pub chain: ChainID,
+    // Address of the endpoint on the chain
+    pub endpoint_address: Address,
+}
+
+impl SerializeGovernancePayload for PayloadGovernanceRegisterChain {
+    const MODULE: &'static str = MODULE;
+    const ACTION: u8 = 1;
+}
+
+impl DeserializeGovernancePayload for PayloadGovernanceRegisterChain {
+}
+
+impl DeserializePayload for PayloadGovernanceRegisterChain
+where
+    Self: DeserializeGovernancePayload,
+{
+    fn deserialize(buf: &mut &[u8]) -> Result<Self, SolitaireError> {
+        let mut v = Cursor::new(buf);
+        Self::check_governance_header(&mut v)?;
+
+        let chain = v.read_u16::<BigEndian>()?;
+        let mut endpoint_address = [0u8; 32];
+        v.read_exact(&mut endpoint_address)?;
+
+        if v.position() != v.into_inner().len() as u64 {
+            return Err(InvalidAccountData.into());
+        }
+
+        Ok(PayloadGovernanceRegisterChain {
+            chain,
+            endpoint_address,
+        })
+    }
+}
+
+impl SerializePayload for PayloadGovernanceRegisterChain
+where
+    Self: SerializeGovernancePayload,
+{
+    fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), SolitaireError> {
+        self.write_governance_header(writer);
+        // Payload ID
+        writer.write_u16::<BigEndian>(self.chain)?;
+        writer.write(&self.endpoint_address[..])?;
+
+        Ok(())
+    }
+}
+
+#[derive(PartialEq, Debug)]
+pub struct GovernancePayloadUpgrade {
+    // Address of the new Implementation
+    pub new_contract: Pubkey,
+}
+
+impl SerializePayload for GovernancePayloadUpgrade {
+    fn serialize<W: Write>(&self, v: &mut W) -> std::result::Result<(), SolitaireError> {
+        self.write_governance_header(v);
+        v.write(&self.new_contract.to_bytes())?;
+        Ok(())
+    }
+}
+
+impl DeserializePayload for GovernancePayloadUpgrade
+where
+    Self: DeserializeGovernancePayload,
+{
+    fn deserialize(buf: &mut &[u8]) -> Result<Self, SolitaireError> {
+        let mut c = Cursor::new(buf);
+        Self::check_governance_header(&mut c)?;
+
+        let mut addr = [0u8; 32];
+        c.read_exact(&mut addr)?;
+
+        if c.position() != c.into_inner().len() as u64 {
+            return Err(InvalidAccountData.into());
+        }
+
+        Ok(GovernancePayloadUpgrade {
+            new_contract: Pubkey::new(&addr[..]),
+        })
+    }
+}
+
+impl SerializeGovernancePayload for GovernancePayloadUpgrade {
+    const MODULE: &'static str = MODULE;
+    const ACTION: u8 = 2;
+}
+
+impl DeserializeGovernancePayload for GovernancePayloadUpgrade {
+}
+
+#[cfg(feature = "no-entrypoint")]
+mod tests {
+    use crate::messages::{
+        GovernancePayloadUpgrade,
+        PayloadGovernanceRegisterChain,
+        PayloadTransfer,
+    };
+    use bridge::{
+        DeserializePayload,
+        SerializePayload,
+    };
+    use primitive_types::U256;
+    use rand::RngCore;
+    use solana_program::pubkey::Pubkey;
+
+    #[test]
+    pub fn test_serde_transfer() {
+        let mut token_address = [0u8; 32];
+        rand::thread_rng().fill_bytes(&mut token_address);
+        let mut to = [0u8; 32];
+        rand::thread_rng().fill_bytes(&mut to);
+
+        let transfer_original = PayloadTransfer {
+            token_address,
+            token_chain: 8,
+            to,
+            to_chain: 1,
+            name: String::from("Token Token"),
+            symbol: String::from("TEST"),
+            uri: String::from("https://abc.abc.abc.com"),
+            token_id: U256::from(1234),
+        };
+
+        let mut data = transfer_original.try_to_vec().unwrap();
+        let transfer_deser = PayloadTransfer::deserialize(&mut data.as_slice()).unwrap();
+
+        assert_eq!(transfer_original, transfer_deser);
+    }
+
+    #[test]
+    pub fn test_serde_gov_upgrade() {
+        let original = GovernancePayloadUpgrade {
+            new_contract: Pubkey::new_unique(),
+        };
+
+        let mut data = original.try_to_vec().unwrap();
+        let deser = GovernancePayloadUpgrade::deserialize(&mut data.as_slice()).unwrap();
+
+        assert_eq!(original, deser);
+    }
+
+    #[test]
+    pub fn test_serde_gov_register_chain() {
+        let mut endpoint_address = [0u8; 32];
+        rand::thread_rng().fill_bytes(&mut endpoint_address);
+
+        let original = PayloadGovernanceRegisterChain {
+            chain: 8,
+            endpoint_address,
+        };
+
+        let mut data = original.try_to_vec().unwrap();
+        let deser = PayloadGovernanceRegisterChain::deserialize(&mut data.as_slice()).unwrap();
+
+        assert_eq!(original, deser);
+    }
+}

solana/modules/nft_bridge/program/src/types.rs

@@ -0,0 +1,64 @@
+use borsh::{
+    BorshDeserialize,
+    BorshSerialize,
+};
+use primitive_types::U256;
+use serde::{
+    Deserialize,
+    Serialize,
+};
+use solana_program::pubkey::Pubkey;
+use solitaire::{
+    pack_type,
+    processors::seeded::{
+        AccountOwner,
+        Owned,
+    },
+};
+use spl_token::state::{
+    Account,
+    Mint,
+};
+use spl_token_metadata::state::Metadata;
+
+pub type Address = [u8; 32];
+pub type ChainID = u16;
+
+#[derive(Default, Clone, Copy, BorshDeserialize, BorshSerialize, Serialize, Deserialize)]
+pub struct Config {
+    pub wormhole_bridge: Pubkey,
+}
+
+impl Owned for Config {
+    fn owner(&self) -> AccountOwner {
+        AccountOwner::This
+    }
+}
+
+#[derive(Default, Clone, Copy, BorshDeserialize, BorshSerialize, Serialize, Deserialize)]
+pub struct EndpointRegistration {
+    pub chain: ChainID,
+    pub contract: Address,
+}
+
+impl Owned for EndpointRegistration {
+    fn owner(&self) -> AccountOwner {
+        AccountOwner::This
+    }
+}
+
+#[derive(Default, Clone, Copy, BorshDeserialize, BorshSerialize, Serialize, Deserialize)]
+pub struct WrappedMeta {
+    pub chain: ChainID,
+    pub token_address: Address,
+    pub token_id: [u64; 4],
+}
+
+impl Owned for WrappedMeta {
+    fn owner(&self) -> AccountOwner {
+        AccountOwner::This
+    }
+}
+
+pack_type!(SplMint, Mint, AccountOwner::Other(spl_token::id()));
+pack_type!(SplAccount, Account, AccountOwner::Other(spl_token::id()));

solana/modules/nft_bridge/program/src/wasm.rs

@@ -0,0 +1,367 @@
+use crate::{
+    accounts::{
+        AuthoritySigner,
+        EmitterAccount,
+        WrappedDerivationData,
+        WrappedMetaDerivationData,
+        WrappedMint,
+        WrappedTokenMeta,
+    },
+    instructions::{
+        complete_native,
+        complete_wrapped,
+        register_chain,
+        transfer_native,
+        transfer_wrapped,
+        upgrade_contract,
+    },
+    messages::{
+        GovernancePayloadUpgrade,
+        PayloadGovernanceRegisterChain,
+        PayloadTransfer,
+    },
+    types::{
+        EndpointRegistration,
+        WrappedMeta,
+    },
+    CompleteNativeData,
+    CompleteWrappedData,
+    RegisterChainData,
+    TransferNativeData,
+    TransferWrappedData,
+};
+use borsh::BorshDeserialize;
+use bridge::{
+    accounts::PostedVAADerivationData,
+    instructions::hash_vaa,
+    vaa::VAA,
+    DeserializePayload,
+    PostVAAData,
+};
+use primitive_types::U256;
+use solana_program::pubkey::Pubkey;
+use solitaire::{
+    processors::seeded::Seeded,
+    AccountState,
+};
+use std::str::FromStr;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub fn transfer_native_ix(
+    program_id: String,
+    bridge_id: String,
+    payer: String,
+    message: String,
+    from: String,
+    mint: String,
+    nonce: u32,
+    target_address: Vec<u8>,
+    target_chain: u16,
+) -> JsValue {
+    let program_id = Pubkey::from_str(program_id.as_str()).unwrap();
+    let bridge_id = Pubkey::from_str(bridge_id.as_str()).unwrap();
+    let payer = Pubkey::from_str(payer.as_str()).unwrap();
+    let message = Pubkey::from_str(message.as_str()).unwrap();
+    let from = Pubkey::from_str(from.as_str()).unwrap();
+    let mint = Pubkey::from_str(mint.as_str()).unwrap();
+
+    let mut target_addr = [0u8; 32];
+    target_addr.copy_from_slice(target_address.as_slice());
+
+    let ix = transfer_native(
+        program_id,
+        bridge_id,
+        payer,
+        message,
+        from,
+        mint,
+        TransferNativeData {
+            nonce,
+            target_address: target_addr,
+            target_chain,
+        },
+    )
+    .unwrap();
+
+    JsValue::from_serde(&ix).unwrap()
+}
+
+#[wasm_bindgen]
+pub fn transfer_wrapped_ix(
+    program_id: String,
+    bridge_id: String,
+    payer: String,
+    message: String,
+    from: String,
+    from_owner: String,
+    token_chain: u16,
+    token_address: Vec<u8>,
+    token_id: Vec<u8>,
+    nonce: u32,
+    target_address: Vec<u8>,
+    target_chain: u16,
+) -> JsValue {
+    let program_id = Pubkey::from_str(program_id.as_str()).unwrap();
+    let bridge_id = Pubkey::from_str(bridge_id.as_str()).unwrap();
+    let payer = Pubkey::from_str(payer.as_str()).unwrap();
+    let message = Pubkey::from_str(message.as_str()).unwrap();
+    let from = Pubkey::from_str(from.as_str()).unwrap();
+    let from_owner = Pubkey::from_str(from_owner.as_str()).unwrap();
+
+    let mut target_addr = [0u8; 32];
+    target_addr.copy_from_slice(target_address.as_slice());
+    let mut token_addr = [0u8; 32];
+    token_addr.copy_from_slice(token_address.as_slice());
+    let token_id = U256::from_little_endian(token_id.as_slice());
+
+    let ix = transfer_wrapped(
+        program_id,
+        bridge_id,
+        payer,
+        message,
+        from,
+        from_owner,
+        token_chain,
+        token_addr,
+        token_id,
+        TransferWrappedData {
+            nonce,
+            target_address: target_addr,
+            target_chain,
+        },
+    )
+    .unwrap();
+
+    JsValue::from_serde(&ix).unwrap()
+}
+
+#[wasm_bindgen]
+pub fn complete_transfer_native_ix(
+    program_id: String,
+    bridge_id: String,
+    payer: String,
+    to_authority: String,
+    vaa: Vec<u8>,
+) -> JsValue {
+    let program_id = Pubkey::from_str(program_id.as_str()).unwrap();
+    let bridge_id = Pubkey::from_str(bridge_id.as_str()).unwrap();
+    let payer = Pubkey::from_str(payer.as_str()).unwrap();
+    let to_authority = Pubkey::from_str(to_authority.as_str()).unwrap();
+    let vaa = VAA::deserialize(vaa.as_slice()).unwrap();
+    let payload = PayloadTransfer::deserialize(&mut vaa.payload.as_slice()).unwrap();
+    let message_key = bridge::accounts::PostedVAA::<'_, { AccountState::Uninitialized }>::key(
+        &PostedVAADerivationData {
+            payload_hash: hash_vaa(&vaa.clone().into()).to_vec(),
+        },
+        &bridge_id,
+    );
+    let post_vaa_data = PostVAAData {
+        version: vaa.version,
+        guardian_set_index: vaa.guardian_set_index,
+        timestamp: vaa.timestamp,
+        nonce: vaa.nonce,
+        emitter_chain: vaa.emitter_chain,
+        emitter_address: vaa.emitter_address,
+        sequence: vaa.sequence,
+        consistency_level: vaa.consistency_level,
+        payload: vaa.payload,
+    };
+
+    let ix = complete_native(
+        program_id,
+        bridge_id,
+        payer,
+        message_key,
+        post_vaa_data,
+        to_authority,
+        Pubkey::new(&payload.token_address),
+        CompleteNativeData {},
+    )
+    .unwrap();
+
+    JsValue::from_serde(&ix).unwrap()
+}
+
+#[wasm_bindgen]
+pub fn complete_transfer_wrapped_ix(
+    program_id: String,
+    bridge_id: String,
+    payer: String,
+    to_authority: String,
+    vaa: Vec<u8>,
+) -> JsValue {
+    let program_id = Pubkey::from_str(program_id.as_str()).unwrap();
+    let bridge_id = Pubkey::from_str(bridge_id.as_str()).unwrap();
+    let payer = Pubkey::from_str(payer.as_str()).unwrap();
+    let to_authority = Pubkey::from_str(to_authority.as_str()).unwrap();
+    let vaa = VAA::deserialize(vaa.as_slice()).unwrap();
+    let payload = PayloadTransfer::deserialize(&mut vaa.payload.as_slice()).unwrap();
+    let message_key = bridge::accounts::PostedVAA::<'_, { AccountState::Uninitialized }>::key(
+        &PostedVAADerivationData {
+            payload_hash: hash_vaa(&vaa.clone().into()).to_vec(),
+        },
+        &bridge_id,
+    );
+    let post_vaa_data = PostVAAData {
+        version: vaa.version,
+        guardian_set_index: vaa.guardian_set_index,
+        timestamp: vaa.timestamp,
+        nonce: vaa.nonce,
+        emitter_chain: vaa.emitter_chain,
+        emitter_address: vaa.emitter_address,
+        sequence: vaa.sequence,
+        consistency_level: vaa.consistency_level,
+        payload: vaa.payload,
+    };
+
+    let ix = complete_wrapped(
+        program_id,
+        bridge_id,
+        payer,
+        message_key,
+        post_vaa_data,
+        payload.clone(),
+        to_authority,
+        CompleteWrappedData {},
+    )
+    .unwrap();
+
+    JsValue::from_serde(&ix).unwrap()
+}
+
+#[wasm_bindgen]
+pub fn upgrade_contract_ix(
+    program_id: String,
+    bridge_id: String,
+    payer: String,
+    spill: String,
+    vaa: Vec<u8>,
+) -> JsValue {
+    let program_id = Pubkey::from_str(program_id.as_str()).unwrap();
+    let bridge_id = Pubkey::from_str(bridge_id.as_str()).unwrap();
+    let spill = Pubkey::from_str(spill.as_str()).unwrap();
+    let vaa = VAA::deserialize(vaa.as_slice()).unwrap();
+    let payload = GovernancePayloadUpgrade::deserialize(&mut vaa.payload.as_slice()).unwrap();
+    let message_key = bridge::accounts::PostedVAA::<'_, { AccountState::Uninitialized }>::key(
+        &PostedVAADerivationData {
+            payload_hash: hash_vaa(&vaa.clone().into()).to_vec(),
+        },
+        &bridge_id,
+    );
+    let ix = upgrade_contract(
+        program_id,
+        Pubkey::from_str(payer.as_str()).unwrap(),
+        message_key,
+        Pubkey::new(&vaa.emitter_address),
+        payload.new_contract,
+        spill,
+        vaa.sequence,
+    );
+    return JsValue::from_serde(&ix).unwrap();
+}
+
+#[wasm_bindgen]
+pub fn register_chain_ix(
+    program_id: String,
+    bridge_id: String,
+    payer: String,
+    vaa: Vec<u8>,
+) -> JsValue {
+    let program_id = Pubkey::from_str(program_id.as_str()).unwrap();
+    let bridge_id = Pubkey::from_str(bridge_id.as_str()).unwrap();
+    let payer = Pubkey::from_str(payer.as_str()).unwrap();
+    let vaa = VAA::deserialize(vaa.as_slice()).unwrap();
+    let payload = PayloadGovernanceRegisterChain::deserialize(&mut vaa.payload.as_slice()).unwrap();
+    let message_key = bridge::accounts::PostedVAA::<'_, { AccountState::Uninitialized }>::key(
+        &PostedVAADerivationData {
+            payload_hash: hash_vaa(&vaa.clone().into()).to_vec(),
+        },
+        &bridge_id,
+    );
+    let post_vaa_data = PostVAAData {
+        version: vaa.version,
+        guardian_set_index: vaa.guardian_set_index,
+        timestamp: vaa.timestamp,
+        nonce: vaa.nonce,
+        emitter_chain: vaa.emitter_chain,
+        emitter_address: vaa.emitter_address,
+        sequence: vaa.sequence,
+        consistency_level: vaa.consistency_level,
+        payload: vaa.payload,
+    };
+    let ix = register_chain(
+        program_id,
+        bridge_id,
+        payer,
+        message_key,
+        post_vaa_data,
+        payload,
+        RegisterChainData {},
+    )
+    .unwrap();
+    return JsValue::from_serde(&ix).unwrap();
+}
+
+#[wasm_bindgen]
+pub fn emitter_address(program_id: String) -> Vec<u8> {
+    let program_id = Pubkey::from_str(program_id.as_str()).unwrap();
+    let emitter = EmitterAccount::key(None, &program_id);
+
+    emitter.to_bytes().to_vec()
+}
+
+#[wasm_bindgen]
+pub fn approval_authority_address(program_id: String) -> Vec<u8> {
+    let program_id = Pubkey::from_str(program_id.as_str()).unwrap();
+    let approval_authority = AuthoritySigner::key(None, &program_id);
+
+    approval_authority.to_bytes().to_vec()
+}
+
+#[wasm_bindgen]
+pub fn wrapped_address(
+    program_id: String,
+    token_address: Vec<u8>,
+    token_chain: u16,
+    token_id: Vec<u8>,
+) -> Vec<u8> {
+    let program_id = Pubkey::from_str(program_id.as_str()).unwrap();
+    let mut t_addr = [0u8; 32];
+    t_addr.copy_from_slice(&token_address);
+    let token_id = U256::from_little_endian(token_id.as_slice());
+
+    let wrapped_addr = WrappedMint::<'_, { AccountState::Initialized }>::key(
+        &WrappedDerivationData {
+            token_address: t_addr,
+            token_chain,
+            token_id,
+        },
+        &program_id,
+    );
+
+    wrapped_addr.to_bytes().to_vec()
+}
+
+#[wasm_bindgen]
+pub fn wrapped_meta_address(program_id: String, mint_address: Vec<u8>) -> Vec<u8> {
+    let program_id = Pubkey::from_str(program_id.as_str()).unwrap();
+    let mint_key = Pubkey::new(mint_address.as_slice());
+
+    let wrapped_meta_addr = WrappedTokenMeta::<'_, { AccountState::Initialized }>::key(
+        &WrappedMetaDerivationData { mint_key },
+        &program_id,
+    );
+
+    wrapped_meta_addr.to_bytes().to_vec()
+}
+
+#[wasm_bindgen]
+pub fn parse_wrapped_meta(data: Vec<u8>) -> JsValue {
+    JsValue::from_serde(&WrappedMeta::try_from_slice(data.as_slice()).unwrap()).unwrap()
+}
+
+#[wasm_bindgen]
+pub fn parse_endpoint_registration(data: Vec<u8>) -> JsValue {
+    JsValue::from_serde(&EndpointRegistration::try_from_slice(data.as_slice()).unwrap()).unwrap()
+}

solana/modules/nft_bridge/program/tests/common.rs

@@ -0,0 +1,767 @@
+#![allow(warnings)]
+
+use borsh::{
+    BorshDeserialize,
+    BorshSerialize,
+};
+use byteorder::{
+    BigEndian,
+    WriteBytesExt,
+};
+use hex_literal::hex;
+use secp256k1::{
+    Message as Secp256k1Message,
+    PublicKey,
+    SecretKey,
+};
+use sha3::Digest;
+use solana_client::{
+    client_error::ClientError,
+    rpc_client::RpcClient,
+    rpc_config::RpcSendTransactionConfig,
+};
+use solana_program::{
+    borsh::try_from_slice_unchecked,
+    hash,
+    instruction::{
+        AccountMeta,
+        Instruction,
+    },
+    program_pack::Pack,
+    pubkey::Pubkey,
+    system_instruction::{
+        self,
+        create_account,
+    },
+    system_program,
+    sysvar,
+};
+use solana_sdk::{
+    commitment_config::CommitmentConfig,
+    rent::Rent,
+    secp256k1_instruction::new_secp256k1_instruction,
+    signature::{
+        read_keypair_file,
+        Keypair,
+        Signature,
+        Signer,
+    },
+    transaction::Transaction,
+};
+use spl_token::state::Mint;
+use std::{
+    convert::TryInto,
+    env,
+    io::{
+        Cursor,
+        Write,
+    },
+    time::{
+        Duration,
+        SystemTime,
+    },
+};
+
+use token_bridge::{
+    accounts::*,
+    instruction,
+    instructions,
+    types::*,
+    Initialize,
+};
+
+use solitaire::{
+    processors::seeded::Seeded,
+    AccountState,
+};
+
+pub use helpers::*;
+
+/// Simple API wrapper for quickly preparing and sending transactions.
+pub fn execute(
+    client: &RpcClient,
+    payer: &Keypair,
+    signers: &[&Keypair],
+    instructions: &[Instruction],
+    commitment_level: CommitmentConfig,
+) -> Result<Signature, ClientError> {
+    let mut transaction = Transaction::new_with_payer(instructions, Some(&payer.pubkey()));
+    let recent_blockhash = client.get_recent_blockhash().unwrap().0;
+    transaction.sign(&signers.to_vec(), recent_blockhash);
+    client.send_and_confirm_transaction_with_spinner_and_config(
+        &transaction,
+        commitment_level,
+        RpcSendTransactionConfig {
+            skip_preflight: true,
+            preflight_commitment: None,
+            encoding: None,
+        },
+    )
+}
+
+mod helpers {
+    use bridge::types::{
+        ConsistencyLevel,
+        PostedVAAData,
+    };
+    use token_bridge::{
+        CompleteNativeData,
+        CompleteWrappedData,
+        CreateWrappedData,
+        RegisterChainData,
+        TransferNativeData,
+        TransferWrappedData,
+    };
+
+    use super::*;
+    use bridge::{
+        accounts::{
+            FeeCollector,
+            PostedVAADerivationData,
+        },
+        PostVAAData,
+    };
+    use std::ops::Add;
+    use token_bridge::messages::{
+        PayloadAssetMeta,
+        PayloadGovernanceRegisterChain,
+        PayloadTransfer,
+    };
+
+    /// Initialize the test environment, spins up a solana-test-validator in the background so that
+    /// each test has a fresh environment to work within.
+    pub fn setup() -> (Keypair, RpcClient, Pubkey, Pubkey) {
+        let payer = env::var("BRIDGE_PAYER").unwrap_or("./payer.json".to_string());
+        let rpc_address = env::var("BRIDGE_RPC").unwrap_or("http://127.0.0.1:8899".to_string());
+        let payer = read_keypair_file(payer).unwrap();
+        let rpc = RpcClient::new(rpc_address);
+
+        let (program, token_program) = (
+            env::var("BRIDGE_PROGRAM")
+                .unwrap_or("Bridge1p5gheXUvJ6jGWGeCsgPKgnE3YgdGKRVCMY9o".to_string())
+                .parse::<Pubkey>()
+                .unwrap(),
+            env::var("TOKEN_BRIDGE_PROGRAM")
+                .unwrap_or("B6RHG3mfcckmrYN1UhmJzyS1XX3fZKbkeUcpJe9Sy3FE".to_string())
+                .parse::<Pubkey>()
+                .unwrap(),
+        );
+
+        (payer, rpc, program, token_program)
+    }
+
+    /// Wait for a single transaction to fully finalize, guaranteeing chain state has been
+    /// confirmed. Useful for consistently fetching data during state checks.
+    pub fn sync(client: &RpcClient, payer: &Keypair) {
+        execute(
+            client,
+            payer,
+            &[payer],
+            &[system_instruction::transfer(
+                &payer.pubkey(),
+                &payer.pubkey(),
+                1,
+            )],
+            CommitmentConfig::finalized(),
+        )
+        .unwrap();
+    }
+
+    /// Fetch account data, the loop is there to re-attempt until data is available.
+    pub fn get_account_data<T: BorshDeserialize>(
+        client: &RpcClient,
+        account: &Pubkey,
+    ) -> Option<T> {
+        let account = client
+            .get_account_with_commitment(account, CommitmentConfig::processed())
+            .unwrap();
+        T::try_from_slice(&account.value.unwrap().data).ok()
+    }
+
+    pub fn initialize_bridge(
+        client: &RpcClient,
+        program: &Pubkey,
+        payer: &Keypair,
+    ) -> Result<Signature, ClientError> {
+        let initial_guardians = &[[1u8; 20]];
+        execute(
+            client,
+            payer,
+            &[payer],
+            &[bridge::instructions::initialize(
+                *program,
+                payer.pubkey(),
+                50,
+                2_000_000_000,
+                initial_guardians,
+            )
+            .unwrap()],
+            CommitmentConfig::processed(),
+        )
+    }
+
+    pub fn transfer(
+        client: &RpcClient,
+        from: &Keypair,
+        to: &Pubkey,
+        lamports: u64,
+    ) -> Result<Signature, ClientError> {
+        execute(
+            client,
+            from,
+            &[from],
+            &[system_instruction::transfer(&from.pubkey(), to, lamports)],
+            CommitmentConfig::processed(),
+        )
+    }
+
+    pub fn initialize(
+        client: &RpcClient,
+        program: &Pubkey,
+        payer: &Keypair,
+        bridge: &Pubkey,
+    ) -> Result<Signature, ClientError> {
+        let instruction = instructions::initialize(*program, payer.pubkey(), *bridge)
+            .expect("Could not create Initialize instruction");
+
+        for account in instruction.accounts.iter().enumerate() {
+            println!("{}: {}", account.0, account.1.pubkey);
+        }
+
+        execute(
+            client,
+            payer,
+            &[payer],
+            &[instruction],
+            CommitmentConfig::processed(),
+        )
+    }
+
+    pub fn attest(
+        client: &RpcClient,
+        program: &Pubkey,
+        bridge: &Pubkey,
+        payer: &Keypair,
+        message: &Keypair,
+        mint: Pubkey,
+        nonce: u32,
+    ) -> Result<Signature, ClientError> {
+        let mint_data = Mint::unpack(
+            &client
+                .get_account_with_commitment(&mint, CommitmentConfig::processed())?
+                .value
+                .unwrap()
+                .data,
+        )
+        .expect("Could not unpack Mint");
+
+        let instruction = instructions::attest(
+            *program,
+            *bridge,
+            payer.pubkey(),
+            message.pubkey(),
+            mint,
+            nonce,
+        )
+        .expect("Could not create Attest instruction");
+
+        for account in instruction.accounts.iter().enumerate() {
+            println!("{}: {}", account.0, account.1.pubkey);
+        }
+
+        execute(
+            client,
+            payer,
+            &[payer, message],
+            &[instruction],
+            CommitmentConfig::processed(),
+        )
+    }
+
+    pub fn transfer_native(
+        client: &RpcClient,
+        program: &Pubkey,
+        bridge: &Pubkey,
+        payer: &Keypair,
+        message: &Keypair,
+        from: &Keypair,
+        from_owner: &Keypair,
+        mint: Pubkey,
+        amount: u64,
+    ) -> Result<Signature, ClientError> {
+        let instruction = instructions::transfer_native(
+            *program,
+            *bridge,
+            payer.pubkey(),
+            message.pubkey(),
+            from.pubkey(),
+            mint,
+            TransferNativeData {
+                nonce: 0,
+                amount,
+                fee: 0,
+                target_address: [0u8; 32],
+                target_chain: 2,
+            },
+        )
+        .expect("Could not create Transfer Native");
+
+        for account in instruction.accounts.iter().enumerate() {
+            println!("{}: {}", account.0, account.1.pubkey);
+        }
+
+        execute(
+            client,
+            payer,
+            &[payer, from_owner, message],
+            &[
+                spl_token::instruction::approve(
+                    &spl_token::id(),
+                    &from.pubkey(),
+                    &token_bridge::accounts::AuthoritySigner::key(None, program),
+                    &from_owner.pubkey(),
+                    &[],
+                    amount,
+                )
+                .unwrap(),
+                instruction,
+            ],
+            CommitmentConfig::processed(),
+        )
+    }
+
+    pub fn transfer_wrapped(
+        client: &RpcClient,
+        program: &Pubkey,
+        bridge: &Pubkey,
+        payer: &Keypair,
+        message: &Keypair,
+        from: Pubkey,
+        from_owner: &Keypair,
+        token_chain: u16,
+        token_address: Address,
+        amount: u64,
+    ) -> Result<Signature, ClientError> {
+        let instruction = instructions::transfer_wrapped(
+            *program,
+            *bridge,
+            payer.pubkey(),
+            message.pubkey(),
+            from,
+            from_owner.pubkey(),
+            token_chain,
+            token_address,
+            TransferWrappedData {
+                nonce: 0,
+                amount,
+                fee: 0,
+                target_address: [5u8; 32],
+                target_chain: 2,
+            },
+        )
+        .expect("Could not create Transfer Native");
+
+        for account in instruction.accounts.iter().enumerate() {
+            println!("{}: {}", account.0, account.1.pubkey);
+        }
+
+        execute(
+            client,
+            payer,
+            &[payer, from_owner, message],
+            &[
+                spl_token::instruction::approve(
+                    &spl_token::id(),
+                    &from,
+                    &token_bridge::accounts::AuthoritySigner::key(None, program),
+                    &from_owner.pubkey(),
+                    &[],
+                    amount,
+                )
+                .unwrap(),
+                instruction,
+            ],
+            CommitmentConfig::processed(),
+        )
+    }
+
+    pub fn register_chain(
+        client: &RpcClient,
+        program: &Pubkey,
+        bridge: &Pubkey,
+        message_acc: &Pubkey,
+        vaa: PostVAAData,
+        payload: PayloadGovernanceRegisterChain,
+        payer: &Keypair,
+    ) -> Result<Signature, ClientError> {
+        let instruction = instructions::register_chain(
+            *program,
+            *bridge,
+            payer.pubkey(),
+            *message_acc,
+            vaa,
+            payload,
+            RegisterChainData {},
+        )
+        .expect("Could not create Transfer Native");
+
+        for account in instruction.accounts.iter().enumerate() {
+            println!("{}: {}", account.0, account.1.pubkey);
+        }
+
+        execute(
+            client,
+            payer,
+            &[payer],
+            &[instruction],
+            CommitmentConfig::processed(),
+        )
+    }
+
+    pub fn complete_native(
+        client: &RpcClient,
+        program: &Pubkey,
+        bridge: &Pubkey,
+        message_acc: &Pubkey,
+        vaa: PostVAAData,
+        payload: PayloadTransfer,
+        payer: &Keypair,
+    ) -> Result<Signature, ClientError> {
+        let instruction = instructions::complete_native(
+            *program,
+            *bridge,
+            payer.pubkey(),
+            *message_acc,
+            vaa,
+            Pubkey::new(&payload.to[..]),
+            None,
+            Pubkey::new(&payload.token_address[..]),
+            CompleteNativeData {},
+        )
+        .expect("Could not create Complete Native instruction");
+
+        for account in instruction.accounts.iter().enumerate() {
+            println!("{}: {}", account.0, account.1.pubkey);
+        }
+
+        execute(
+            client,
+            payer,
+            &[payer],
+            &[instruction],
+            CommitmentConfig::processed(),
+        )
+    }
+
+    pub fn complete_transfer_wrapped(
+        client: &RpcClient,
+        program: &Pubkey,
+        bridge: &Pubkey,
+        message_acc: &Pubkey,
+        vaa: PostVAAData,
+        payload: PayloadTransfer,
+        payer: &Keypair,
+    ) -> Result<Signature, ClientError> {
+        let to = Pubkey::new(&payload.to[..]);
+
+        let instruction = instructions::complete_wrapped(
+            *program,
+            *bridge,
+            payer.pubkey(),
+            *message_acc,
+            vaa,
+            payload,
+            to,
+            None,
+            CompleteWrappedData {},
+        )
+        .expect("Could not create Complete Wrapped instruction");
+
+        for account in instruction.accounts.iter().enumerate() {
+            println!("{}: {}", account.0, account.1.pubkey);
+        }
+
+        execute(
+            client,
+            payer,
+            &[payer],
+            &[instruction],
+            CommitmentConfig::processed(),
+        )
+    }
+
+    pub fn create_wrapped(
+        client: &RpcClient,
+        program: &Pubkey,
+        bridge: &Pubkey,
+        message_acc: &Pubkey,
+        vaa: PostVAAData,
+        payload: PayloadAssetMeta,
+        payer: &Keypair,
+    ) -> Result<Signature, ClientError> {
+        let instruction = instructions::create_wrapped(
+            *program,
+            *bridge,
+            payer.pubkey(),
+            *message_acc,
+            vaa,
+            payload,
+            CreateWrappedData {},
+        )
+        .expect("Could not create Create Wrapped instruction");
+
+        for account in instruction.accounts.iter().enumerate() {
+            println!("{}: {}", account.0, account.1.pubkey);
+        }
+
+        execute(
+            client,
+            payer,
+            &[payer],
+            &[instruction],
+            CommitmentConfig::processed(),
+        )
+    }
+
+    pub fn create_mint(
+        client: &RpcClient,
+        payer: &Keypair,
+        mint_authority: &Pubkey,
+        mint: &Keypair,
+    ) -> Result<Signature, ClientError> {
+        execute(
+            client,
+            payer,
+            &[payer, mint],
+            &[
+                solana_sdk::system_instruction::create_account(
+                    &payer.pubkey(),
+                    &mint.pubkey(),
+                    Rent::default().minimum_balance(spl_token::state::Mint::LEN),
+                    spl_token::state::Mint::LEN as u64,
+                    &spl_token::id(),
+                ),
+                spl_token::instruction::initialize_mint(
+                    &spl_token::id(),
+                    &mint.pubkey(),
+                    mint_authority,
+                    None,
+                    0,
+                )
+                .unwrap(),
+            ],
+            CommitmentConfig::processed(),
+        )
+    }
+
+    pub fn create_spl_metadata(
+        client: &RpcClient,
+        payer: &Keypair,
+        metadata_account: &Pubkey,
+        mint_authority: &Keypair,
+        mint: &Keypair,
+        update_authority: &Pubkey,
+        name: String,
+        symbol: String,
+    ) -> Result<Signature, ClientError> {
+        execute(
+            client,
+            payer,
+            &[payer, mint_authority],
+            &[spl_token_metadata::instruction::create_metadata_accounts(
+                spl_token_metadata::id(),
+                *metadata_account,
+                mint.pubkey(),
+                mint_authority.pubkey(),
+                payer.pubkey(),
+                *update_authority,
+                name,
+                symbol,
+                "https://token.org".to_string(),
+                None,
+                0,
+                false,
+                false,
+            )],
+            CommitmentConfig::processed(),
+        )
+    }
+
+    pub fn create_token_account(
+        client: &RpcClient,
+        payer: &Keypair,
+        token_acc: &Keypair,
+        token_authority: Pubkey,
+        mint: Pubkey,
+    ) -> Result<Signature, ClientError> {
+        execute(
+            client,
+            payer,
+            &[payer, token_acc],
+            &[
+                solana_sdk::system_instruction::create_account(
+                    &payer.pubkey(),
+                    &token_acc.pubkey(),
+                    Rent::default().minimum_balance(spl_token::state::Account::LEN),
+                    spl_token::state::Account::LEN as u64,
+                    &spl_token::id(),
+                ),
+                spl_token::instruction::initialize_account(
+                    &spl_token::id(),
+                    &token_acc.pubkey(),
+                    &mint,
+                    &token_authority,
+                )
+                .unwrap(),
+            ],
+            CommitmentConfig::processed(),
+        )
+    }
+
+    pub fn mint_tokens(
+        client: &RpcClient,
+        payer: &Keypair,
+        mint_authority: &Keypair,
+        mint: &Keypair,
+        token_account: &Pubkey,
+        amount: u64,
+    ) -> Result<Signature, ClientError> {
+        execute(
+            client,
+            payer,
+            &[payer, &mint_authority],
+            &[spl_token::instruction::mint_to(
+                &spl_token::id(),
+                &mint.pubkey(),
+                token_account,
+                &mint_authority.pubkey(),
+                &[],
+                amount,
+            )
+            .unwrap()],
+            CommitmentConfig::processed(),
+        )
+    }
+
+    /// Utility function for generating VAA's from message data.
+    pub fn generate_vaa(
+        emitter: Address,
+        emitter_chain: u16,
+        data: Vec<u8>,
+        nonce: u32,
+        sequence: u64,
+    ) -> (PostVAAData, [u8; 32], [u8; 32]) {
+        let mut vaa = PostVAAData {
+            version: 0,
+            guardian_set_index: 0,
+
+            // Body part
+            emitter_chain,
+            emitter_address: emitter,
+            sequence,
+            payload: data,
+            timestamp: SystemTime::now()
+                .duration_since(SystemTime::UNIX_EPOCH)
+                .unwrap()
+                .as_secs() as u32,
+            nonce,
+            consistency_level: ConsistencyLevel::Confirmed as u8,
+        };
+
+        // Hash data, the thing we wish to actually sign.
+        let body = {
+            let mut v = Cursor::new(Vec::new());
+            v.write_u32::<BigEndian>(vaa.timestamp).unwrap();
+            v.write_u32::<BigEndian>(vaa.nonce).unwrap();
+            v.write_u16::<BigEndian>(vaa.emitter_chain).unwrap();
+            v.write(&vaa.emitter_address).unwrap();
+            v.write_u64::<BigEndian>(vaa.sequence).unwrap();
+            v.write_u8(vaa.consistency_level).unwrap();
+            v.write(&vaa.payload).unwrap();
+            v.into_inner()
+        };
+
+        // Hash this body, which is expected to be the same as the hash currently stored in the
+        // signature account, binding that set of signatures to this VAA.
+        let body: [u8; 32] = {
+            let mut h = sha3::Keccak256::default();
+            h.write(body.as_slice()).unwrap();
+            h.finalize().into()
+        };
+
+        let body_hash: [u8; 32] = {
+            let mut h = sha3::Keccak256::default();
+            h.write(&body).unwrap();
+            h.finalize().into()
+        };
+
+        (vaa, body, body_hash)
+    }
+
+    pub fn post_vaa(
+        client: &RpcClient,
+        program: &Pubkey,
+        payer: &Keypair,
+        vaa: PostVAAData,
+    ) -> Result<(), ClientError> {
+        let instruction =
+            bridge::instructions::post_vaa(*program, payer.pubkey(), Pubkey::new_unique(), vaa);
+
+        for account in instruction.accounts.iter().enumerate() {
+            println!("{}: {}", account.0, account.1.pubkey);
+        }
+
+        execute(
+            client,
+            payer,
+            &[payer],
+            &[instruction],
+            CommitmentConfig::processed(),
+        )?;
+
+        Ok(())
+    }
+
+    pub fn post_message(
+        client: &RpcClient,
+        program: &Pubkey,
+        payer: &Keypair,
+        emitter: &Keypair,
+        message: &Keypair,
+        nonce: u32,
+        data: Vec<u8>,
+        fee: u64,
+    ) -> Result<(), ClientError> {
+        // Transfer money into the fee collector as it needs a balance/must exist.
+        let fee_collector = FeeCollector::<'_>::key(None, program);
+
+        // Capture the resulting message, later functions will need this.
+        let instruction = bridge::instructions::post_message(
+            *program,
+            payer.pubkey(),
+            emitter.pubkey(),
+            message.pubkey(),
+            nonce,
+            data,
+            ConsistencyLevel::Confirmed,
+        )
+        .unwrap();
+
+        for account in instruction.accounts.iter().enumerate() {
+            println!("{}: {}", account.0, account.1.pubkey);
+        }
+
+        execute(
+            client,
+            payer,
+            &[payer, emitter, message],
+            &[
+                system_instruction::transfer(&payer.pubkey(), &fee_collector, fee),
+                instruction,
+            ],
+            CommitmentConfig::processed(),
+        )?;
+
+        Ok(())
+    }
+}

solana/modules/nft_bridge/program/tests/integration.rs

@@ -0,0 +1,631 @@
+#![allow(warnings)]
+
+use borsh::BorshSerialize;
+use byteorder::{
+    BigEndian,
+    WriteBytesExt,
+};
+use hex_literal::hex;
+use rand::Rng;
+use secp256k1::{
+    Message as Secp256k1Message,
+    PublicKey,
+    SecretKey,
+};
+use sha3::Digest;
+use solana_client::rpc_client::RpcClient;
+use solana_program::{
+    borsh::try_from_slice_unchecked,
+    hash,
+    instruction::{
+        AccountMeta,
+        Instruction,
+    },
+    program_pack::Pack,
+    pubkey::Pubkey,
+    system_instruction::{
+        self,
+        create_account,
+    },
+    system_program,
+    sysvar,
+};
+use solana_sdk::{
+    commitment_config::CommitmentConfig,
+    signature::{
+        read_keypair_file,
+        Keypair,
+        Signer,
+    },
+    transaction::Transaction,
+};
+use solitaire::{
+    processors::seeded::Seeded,
+    AccountState,
+};
+use spl_token::state::Mint;
+use std::{
+    convert::TryInto,
+    io::{
+        Cursor,
+        Write,
+    },
+    time::{
+        Duration,
+        SystemTime,
+    },
+};
+
+use bridge::{
+    accounts::{
+        Bridge,
+        FeeCollector,
+        GuardianSet,
+        GuardianSetDerivationData,
+        PostedVAA,
+        PostedVAADerivationData,
+        SignatureSet,
+    },
+    instruction,
+    types::{
+        BridgeConfig,
+        BridgeData,
+        GovernancePayloadGuardianSetChange,
+        GovernancePayloadSetMessageFee,
+        GovernancePayloadTransferFees,
+        GuardianSetData,
+        MessageData,
+        PostedVAAData,
+        SequenceTracker,
+        SignatureSet as SignatureSetData,
+    },
+    Initialize,
+    PostVAA,
+    PostVAAData,
+    SerializePayload,
+    Signature,
+};
+use primitive_types::U256;
+use std::{
+    collections::HashMap,
+    str::FromStr,
+    time::UNIX_EPOCH,
+};
+use token_bridge::{
+    accounts::{
+        EmitterAccount,
+        WrappedDerivationData,
+        WrappedMint,
+    },
+    messages::{
+        PayloadAssetMeta,
+        PayloadGovernanceRegisterChain,
+        PayloadTransfer,
+    },
+    types::Address,
+};
+
+mod common;
+
+const GOVERNANCE_KEY: [u8; 64] = [
+    240, 133, 120, 113, 30, 67, 38, 184, 197, 72, 234, 99, 241, 21, 58, 225, 41, 157, 171, 44, 196,
+    163, 134, 236, 92, 148, 110, 68, 127, 114, 177, 0, 173, 253, 199, 9, 242, 142, 201, 174, 108,
+    197, 18, 102, 115, 0, 31, 205, 127, 188, 191, 56, 171, 228, 20, 247, 149, 170, 141, 231, 147,
+    88, 97, 199,
+];
+
+struct Context {
+    /// Address of the core bridge contract.
+    bridge: Pubkey,
+
+    /// Shared RPC client for tests to make transactions with.
+    client: RpcClient,
+
+    /// Payer key with a ton of lamports to ease testing with.
+    payer: Keypair,
+
+    /// Track nonces throughout the tests.
+    seq: Sequencer,
+
+    /// Address of the token bridge itself that we wish to test.
+    token_bridge: Pubkey,
+
+    /// Keypairs for mint information, required in multiple tests.
+    mint_authority: Keypair,
+    mint: Keypair,
+    mint_meta: Pubkey,
+
+    /// Keypairs for test token accounts.
+    token_authority: Keypair,
+    token_account: Keypair,
+    metadata_account: Pubkey,
+}
+
+/// Small helper to track and provide sequences during tests. This is in particular needed for
+/// guardian operations that require them for derivations.
+struct Sequencer {
+    sequences: HashMap<[u8; 32], u64>,
+}
+
+impl Sequencer {
+    fn next(&mut self, emitter: [u8; 32]) -> u64 {
+        let entry = self.sequences.entry(emitter).or_insert(0);
+        *entry += 1;
+        *entry - 1
+    }
+
+    fn peek(&mut self, emitter: [u8; 32]) -> u64 {
+        *self.sequences.entry(emitter).or_insert(0)
+    }
+}
+
+#[test]
+fn run_integration_tests() {
+    let (payer, client, bridge, token_bridge) = common::setup();
+
+    // Setup a Bridge to test against.
+    println!("Bridge: {}", bridge);
+    common::initialize_bridge(&client, &bridge, &payer);
+
+    // Context for test environment.
+    let mint = Keypair::new();
+    let mint_pubkey = mint.pubkey();
+    let metadata_pubkey = Pubkey::from_str("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s").unwrap();
+
+    // SPL Token Meta
+    let metadata_seeds = &[
+        "metadata".as_bytes(),
+        metadata_pubkey.as_ref(),
+        mint_pubkey.as_ref(),
+    ];
+
+    let (metadata_key, metadata_bump_seed) = Pubkey::find_program_address(
+        metadata_seeds,
+        &Pubkey::from_str("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s").unwrap(),
+    );
+
+    // Token Bridge Meta
+    use token_bridge::accounts::WrappedTokenMeta;
+    let metadata_account = WrappedTokenMeta::<'_, { AccountState::Uninitialized }>::key(
+        &token_bridge::accounts::WrappedMetaDerivationData {
+            mint_key: mint_pubkey.clone(),
+        },
+        &token_bridge,
+    );
+
+    let mut context = Context {
+        seq: Sequencer {
+            sequences: HashMap::new(),
+        },
+        bridge,
+        client,
+        payer,
+        token_bridge,
+        mint_authority: Keypair::new(),
+        mint,
+        mint_meta: metadata_account,
+        token_account: Keypair::new(),
+        token_authority: Keypair::new(),
+        metadata_account: metadata_key,
+    };
+
+    // Create a mint for use within tests.
+    common::create_mint(
+        &context.client,
+        &context.payer,
+        &context.mint_authority.pubkey(),
+        &context.mint,
+    )
+    .unwrap();
+
+    // Create Token accounts for use within tests.
+    common::create_token_account(
+        &context.client,
+        &context.payer,
+        &context.token_account,
+        context.token_authority.pubkey(),
+        context.mint.pubkey(),
+    )
+    .unwrap();
+
+    // Mint tokens
+    common::mint_tokens(
+        &context.client,
+        &context.payer,
+        &context.mint_authority,
+        &context.mint,
+        &context.token_account.pubkey(),
+        1000,
+    )
+    .unwrap();
+
+    // Initialize the bridge and verify the bridges state.
+    test_initialize(&mut context);
+    test_transfer_native(&mut context);
+    test_attest(&mut context);
+    test_register_chain(&mut context);
+    test_transfer_native_in(&mut context);
+
+    // Create an SPL Metadata account to test attestations for wrapped tokens.
+    common::create_spl_metadata(
+        &context.client,
+        &context.payer,
+        &context.metadata_account,
+        &context.mint_authority,
+        &context.mint,
+        &context.payer.pubkey(),
+        "BTC".to_string(),
+        "Bitcoin".to_string(),
+    )
+    .unwrap();
+
+    let wrapped = test_create_wrapped(&mut context);
+    let wrapped_acc = Keypair::new();
+    common::create_token_account(
+        &context.client,
+        &context.payer,
+        &wrapped_acc,
+        context.token_authority.pubkey(),
+        wrapped,
+    )
+    .unwrap();
+    test_transfer_wrapped_in(&mut context, wrapped_acc.pubkey());
+    test_transfer_wrapped(&mut context, wrapped_acc.pubkey());
+}
+
+fn test_attest(context: &mut Context) -> () {
+    println!("Attest");
+    use token_bridge::{
+        accounts::ConfigAccount,
+        types::Config,
+    };
+
+    let Context {
+        ref payer,
+        ref client,
+        ref bridge,
+        ref token_bridge,
+        ref mint_authority,
+        ref mint,
+        ref mint_meta,
+        ref metadata_account,
+        ..
+    } = context;
+
+    let message = &Keypair::new();
+
+    common::attest(
+        client,
+        token_bridge,
+        bridge,
+        payer,
+        message,
+        mint.pubkey(),
+        0,
+    )
+    .unwrap();
+
+    let emitter_key = EmitterAccount::key(None, &token_bridge);
+    let mint_data = Mint::unpack(
+        &client
+            .get_account_with_commitment(&mint.pubkey(), CommitmentConfig::processed())
+            .unwrap()
+            .value
+            .unwrap()
+            .data,
+    )
+    .unwrap();
+    let payload = PayloadAssetMeta {
+        token_address: mint.pubkey().to_bytes(),
+        token_chain: 1,
+        decimals: mint_data.decimals,
+        symbol: "USD".to_string(),
+        name: "Bitcoin".to_string(),
+    };
+    let payload = payload.try_to_vec().unwrap();
+}
+
+fn test_transfer_native(context: &mut Context) -> () {
+    println!("Transfer Native");
+    use token_bridge::{
+        accounts::ConfigAccount,
+        types::Config,
+    };
+
+    let Context {
+        ref payer,
+        ref client,
+        ref bridge,
+        ref token_bridge,
+        ref mint_authority,
+        ref mint,
+        ref mint_meta,
+        ref token_account,
+        ref token_authority,
+        ..
+    } = context;
+
+    let message = &Keypair::new();
+
+    common::transfer_native(
+        client,
+        token_bridge,
+        bridge,
+        payer,
+        message,
+        token_account,
+        token_authority,
+        mint.pubkey(),
+        100,
+    )
+    .unwrap();
+}
+
+fn test_transfer_wrapped(context: &mut Context, token_account: Pubkey) -> () {
+    println!("TransferWrapped");
+    use token_bridge::{
+        accounts::ConfigAccount,
+        types::Config,
+    };
+
+    let Context {
+        ref payer,
+        ref client,
+        ref bridge,
+        ref token_bridge,
+        ref mint_authority,
+        ref token_authority,
+        ..
+    } = context;
+
+    let message = &Keypair::new();
+
+    common::transfer_wrapped(
+        client,
+        token_bridge,
+        bridge,
+        payer,
+        message,
+        token_account,
+        token_authority,
+        2,
+        [1u8; 32],
+        10000000,
+    )
+    .unwrap();
+}
+
+fn test_register_chain(context: &mut Context) -> () {
+    println!("Register Chain");
+    use token_bridge::{
+        accounts::ConfigAccount,
+        types::Config,
+    };
+
+    let Context {
+        ref payer,
+        ref client,
+        ref bridge,
+        ref token_bridge,
+        ref mint_authority,
+        ref mint,
+        ref mint_meta,
+        ref token_account,
+        ref token_authority,
+        ..
+    } = context;
+
+    let nonce = rand::thread_rng().gen();
+    let emitter = Keypair::from_bytes(&GOVERNANCE_KEY).unwrap();
+    let payload = PayloadGovernanceRegisterChain {
+        chain: 2,
+        endpoint_address: [0u8; 32],
+    };
+    let message = payload.try_to_vec().unwrap();
+
+    let (vaa, _, _) = common::generate_vaa(emitter.pubkey().to_bytes(), 1, message, nonce, 0);
+    common::post_vaa(client, bridge, payer, vaa.clone()).unwrap();
+
+    let mut msg_derivation_data = &PostedVAADerivationData {
+        payload_hash: bridge::instructions::hash_vaa(&vaa).to_vec(),
+    };
+    let message_key =
+        PostedVAA::<'_, { AccountState::MaybeInitialized }>::key(&msg_derivation_data, &bridge);
+
+    common::register_chain(
+        client,
+        token_bridge,
+        bridge,
+        &message_key,
+        vaa,
+        payload,
+        payer,
+    )
+    .unwrap();
+}
+
+fn test_transfer_native_in(context: &mut Context) -> () {
+    println!("TransferNativeIn");
+    use token_bridge::{
+        accounts::ConfigAccount,
+        types::Config,
+    };
+
+    let Context {
+        ref payer,
+        ref client,
+        ref bridge,
+        ref token_bridge,
+        ref mint_authority,
+        ref mint,
+        ref mint_meta,
+        ref token_account,
+        ref token_authority,
+        ..
+    } = context;
+
+    let nonce = rand::thread_rng().gen();
+
+    let payload = PayloadTransfer {
+        amount: U256::from(100),
+        token_address: mint.pubkey().to_bytes(),
+        token_chain: 1,
+        to: token_account.pubkey().to_bytes(),
+        to_chain: 1,
+        fee: U256::from(0),
+    };
+    let message = payload.try_to_vec().unwrap();
+
+    let (vaa, _, _) = common::generate_vaa([0u8; 32], 2, message, nonce, 1);
+    common::post_vaa(client, bridge, payer, vaa.clone()).unwrap();
+    let mut msg_derivation_data = &PostedVAADerivationData {
+        payload_hash: bridge::instructions::hash_vaa(&vaa).to_vec(),
+    };
+    let message_key =
+        PostedVAA::<'_, { AccountState::MaybeInitialized }>::key(&msg_derivation_data, &bridge);
+
+    common::complete_native(
+        client,
+        token_bridge,
+        bridge,
+        &message_key,
+        vaa,
+        payload,
+        payer,
+    )
+    .unwrap();
+}
+
+fn test_transfer_wrapped_in(context: &mut Context, to: Pubkey) -> () {
+    println!("TransferWrappedIn");
+    use token_bridge::{
+        accounts::ConfigAccount,
+        types::Config,
+    };
+
+    let Context {
+        ref payer,
+        ref client,
+        ref bridge,
+        ref token_bridge,
+        ref mint_authority,
+        ref mint,
+        ref mint_meta,
+        ref token_account,
+        ref token_authority,
+        ..
+    } = context;
+
+    let nonce = rand::thread_rng().gen();
+
+    let payload = PayloadTransfer {
+        amount: U256::from(100000000),
+        token_address: [1u8; 32],
+        token_chain: 2,
+        to: to.to_bytes(),
+        to_chain: 1,
+        fee: U256::from(0),
+    };
+    let message = payload.try_to_vec().unwrap();
+
+    let (vaa, _, _) = common::generate_vaa([0u8; 32], 2, message, nonce, rand::thread_rng().gen());
+    common::post_vaa(client, bridge, payer, vaa.clone()).unwrap();
+    let mut msg_derivation_data = &PostedVAADerivationData {
+        payload_hash: bridge::instructions::hash_vaa(&vaa).to_vec(),
+    };
+    let message_key =
+        PostedVAA::<'_, { AccountState::MaybeInitialized }>::key(&msg_derivation_data, &bridge);
+
+    common::complete_transfer_wrapped(
+        client,
+        token_bridge,
+        bridge,
+        &message_key,
+        vaa,
+        payload,
+        payer,
+    )
+    .unwrap();
+}
+
+fn test_create_wrapped(context: &mut Context) -> (Pubkey) {
+    println!("CreateWrapped");
+    use token_bridge::{
+        accounts::ConfigAccount,
+        types::Config,
+    };
+
+    let Context {
+        ref payer,
+        ref client,
+        ref bridge,
+        ref token_bridge,
+        ref mint_authority,
+        ref mint,
+        ref mint_meta,
+        ref token_account,
+        ref token_authority,
+        ..
+    } = context;
+
+    let nonce = rand::thread_rng().gen();
+
+    let payload = PayloadAssetMeta {
+        token_address: [1u8; 32],
+        token_chain: 2,
+        decimals: 7,
+        symbol: "".to_string(),
+        name: "".to_string(),
+    };
+    let message = payload.try_to_vec().unwrap();
+
+    let (vaa, _, _) = common::generate_vaa([0u8; 32], 2, message, nonce, 2);
+    common::post_vaa(client, bridge, payer, vaa.clone()).unwrap();
+    let mut msg_derivation_data = &PostedVAADerivationData {
+        payload_hash: bridge::instructions::hash_vaa(&vaa).to_vec(),
+    };
+    let message_key =
+        PostedVAA::<'_, { AccountState::MaybeInitialized }>::key(&msg_derivation_data, &bridge);
+
+    common::create_wrapped(
+        client,
+        token_bridge,
+        bridge,
+        &message_key,
+        vaa,
+        payload,
+        payer,
+    )
+    .unwrap();
+
+    return WrappedMint::<'_, { AccountState::Initialized }>::key(
+        &WrappedDerivationData {
+            token_chain: 2,
+            token_address: [1u8; 32],
+        },
+        token_bridge,
+    );
+}
+
+fn test_initialize(context: &mut Context) {
+    println!("Initialize");
+    use token_bridge::{
+        accounts::ConfigAccount,
+        types::Config,
+    };
+
+    let Context {
+        ref payer,
+        ref client,
+        ref bridge,
+        ref token_bridge,
+        ..
+    } = context;
+
+    common::initialize(client, token_bridge, payer, &bridge).unwrap();
+
+    // Verify Token Bridge State
+    let config_key = ConfigAccount::<'_, { AccountState::Uninitialized }>::key(None, &token_bridge);
+    let config: Config = common::get_account_data(client, &config_key).unwrap();
+    assert_eq!(config.wormhole_bridge, *bridge);
+}

solana/modules/token_bridge/client/src/main.rs

@@ -94,6 +94,7 @@ fn command_create_meta(
     mint: &Pubkey,
     name: String,
     symbol: String,
+    uri: String,
 ) -> CommmandResult {
     println!("Creating meta for mint {}", mint);
 
@@ -116,7 +117,7 @@ fn command_create_meta(
         config.owner.pubkey(),
         name,
         symbol,
-        String::from(""),
+        uri,
         None,
         0,
         false,
@@ -247,6 +248,15 @@ fn main() {
                         .index(3)
                         .required(true)
                         .help("Symbol of the token"),
+                )
+                .arg(
+                    Arg::with_name("uri")
+                        .long("uri")
+                        .value_name("URI")
+                        .takes_value(true)
+                        .index(4)
+                        .required(true)
+                        .help("URI of the token metadata"),
                 ),
         )
         .get_matches();
@@ -289,8 +299,9 @@ fn main() {
             let mint = pubkey_of(arg_matches, "mint").unwrap();
             let name: String = value_of(arg_matches, "name").unwrap();
             let symbol: String = value_of(arg_matches, "symbol").unwrap();
+            let uri: String = value_of(arg_matches, "uri").unwrap();
 
-            command_create_meta(&config, &mint, name, symbol)
+            command_create_meta(&config, &mint, name, symbol, uri)
         }
         ("emitter", Some(arg_matches)) => {
             let bridge = pubkey_of(arg_matches, "bridge").unwrap();