add nft bridge skeleton
Change-Id: I69449e95415cd94b7de4528fe4002b241e1e6b95
This commit is contained in:
parent
8d15138d57
commit
a2b3d111f4
|
@ -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` |
|
||||
|
|
|
@ -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).
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -0,0 +1,5 @@
|
|||
[workspace]
|
||||
members = ["program"]
|
||||
|
||||
[patch.crates-io]
|
||||
memmap2 = { path = "../../bridge/memmap2-rs" }
|
|
@ -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" }
|
|
@ -0,0 +1,2 @@
|
|||
[target.bpfel-unknown-unknown.dependencies.std]
|
||||
features = []
|
|
@ -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(),
|
||||
]
|
||||
}
|
||||
}
|
|
@ -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::*;
|
|
@ -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(())
|
||||
}
|
|
@ -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(())
|
||||
}
|
|
@ -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(())
|
||||
}
|
|
@ -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(())
|
||||
}
|
|
@ -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(),
|
||||
}
|
||||
}
|
|
@ -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,
|
||||
}
|
|
@ -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);
|
||||
}
|
||||
}
|
|
@ -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()));
|
|
@ -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()
|
||||
}
|
|
@ -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(())
|
||||
}
|
||||
}
|
|
@ -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);
|
||||
}
|
|
@ -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();
|
||||
|
|
Loading…
Reference in New Issue