certusone
/
wormhole
mirror of https://github.com/certusone/wormhole.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

solana: token-bridge: Fix tests 

Refactor the tests so that we can run them with `cargo test-bpf`.
This commit is contained in:
Chirantan Ekbote 2022-04-19 14:12:33 +09:00 committed by Chirantan Ekbote
parent 06c79838bd
commit ff40fa34b8
5 changed files with 684 additions and 586 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
solana/Cargo.lock generated
View File

@ -3476,8 +3476,8 @@ dependencies = [
"rocksalt",
"serde",
"sha3",
"solana-client",
"solana-program",
"solana-program-test",
"solana-sdk",
"solitaire",
"solitaire-client",

6
solana/modules/token_bridge/program/Cargo.toml
View File

@ -9,12 +9,13 @@ crate-type = ["cdylib", "lib"]
name = "token_bridge"
[features]
no-entrypoint = ["solitaire/no-entrypoint", "rand"]
no-entrypoint = ["solitaire/no-entrypoint", "instructions", "rand"]
trace = ["solitaire/trace"]
wasm = ["no-entrypoint", "wasm-bindgen"]
client = ["solitaire-client", "solitaire/client", "no-entrypoint"]
cpi = ["no-entrypoint"]
default = []
instructions = []
[dependencies]
wormhole-bridge-solana = { path = "../../../bridge/program", features = ["no-entrypoint", "cpi"] }
@ -37,7 +38,8 @@ rand = { version = "0.7.3", optional = true }
hex = "*"
hex-literal = "0.3.1"
libsecp256k1 = { version = "0.6.0", features = [] }
solana-client = "=1.9.4"
rand = "0.7.3"
solana-program-test = "=1.9.4"
solana-sdk = "=1.9.4"
spl-token = { version = "=3.2.0", features = ["no-entrypoint"] }
spl-token-metadata = { path = "../token-metadata" }

2
solana/modules/token_bridge/program/src/lib.rs
View File

@ -4,7 +4,7 @@
// #![cfg(all(target_arch = "bpf", not(feature = "no-entrypoint")))]
#[cfg(feature = "no-entrypoint")]
#[cfg(feature = "instructions")]
pub mod instructions;
#[cfg(feature = "wasm")]

480
solana/modules/token_bridge/program/tests/common.rs
View File

@ -9,17 +9,12 @@ use byteorder::{
WriteBytesExt,
};
use hex_literal::hex;
use secp256k1::{
use libsecp256k1::{
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,
@ -36,8 +31,12 @@ use solana_program::{
system_program,
sysvar,
};
use solana_program_test::{
BanksClient,
ProgramTest,
};
use solana_sdk::{
commitment_config::CommitmentConfig,
commitment_config::CommitmentLevel,
rent::Rent,
secp256k1_instruction::new_secp256k1_instruction,
signature::{
@ -46,7 +45,9 @@ use solana_sdk::{
Signature,
Signer,
},
signers::Signers,
transaction::Transaction,
transport::TransportError,
};
use spl_token::state::Mint;
use std::{
@ -78,32 +79,33 @@ use solitaire::{
pub use helpers::*;
/// Simple API wrapper for quickly preparing and sending transactions.
pub fn execute(
client: &RpcClient,
pub async fn execute<T: Signers>(
client: &mut BanksClient,
payer: &Keypair,
signers: &[&Keypair],
signers: &T,
instructions: &[Instruction],
commitment_level: CommitmentConfig,
) -> Result<Signature, ClientError> {
commitment_level: CommitmentLevel,
) -> Result<(), TransportError> {
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,
},
)
let recent_blockhash = client.get_latest_blockhash().await?;
transaction.sign(signers, recent_blockhash);
client
.process_transaction_with_commitment(transaction, commitment_level)
.await
}
mod helpers {
use bridge::types::{
ConsistencyLevel,
use super::*;
use bridge::{
accounts::{
FeeCollector,
PostedVAADerivationData,
},
types::ConsistencyLevel,
PostVAAData,
PostedVAAData,
};
use solana_program_test::processor;
use token_bridge::{
CompleteNativeData,
CompleteWrappedData,
@ -113,14 +115,6 @@ mod helpers {
TransferWrappedData,
};
use super::*;
use bridge::{
accounts::{
FeeCollector,
PostedVAADerivationData,
},
PostVAAData,
};
use std::ops::Add;
use token_bridge::messages::{
PayloadAssetMeta,
@ -128,14 +122,39 @@ mod helpers {
PayloadTransfer,
};
/// Generate `count` secp256k1 private keys, along with their ethereum-styled public key
/// encoding: 0x0123456789ABCDEF01234
pub fn generate_keys(count: u8) -> (Vec<[u8; 20]>, Vec<SecretKey>) {
use rand::Rng;
use sha3::Digest;
let mut rng = rand::thread_rng();
// Generate Guardian Keys
let secret_keys: Vec<SecretKey> = std::iter::repeat_with(|| SecretKey::random(&mut rng))
.take(count as usize)
.collect();
(
secret_keys
.iter()
.map(|key| {
let public_key = PublicKey::from_secret_key(&key);
let mut h = sha3::Keccak256::default();
h.write(&public_key.serialize()[1..]).unwrap();
let key: [u8; 32] = h.finalize().into();
let mut address = [0u8; 20];
address.copy_from_slice(&key[12..]);
address
})
.collect(),
secret_keys,
)
}
/// 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);
pub async fn setup() -> (BanksClient, Keypair, Pubkey, Pubkey) {
let (program, token_program) = (
env::var("BRIDGE_PROGRAM")
.unwrap_or("Bridge1p5gheXUvJ6jGWGeCsgPKgnE3YgdGKRVCMY9o".to_string())
@ -147,81 +166,105 @@ mod helpers {
.unwrap(),
);
(payer, rpc, program, token_program)
let mut builder = ProgramTest::new("bridge", program, processor!(bridge::solitaire));
builder.add_program(
"spl_token_metadata",
spl_token_metadata::id(),
None,
);
builder.add_program(
"token_bridge",
token_program,
processor!(token_bridge::solitaire),
);
// Some instructions go over the limit when tracing is enabled but we need that for better
// logging. We don't really care about the limit during these tests anyway.
builder.set_compute_max_units(u64::MAX);
let (client, payer, _) = builder.start().await;
(client, payer, 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) {
pub async fn sync(client: &mut BanksClient, payer: &Keypair) {
let payer_key = payer.pubkey();
execute(
client,
payer,
&[payer],
&[system_instruction::transfer(
&payer.pubkey(),
&payer.pubkey(),
1,
)],
CommitmentConfig::finalized(),
&[system_instruction::transfer(&payer_key, &payer_key, 1)],
CommitmentLevel::Finalized,
)
.await
.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,
pub async fn get_account_data<T: BorshDeserialize>(
client: &mut BanksClient,
account: Pubkey,
) -> Option<T> {
let account = client
.get_account_with_commitment(account, CommitmentConfig::processed())
.get_account_with_commitment(account, CommitmentLevel::Processed)
.await
.unwrap()
.unwrap();
T::try_from_slice(&account.value.unwrap().data).ok()
T::try_from_slice(&account.data).ok()
}
pub fn initialize_bridge(
client: &RpcClient,
program: &Pubkey,
/// Fetch account balance
pub async fn get_account_balance(client: &mut BanksClient, account: Pubkey) -> u64 {
client.get_account(account).await.unwrap().unwrap().lamports
}
pub async fn initialize_bridge(
client: &mut BanksClient,
program: Pubkey,
payer: &Keypair,
) -> Result<Signature, ClientError> {
let initial_guardians = &[[1u8; 20]];
initial_guardians: &[[u8; 20]],
) -> Result<(), TransportError> {
execute(
client,
payer,
&[payer],
&[bridge::instructions::initialize(
*program,
program,
payer.pubkey(),
50,
2_000_000_000,
initial_guardians,
)
.unwrap()],
CommitmentConfig::processed(),
CommitmentLevel::Processed,
)
.await
}
pub fn transfer(
client: &RpcClient,
pub async fn transfer(
client: &mut BanksClient,
from: &Keypair,
to: &Pubkey,
lamports: u64,
) -> Result<Signature, ClientError> {
) -> Result<(), TransportError> {
execute(
client,
from,
&[from],
&[system_instruction::transfer(&from.pubkey(), to, lamports)],
CommitmentConfig::processed(),
CommitmentLevel::Processed,
)
.await
}
pub fn initialize(
client: &RpcClient,
program: &Pubkey,
pub async fn initialize(
client: &mut BanksClient,
program: Pubkey,
payer: &Keypair,
bridge: &Pubkey,
) -> Result<Signature, ClientError> {
let instruction = instructions::initialize(*program, payer.pubkey(), *bridge)
bridge: Pubkey,
) -> Result<(), TransportError> {
let instruction = instructions::initialize(program, payer.pubkey(), bridge)
.expect("Could not create Initialize instruction");
for account in instruction.accounts.iter().enumerate() {
@ -233,31 +276,29 @@ mod helpers {
payer,
&[payer],
&[instruction],
CommitmentConfig::processed(),
CommitmentLevel::Processed,
)
.await
}
pub fn attest(
client: &RpcClient,
program: &Pubkey,
bridge: &Pubkey,
pub async fn attest(
client: &mut BanksClient,
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");
) -> Result<(), TransportError> {
let account = client
.get_account_with_commitment(mint, CommitmentLevel::Finalized)
.await?
.expect("mint account not found");
let mint_data = Mint::unpack(&account.data).expect("Could not unpack Mint");
let instruction = instructions::attest(
*program,
*bridge,
program,
bridge,
payer.pubkey(),
message.pubkey(),
mint,
@ -274,24 +315,25 @@ mod helpers {
payer,
&[payer, message],
&[instruction],
CommitmentConfig::processed(),
CommitmentLevel::Processed,
)
.await
}
pub fn transfer_native(
client: &RpcClient,
program: &Pubkey,
bridge: &Pubkey,
pub async fn transfer_native(
client: &mut BanksClient,
program: Pubkey,
bridge: Pubkey,
payer: &Keypair,
message: &Keypair,
from: &Keypair,
from_owner: &Keypair,
mint: Pubkey,
amount: u64,
) -> Result<Signature, ClientError> {
) -> Result<(), TransportError> {
let instruction = instructions::transfer_native(
*program,
*bridge,
program,
bridge,
payer.pubkey(),
message.pubkey(),
from.pubkey(),
@ -318,7 +360,7 @@ mod helpers {
spl_token::instruction::approve(
&spl_token::id(),
&from.pubkey(),
&token_bridge::accounts::AuthoritySigner::key(None, program),
&token_bridge::accounts::AuthoritySigner::key(None, &program),
&from_owner.pubkey(),
&[],
amount,
@ -326,14 +368,15 @@ mod helpers {
.unwrap(),
instruction,
],
CommitmentConfig::processed(),
CommitmentLevel::Processed,
)
.await
}
pub fn transfer_wrapped(
client: &RpcClient,
program: &Pubkey,
bridge: &Pubkey,
pub async fn transfer_wrapped(
client: &mut BanksClient,
program: Pubkey,
bridge: Pubkey,
payer: &Keypair,
message: &Keypair,
from: Pubkey,
@ -341,10 +384,10 @@ mod helpers {
token_chain: u16,
token_address: Address,
amount: u64,
) -> Result<Signature, ClientError> {
) -> Result<(), TransportError> {
let instruction = instructions::transfer_wrapped(
*program,
*bridge,
program,
bridge,
payer.pubkey(),
message.pubkey(),
from,
@ -373,7 +416,7 @@ mod helpers {
spl_token::instruction::approve(
&spl_token::id(),
&from,
&token_bridge::accounts::AuthoritySigner::key(None, program),
&token_bridge::accounts::AuthoritySigner::key(None, &program),
&from_owner.pubkey(),
&[],
amount,
@ -381,24 +424,25 @@ mod helpers {
.unwrap(),
instruction,
],
CommitmentConfig::processed(),
CommitmentLevel::Processed,
)
.await
}
pub fn register_chain(
client: &RpcClient,
program: &Pubkey,
bridge: &Pubkey,
message_acc: &Pubkey,
pub async fn register_chain(
client: &mut BanksClient,
program: Pubkey,
bridge: Pubkey,
message_acc: Pubkey,
vaa: PostVAAData,
payload: PayloadGovernanceRegisterChain,
payer: &Keypair,
) -> Result<Signature, ClientError> {
) -> Result<(), TransportError> {
let instruction = instructions::register_chain(
*program,
*bridge,
program,
bridge,
payer.pubkey(),
*message_acc,
message_acc,
vaa,
payload,
RegisterChainData {},
@ -414,24 +458,25 @@ mod helpers {
payer,
&[payer],
&[instruction],
CommitmentConfig::processed(),
CommitmentLevel::Processed,
)
.await
}
pub fn complete_native(
client: &RpcClient,
program: &Pubkey,
bridge: &Pubkey,
message_acc: &Pubkey,
pub async fn complete_native(
client: &mut BanksClient,
program: Pubkey,
bridge: Pubkey,
message_acc: Pubkey,
vaa: PostVAAData,
payload: PayloadTransfer,
payer: &Keypair,
) -> Result<Signature, ClientError> {
) -> Result<(), TransportError> {
let instruction = instructions::complete_native(
*program,
*bridge,
program,
bridge,
payer.pubkey(),
*message_acc,
message_acc,
vaa,
Pubkey::new(&payload.to[..]),
None,
@ -449,26 +494,27 @@ mod helpers {
payer,
&[payer],
&[instruction],
CommitmentConfig::processed(),
CommitmentLevel::Processed,
)
.await
}
pub fn complete_transfer_wrapped(
client: &RpcClient,
program: &Pubkey,
bridge: &Pubkey,
message_acc: &Pubkey,
pub async fn complete_transfer_wrapped(
client: &mut BanksClient,
program: Pubkey,
bridge: Pubkey,
message_acc: Pubkey,
vaa: PostVAAData,
payload: PayloadTransfer,
payer: &Keypair,
) -> Result<Signature, ClientError> {
) -> Result<(), TransportError> {
let to = Pubkey::new(&payload.to[..]);
let instruction = instructions::complete_wrapped(
*program,
*bridge,
program,
bridge,
payer.pubkey(),
*message_acc,
message_acc,
vaa,
payload,
to,
@ -486,24 +532,25 @@ mod helpers {
payer,
&[payer],
&[instruction],
CommitmentConfig::processed(),
CommitmentLevel::Processed,
)
.await
}
pub fn create_wrapped(
client: &RpcClient,
program: &Pubkey,
bridge: &Pubkey,
message_acc: &Pubkey,
pub async fn create_wrapped(
client: &mut BanksClient,
program: Pubkey,
bridge: Pubkey,
message_acc: Pubkey,
vaa: PostVAAData,
payload: PayloadAssetMeta,
payer: &Keypair,
) -> Result<Signature, ClientError> {
) -> Result<(), TransportError> {
let instruction = instructions::create_wrapped(
*program,
*bridge,
program,
bridge,
payer.pubkey(),
*message_acc,
message_acc,
vaa,
payload,
CreateWrappedData {},
@ -519,16 +566,18 @@ mod helpers {
payer,
&[payer],
&[instruction],
CommitmentConfig::processed(),
CommitmentLevel::Processed,
)
.await
}
pub fn create_mint(
client: &RpcClient,
pub async fn create_mint(
client: &mut BanksClient,
payer: &Keypair,
mint_authority: &Pubkey,
mint: &Keypair,
) -> Result<Signature, ClientError> {
) -> Result<(), TransportError> {
let mint_key = mint.pubkey();
execute(
client,
payer,
@ -536,45 +585,46 @@ mod helpers {
&[
solana_sdk::system_instruction::create_account(
&payer.pubkey(),
&mint.pubkey(),
&mint_key,
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_key,
mint_authority,
None,
0,
)
.unwrap(),
],
CommitmentConfig::processed(),
CommitmentLevel::Processed,
)
.await
}
pub fn create_spl_metadata(
client: &RpcClient,
pub async fn create_spl_metadata(
client: &mut BanksClient,
payer: &Keypair,
metadata_account: &Pubkey,
metadata_account: Pubkey,
mint_authority: &Keypair,
mint: &Keypair,
update_authority: &Pubkey,
update_authority: Pubkey,
name: String,
symbol: String,
) -> Result<Signature, ClientError> {
) -> Result<(), TransportError> {
execute(
client,
payer,
&[payer, mint_authority],
&[spl_token_metadata::instruction::create_metadata_accounts(
spl_token_metadata::id(),
*metadata_account,
metadata_account,
mint.pubkey(),
mint_authority.pubkey(),
payer.pubkey(),
*update_authority,
update_authority,
name,
symbol,
"https://token.org".to_string(),
@ -583,17 +633,19 @@ mod helpers {
false,
false,
)],
CommitmentConfig::processed(),
CommitmentLevel::Processed,
)
.await
}
pub fn create_token_account(
client: &RpcClient,
pub async fn create_token_account(
client: &mut BanksClient,
payer: &Keypair,
token_acc: &Keypair,
token_authority: Pubkey,
mint: Pubkey,
) -> Result<Signature, ClientError> {
token_authority: &Pubkey,
mint: &Pubkey,
) -> Result<(), TransportError> {
let token_key = token_acc.pubkey();
execute(
client,
payer,
@ -601,35 +653,36 @@ mod helpers {
&[
solana_sdk::system_instruction::create_account(
&payer.pubkey(),
&token_acc.pubkey(),
&token_key,
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,
&token_key,
mint,
token_authority,
)
.unwrap(),
],
CommitmentConfig::processed(),
CommitmentLevel::Processed,
)
.await
}
pub fn mint_tokens(
client: &RpcClient,
pub async fn mint_tokens(
client: &mut BanksClient,
payer: &Keypair,
mint_authority: &Keypair,
mint: &Keypair,
token_account: &Pubkey,
amount: u64,
) -> Result<Signature, ClientError> {
) -> Result<(), TransportError> {
execute(
client,
payer,
&[payer, &mint_authority],
&[payer, mint_authority],
&[spl_token::instruction::mint_to(
&spl_token::id(),
&mint.pubkey(),
@ -639,15 +692,16 @@ mod helpers {
amount,
)
.unwrap()],
CommitmentConfig::processed(),
CommitmentLevel::Processed,
)
.await
}
/// Utility function for generating VAA's from message data.
pub fn generate_vaa(
pub fn generate_vaa<T: Into<Vec<u8>>>(
emitter: Address,
emitter_chain: u16,
data: Vec<u8>,
data: T,
nonce: u32,
sequence: u64,
) -> (PostVAAData, [u8; 32], [u8; 32]) {
@ -659,7 +713,7 @@ mod helpers {
emitter_chain,
emitter_address: emitter,
sequence,
payload: data,
payload: data.into(),
timestamp: SystemTime::now()
.duration_since(SystemTime::UNIX_EPOCH)
.unwrap()
@ -698,14 +752,54 @@ mod helpers {
(vaa, body, body_hash)
}
pub fn post_vaa(
client: &RpcClient,
pub async fn verify_signatures(
client: &mut BanksClient,
program: &Pubkey,
payer: &Keypair,
body: [u8; 32],
secret_keys: &[SecretKey],
guardian_set_version: u32,
) -> Result<Pubkey, TransportError> {
let signature_set = Keypair::new();
let tx_signers = [payer, &signature_set];
// Push Secp256k1 instructions for each signature we want to verify.
for (i, key) in secret_keys.iter().enumerate() {
// Set this signers signature position as present at 0.
let mut signers = [-1; 19];
signers[i] = 0;
execute(
client,
payer,
&tx_signers,
&[
new_secp256k1_instruction(key, &body),
bridge::instructions::verify_signatures(
*program,
payer.pubkey(),
guardian_set_version,
signature_set.pubkey(),
bridge::VerifySignaturesData { signers },
)
.unwrap(),
],
CommitmentLevel::Processed,
)
.await?;
}
Ok(signature_set.pubkey())
}
pub async fn post_vaa(
client: &mut BanksClient,
program: Pubkey,
payer: &Keypair,
signature_set: Pubkey,
vaa: PostVAAData,
) -> Result<(), ClientError> {
) -> Result<(), TransportError> {
let instruction =
bridge::instructions::post_vaa(*program, payer.pubkey(), Pubkey::new_unique(), vaa);
bridge::instructions::post_vaa(program, payer.pubkey(), signature_set, vaa);
for account in instruction.accounts.iter().enumerate() {
println!("{}: {}", account.0, account.1.pubkey);
@ -716,28 +810,27 @@ mod helpers {
payer,
&[payer],
&[instruction],
CommitmentConfig::processed(),
)?;
Ok(())
CommitmentLevel::Processed,
)
.await
}
pub fn post_message(
client: &RpcClient,
program: &Pubkey,
pub async fn post_message(
client: &mut BanksClient,
program: Pubkey,
payer: &Keypair,
emitter: &Keypair,
message: &Keypair,
nonce: u32,
data: Vec<u8>,
fee: u64,
) -> Result<(), ClientError> {
) -> Result<(), TransportError> {
// Transfer money into the fee collector as it needs a balance/must exist.
let fee_collector = FeeCollector::<'_>::key(None, program);
let fee_collector = FeeCollector::<'_>::key(None, &program);
// Capture the resulting message, later functions will need this.
let instruction = bridge::instructions::post_message(
*program,
program,
payer.pubkey(),
emitter.pubkey(),
message.pubkey(),
@ -759,9 +852,8 @@ mod helpers {
system_instruction::transfer(&payer.pubkey(), &fee_collector, fee),
instruction,
],
CommitmentConfig::processed(),
)?;
Ok(())
CommitmentLevel::Processed,
)
.await
}
}

780
solana/modules/token_bridge/program/tests/integration.rs
View File

@ -1,19 +1,48 @@
#![allow(warnings)]
use borsh::BorshSerialize;
use bridge::{
accounts::{
Bridge,
FeeCollector,
GuardianSet,
GuardianSetDerivationData,
PostedVAA,
PostedVAADerivationData,
SignatureSet,
},
instruction,
types::{
GovernancePayloadGuardianSetChange,
GovernancePayloadSetMessageFee,
GovernancePayloadTransferFees,
},
BridgeConfig,
BridgeData,
GuardianSetData,
Initialize,
MessageData,
PostVAA,
PostVAAData,
PostedVAAData,
SequenceTracker,
SerializePayload,
Signature,
SignatureSet as SignatureSetData,
};
use byteorder::{
BigEndian,
WriteBytesExt,
};
use hex_literal::hex;
use rand::Rng;
use secp256k1::{
use libsecp256k1::{
Message as Secp256k1Message,
PublicKey,
SecretKey,
};
use primitive_types::U256;
use rand::Rng;
use sha3::Digest;
use solana_client::rpc_client::RpcClient;
use solana_program::{
borsh::try_from_slice_unchecked,
hash,
@ -30,14 +59,19 @@ use solana_program::{
system_program,
sysvar,
};
use solana_program_test::{
tokio,
BanksClient,
};
use solana_sdk::{
commitment_config::CommitmentConfig,
commitment_config::CommitmentLevel,
signature::{
read_keypair_file,
Keypair,
Signer,
},
transaction::Transaction,
transport::TransportError,
};
use solitaire::{
processors::seeded::Seeded,
@ -45,54 +79,22 @@ use solitaire::{
};
use spl_token::state::Mint;
use std::{
collections::HashMap,
convert::TryInto,
io::{
Cursor,
Write,
},
str::FromStr,
time::{
Duration,
SystemTime,
UNIX_EPOCH,
},
};
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::{
ConfigAccount,
EmitterAccount,
WrappedDerivationData,
WrappedMint,
@ -102,7 +104,10 @@ use token_bridge::{
PayloadGovernanceRegisterChain,
PayloadTransfer,
},
types::Address,
types::{
Address,
Config,
},
};
mod common;
@ -115,11 +120,17 @@ const GOVERNANCE_KEY: [u8; 64] = [
];
struct Context {
/// Guardian public keys.
guardians: Vec<[u8; 20]>,
/// Guardian secret keys.
guardian_keys: Vec<SecretKey>,
/// Address of the core bridge contract.
bridge: Pubkey,
/// Shared RPC client for tests to make transactions with.
client: RpcClient,
client: BanksClient,
/// Payer key with a ton of lamports to ease testing with.
payer: Keypair,
@ -159,13 +170,13 @@ impl Sequencer {
}
}
#[test]
fn run_integration_tests() {
let (payer, client, bridge, token_bridge) = common::setup();
async fn set_up() -> Result<Context, TransportError> {
let (guardians, guardian_keys) = common::generate_keys(6);
let (mut client, payer, bridge, token_bridge) = common::setup().await;
// Setup a Bridge to test against.
println!("Bridge: {}", bridge);
common::initialize_bridge(&client, &bridge, &payer);
common::initialize_bridge(&mut client, bridge, &payer, &guardians).await?;
// Context for test environment.
let mint = Keypair::new();
@ -194,6 +205,8 @@ fn run_integration_tests() {
);
let mut context = Context {
guardians,
guardian_keys,
seq: Sequencer {
sequences: HashMap::new(),
},
@ -211,353 +224,58 @@ fn run_integration_tests() {
// Create a mint for use within tests.
common::create_mint(
&context.client,
&mut context.client,
&context.payer,
&context.mint_authority.pubkey(),
&context.mint,
)
.unwrap();
.await?;
// Create Token accounts for use within tests.
common::create_token_account(
&context.client,
&mut context.client,
&context.payer,
&context.token_account,
context.token_authority.pubkey(),
context.mint.pubkey(),
&context.token_authority.pubkey(),
&context.mint.pubkey(),
)
.unwrap();
.await?;
// Mint tokens
common::mint_tokens(
&context.client,
&mut context.client,
&context.payer,
&context.mint_authority,
&context.mint,
&context.token_account.pubkey(),
1000,
)
.unwrap();
.await?;
// 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,
// Initialize the token bridge.
common::initialize(
&mut context.client,
context.token_bridge,
&context.payer,
&context.metadata_account,
&context.mint_authority,
&context.mint,
&context.payer.pubkey(),
"BTC".to_string(),
"Bitcoin".to_string(),
context.bridge,
)
.await
.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());
// Verify Token Bridge State
let config_key = ConfigAccount::<'_, { AccountState::Uninitialized }>::key(None, &token_bridge);
let config: Config = common::get_account_data(&mut context.client, config_key)
.await
.unwrap();
assert_eq!(config.wormhole_bridge, bridge);
Ok(context)
}
fn test_attest(context: &mut Context) -> () {
println!("Attest");
use token_bridge::{
accounts::ConfigAccount,
types::Config,
};
async fn create_wrapped(context: &mut Context) -> Pubkey {
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 mut client,
ref bridge,
ref token_bridge,
ref mint_authority,
@ -579,53 +297,339 @@ fn test_create_wrapped(context: &mut Context) -> (Pubkey) {
};
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 (vaa, body, _) = common::generate_vaa([0u8; 32], 2, message, nonce, 2);
let signature_set =
common::verify_signatures(client, bridge, payer, body, &context.guardian_keys, 0)
.await
.unwrap();
common::post_vaa(client, *bridge, payer, signature_set, vaa.clone())
.await
.unwrap();
let mut msg_derivation_data = &PostedVAADerivationData {
payload_hash: bridge::instructions::hash_vaa(&vaa).to_vec(),
payload_hash: body.to_vec(),
};
let message_key =
PostedVAA::<'_, { AccountState::MaybeInitialized }>::key(&msg_derivation_data, &bridge);
PostedVAA::<'_, { AccountState::MaybeInitialized }>::key(&msg_derivation_data, bridge);
common::create_wrapped(
client,
token_bridge,
bridge,
&message_key,
*token_bridge,
*bridge,
message_key,
vaa,
payload,
payer,
)
.await
.unwrap();
return WrappedMint::<'_, { AccountState::Initialized }>::key(
WrappedMint::<'_, { AccountState::Initialized }>::key(
&WrappedDerivationData {
token_chain: 2,
token_address: [1u8; 32],
},
token_bridge,
);
&token_bridge,
)
}
fn test_initialize(context: &mut Context) {
println!("Initialize");
use token_bridge::{
accounts::ConfigAccount,
types::Config,
};
// Create an SPL Metadata account to test attestations for wrapped tokens.
async fn create_wrapped_account(context: &mut Context) -> Result<Pubkey, TransportError> {
common::create_spl_metadata(
&mut context.client,
&context.payer,
context.metadata_account,
&context.mint_authority,
&context.mint,
context.payer.pubkey(),
"BTC".to_string(),
"Bitcoin".to_string(),
)
.await?;
let wrapped = create_wrapped(context).await;
let wrapped_acc = Keypair::new();
common::create_token_account(
&mut context.client,
&context.payer,
&wrapped_acc,
&context.token_authority.pubkey(),
&wrapped,
)
.await?;
Ok(wrapped_acc.pubkey())
}
#[tokio::test]
async fn attest() {
let Context {
ref payer,
ref client,
ref mut client,
bridge,
token_bridge,
ref mint_authority,
ref mint,
ref mint_meta,
ref metadata_account,
..
} = set_up().await.unwrap();
let message = &Keypair::new();
common::attest(
client,
token_bridge,
bridge,
payer,
message,
mint.pubkey(),
0,
)
.await
.unwrap();
let emitter_key = EmitterAccount::key(None, &token_bridge);
let account = client
.get_account_with_commitment(mint.pubkey(), CommitmentLevel::Processed)
.await
.unwrap()
.unwrap();
let mint_data = Mint::unpack(&account.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();
}
#[tokio::test]
async fn transfer_native() {
let Context {
ref payer,
ref mut client,
bridge,
token_bridge,
ref mint_authority,
ref mint,
ref mint_meta,
ref token_account,
ref token_authority,
..
} = set_up().await.unwrap();
let message = &Keypair::new();
common::transfer_native(
client,
token_bridge,
bridge,
payer,
message,
token_account,
token_authority,
mint.pubkey(),
100,
)
.await
.unwrap();
}
async fn register_chain(context: &mut Context) {
let Context {
ref payer,
ref mut client,
ref bridge,
ref token_bridge,
ref mint_authority,
ref mint,
ref mint_meta,
ref token_authority,
ref guardian_keys,
..
} = context;
common::initialize(client, token_bridge, payer, &bridge).unwrap();
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();
// 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);
let (vaa, body, _) = common::generate_vaa(emitter.pubkey().to_bytes(), 1, message, nonce, 0);
let signature_set = common::verify_signatures(client, &bridge, payer, body, guardian_keys, 0)
.await
.unwrap();
common::post_vaa(client, *bridge, payer, signature_set, vaa.clone())
.await
.unwrap();
let mut msg_derivation_data = &PostedVAADerivationData {
payload_hash: body.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,
)
.await
.unwrap();
}
#[tokio::test]
async fn transfer_native_in() {
let mut context = set_up().await.unwrap();
register_chain(&mut context).await;
let Context {
ref payer,
ref mut client,
bridge,
token_bridge,
ref mint_authority,
ref mint,
ref mint_meta,
ref token_account,
ref token_authority,
ref guardian_keys,
..
} = context;
// Do an initial transfer so that the bridge account has some native tokens. This also creates
// the custody account.
let message = &Keypair::new();
common::transfer_native(
client,
token_bridge,
bridge,
payer,
message,
token_account,
token_authority,
mint.pubkey(),
100,
)
.await
.unwrap();
let nonce = rand::thread_rng().gen();
let payload = PayloadTransfer {
amount: U256::from(100u128),
token_address: mint.pubkey().to_bytes(),
token_chain: 1,
to: token_account.pubkey().to_bytes(),
to_chain: 1,
fee: U256::from(0u128),
};
let message = payload.try_to_vec().unwrap();
let (vaa, body, _) = common::generate_vaa([0u8; 32], 2, message, nonce, 1);
let signature_set = common::verify_signatures(client, &bridge, payer, body, guardian_keys, 0)
.await
.unwrap();
common::post_vaa(client, bridge, payer, signature_set, vaa.clone())
.await
.unwrap();
let msg_derivation_data = &PostedVAADerivationData {
payload_hash: body.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,
)
.await
.unwrap();
}
#[tokio::test]
async fn transfer_wrapped() {
let mut context = set_up().await.unwrap();
register_chain(&mut context).await;
let to = create_wrapped_account(&mut context).await.unwrap();
let Context {
ref payer,
ref mut client,
bridge,
token_bridge,
ref mint_authority,
ref mint,
ref mint_meta,
ref token_account,
ref token_authority,
ref guardian_keys,
..
} = 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, body, _) =
common::generate_vaa([0u8; 32], 2, message, nonce, rand::thread_rng().gen());
let signature_set = common::verify_signatures(client, &bridge, payer, body, guardian_keys, 0)
.await
.unwrap();
common::post_vaa(client, bridge, payer, signature_set, vaa.clone())
.await
.unwrap();
let mut msg_derivation_data = &PostedVAADerivationData {
payload_hash: body.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,
)
.await
.unwrap();
// Now transfer the wrapped tokens back, which will burn them.
let message = &Keypair::new();
common::transfer_wrapped(
client,
token_bridge,
bridge,
payer,
message,
to,
token_authority,
2,
[1u8; 32],
10000000,
)
.await
.unwrap();
}