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

terra: Fix formatting 

Also disable the unstable options in rustfmt.toml.
This commit is contained in:
Chirantan Ekbote 2022-09-30 16:03:54 +09:00 committed by Evan Gray
parent 8d6bf74262
commit 68ae3ff6cd
27 changed files with 238 additions and 711 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
terra/contracts/cw20-wrapped/src/contract.rs
View File

@ -1,16 +1,6 @@
use cosmwasm_std::{
to_binary,
Binary,
CosmosMsg,
Deps,
DepsMut,
Env,
MessageInfo,
Response,
StdError,
StdResult,
Uint128,
WasmMsg,
to_binary, Binary, CosmosMsg, Deps, DepsMut, Env, MessageInfo, Response, StdError, StdResult,
Uint128, WasmMsg,
};
#[cfg(not(feature = "library"))]
@ -19,40 +9,17 @@ use cosmwasm_std::entry_point;
use cw2::set_contract_version;
use cw20_legacy::{
allowances::{
execute_burn_from,
execute_decrease_allowance,
execute_increase_allowance,
execute_send_from,
execute_transfer_from,
query_allowance,
},
contract::{
execute_mint,
execute_send,
execute_transfer,
query_balance,
},
state::{
MinterData,
TokenInfo,
TOKEN_INFO,
execute_burn_from, execute_decrease_allowance, execute_increase_allowance,
execute_send_from, execute_transfer_from, query_allowance,
},
contract::{execute_mint, execute_send, execute_transfer, query_balance},
state::{MinterData, TokenInfo, TOKEN_INFO},
ContractError,
};
use crate::{
msg::{
ExecuteMsg,
InstantiateMsg,
MigrateMsg,
QueryMsg,
WrappedAssetInfoResponse,
},
state::{
wrapped_asset_info,
wrapped_asset_info_read,
WrappedAssetInfo,
},
msg::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg, WrappedAssetInfoResponse},
state::{wrapped_asset_info, wrapped_asset_info_read, WrappedAssetInfo},
};
use cw20::TokenInfoResponse;
use std::string::String;
@ -237,11 +204,7 @@ pub fn query_wrapped_asset_info(deps: Deps) -> StdResult<WrappedAssetInfoRespons
#[cfg(test)]
mod tests {
use super::*;
use cosmwasm_std::testing::{
mock_dependencies,
mock_env,
mock_info,
};
use cosmwasm_std::testing::{mock_dependencies, mock_env, mock_info};
use cw20::TokenInfoResponse;
fn get_balance(deps: Deps, address: HumanAddr) -> Uint128 {

11
terra/contracts/cw20-wrapped/src/msg.rs
View File

@ -1,15 +1,8 @@
#![allow(clippy::field_reassign_with_default)]
use schemars::JsonSchema;
use serde::{
Deserialize,
Serialize,
};
use serde::{Deserialize, Serialize};
use cosmwasm_std::{
Addr,
Binary,
Uint128,
};
use cosmwasm_std::{Addr, Binary, Uint128};
use cw20::Expiration;
type HumanAddr = String;

22
terra/contracts/cw20-wrapped/src/state.rs
View File

@ -1,20 +1,8 @@
use schemars::JsonSchema;
use serde::{
Deserialize,
Serialize,
};
use serde::{Deserialize, Serialize};
use cosmwasm_std::{
Binary,
CanonicalAddr,
Storage,
};
use cosmwasm_storage::{
singleton,
singleton_read,
ReadonlySingleton,
Singleton,
};
use cosmwasm_std::{Binary, CanonicalAddr, Storage};
use cosmwasm_storage::{singleton, singleton_read, ReadonlySingleton, Singleton};
pub const KEY_WRAPPED_ASSET: &[u8] = b"wrappedAsset";
@ -30,8 +18,6 @@ pub fn wrapped_asset_info(storage: &mut dyn Storage) -> Singleton<WrappedAssetIn
singleton(storage, KEY_WRAPPED_ASSET)
}
pub fn wrapped_asset_info_read(
storage: &dyn Storage,
) -> ReadonlySingleton<WrappedAssetInfo> {
pub fn wrapped_asset_info_read(storage: &dyn Storage) -> ReadonlySingleton<WrappedAssetInfo> {
singleton_read(storage, KEY_WRAPPED_ASSET)
}

38
terra/contracts/cw20-wrapped/tests/integration.rs
View File

@ -1,38 +1,14 @@
use cosmwasm_std::{
from_slice,
testing::{
mock_dependencies,
mock_env,
mock_info,
MockApi,
MockQuerier,
MockStorage,
},
Addr,
Api,
OwnedDeps,
Response,
Storage,
Uint128,
testing::{mock_dependencies, mock_env, mock_info, MockApi, MockQuerier, MockStorage},
Addr, Api, OwnedDeps, Response, Storage, Uint128,
};
use cosmwasm_storage::to_length_prefixed;
use cw20::TokenInfoResponse;
use cw20_wrapped::{
contract::{
execute,
instantiate,
query,
},
msg::{
ExecuteMsg,
InstantiateMsg,
QueryMsg,
WrappedAssetInfoResponse,
},
state::{
WrappedAssetInfo,
KEY_WRAPPED_ASSET,
},
contract::{execute, instantiate, query},
msg::{ExecuteMsg, InstantiateMsg, QueryMsg, WrappedAssetInfoResponse},
state::{WrappedAssetInfo, KEY_WRAPPED_ASSET},
ContractError,
};
@ -42,9 +18,7 @@ static SENDER: &str = "addr3333";
fn get_wrapped_asset_info<S: Storage>(storage: &S) -> WrappedAssetInfo {
let key = to_length_prefixed(KEY_WRAPPED_ASSET);
let data = storage
.get(&key)
.expect("data should exist");
let data = storage.get(&key).expect("data should exist");
from_slice(&data).expect("invalid data")
}

32
terra/contracts/cw721-base/src/contract_tests.rs
View File

@ -1,39 +1,17 @@
#![cfg(test)]
use cosmwasm_std::{
from_binary,
testing::{
mock_dependencies,
mock_env,
mock_info,
},
to_binary,
CosmosMsg,
DepsMut,
Empty,
Response,
WasmMsg,
testing::{mock_dependencies, mock_env, mock_info},
to_binary, CosmosMsg, DepsMut, Empty, Response, WasmMsg,
};
use cw721::{
Approval,
ApprovalResponse,
ContractInfoResponse,
Cw721Query,
Cw721ReceiveMsg,
Expiration,
NftInfoResponse,
OperatorsResponse,
OwnerOfResponse,
Approval, ApprovalResponse, ContractInfoResponse, Cw721Query, Cw721ReceiveMsg, Expiration,
NftInfoResponse, OperatorsResponse, OwnerOfResponse,
};
use crate::{
ContractError,
Cw721Contract,
ExecuteMsg,
Extension,
InstantiateMsg,
MintMsg,
QueryMsg,
ContractError, Cw721Contract, ExecuteMsg, Extension, InstantiateMsg, MintMsg, QueryMsg,
};
const MINTER: &str = "merlin";

31
terra/contracts/cw721-wrapped/examples/schema.rs
View File

@ -1,33 +1,12 @@
use std::{
env::current_dir,
fs::create_dir_all,
};
use std::{env::current_dir, fs::create_dir_all};
use cosmwasm_schema::{
export_schema,
export_schema_with_title,
remove_schemas,
schema_for,
};
use cosmwasm_schema::{export_schema, export_schema_with_title, remove_schemas, schema_for};
use cw721::{
AllNftInfoResponse,
ApprovalResponse,
ApprovalsResponse,
ContractInfoResponse,
NftInfoResponse,
NumTokensResponse,
OperatorsResponse,
OwnerOfResponse,
TokensResponse,
};
use cw721_base::{
ExecuteMsg,
Extension,
InstantiateMsg,
MinterResponse,
QueryMsg,
AllNftInfoResponse, ApprovalResponse, ApprovalsResponse, ContractInfoResponse, NftInfoResponse,
NumTokensResponse, OperatorsResponse, OwnerOfResponse, TokensResponse,
};
use cw721_base::{ExecuteMsg, Extension, InstantiateMsg, MinterResponse, QueryMsg};
fn main() {
let mut out_dir = current_dir().unwrap();

30
terra/contracts/cw721-wrapped/src/lib.rs
View File

@ -2,10 +2,7 @@ pub mod msg;
pub mod state;
use schemars::JsonSchema;
use serde::{
Deserialize,
Serialize,
};
use serde::{Deserialize, Serialize};
pub use cosmwasm_std::to_binary;
use cosmwasm_std::Empty;
@ -27,34 +24,17 @@ pub mod entry {
use std::convert::TryInto;
use crate::msg::{
InstantiateMsg,
WrappedAssetInfoResponse,
};
use crate::msg::{InstantiateMsg, WrappedAssetInfoResponse};
pub use crate::{
msg::QueryMsg,
state::{
wrapped_asset_info,
wrapped_asset_info_read,
WrappedAssetInfo,
},
state::{wrapped_asset_info, wrapped_asset_info_read, WrappedAssetInfo},
};
use super::*;
use cosmwasm_std::{
entry_point,
to_binary,
Binary,
CosmosMsg,
Deps,
DepsMut,
Env,
MessageInfo,
Response,
StdError,
StdResult,
WasmMsg,
entry_point, to_binary, Binary, CosmosMsg, Deps, DepsMut, Env, MessageInfo, Response,
StdError, StdResult, WasmMsg,
};
use cw721::Cw721Query;

15
terra/contracts/cw721-wrapped/src/msg.rs
View File

@ -1,15 +1,8 @@
pub use cw721_base::MintMsg;
use schemars::JsonSchema;
use serde::{
Deserialize,
Serialize,
};
use serde::{Deserialize, Serialize};
use cosmwasm_std::{
Addr,
Binary,
Empty,
};
use cosmwasm_std::{Addr, Binary, Empty};
pub use cw721_base::msg::ExecuteMsg;
@ -129,7 +122,7 @@ pub enum QueryMsg {
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
pub struct WrappedAssetInfoResponse {
pub asset_chain: u16, // Asset chain id
pub asset_chain: u16, // Asset chain id
pub asset_address: Binary, // Asset smart contract address in the original chain
pub bridge: Addr, // Bridge address, authorized to mint and burn wrapped tokens
pub bridge: Addr, // Bridge address, authorized to mint and burn wrapped tokens
}

18
terra/contracts/cw721-wrapped/src/state.rs
View File

@ -1,20 +1,8 @@
use schemars::JsonSchema;
use serde::{
Deserialize,
Serialize,
};
use serde::{Deserialize, Serialize};
use cosmwasm_std::{
Binary,
CanonicalAddr,
Storage,
};
use cosmwasm_storage::{
singleton,
singleton_read,
ReadonlySingleton,
Singleton,
};
use cosmwasm_std::{Binary, CanonicalAddr, Storage};
use cosmwasm_storage::{singleton, singleton_read, ReadonlySingleton, Singleton};
pub const KEY_WRAPPED_ASSET: &[u8] = b"wrappedAsset";

66
terra/contracts/mock-bridge-integration/src/contract.rs
View File

@ -1,42 +1,16 @@
use cosmwasm_std::{
entry_point,
to_binary,
Binary,
CosmosMsg,
Deps,
DepsMut,
Env,
MessageInfo,
QueryRequest,
Reply,
Response,
StdError,
StdResult,
SubMsg,
WasmMsg,
WasmQuery,
entry_point, to_binary, Binary, CosmosMsg, Deps, DepsMut, Env, MessageInfo, QueryRequest,
Reply, Response, StdError, StdResult, SubMsg, WasmMsg, WasmQuery,
};
use crate::{
msg::{
ExecuteMsg,
InstantiateMsg,
MigrateMsg,
QueryMsg,
},
state::{
Config,
config,
config_read,
},
msg::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg},
state::{config, config_read, Config},
};
use token_bridge_terra::{
msg::{
ExecuteMsg as TokenBridgeExecuteMsg,
QueryMsg as TokenBridgeQueryMessage,
},
msg::TransferInfoResponse,
msg::{ExecuteMsg as TokenBridgeExecuteMsg, QueryMsg as TokenBridgeQueryMessage},
};
#[cfg_attr(not(feature = "library"), entry_point)]
@ -64,7 +38,7 @@ pub fn execute(deps: DepsMut, env: Env, info: MessageInfo, msg: ExecuteMsg) -> S
match msg {
ExecuteMsg::CompleteTransferWithPayload { data } => {
complete_transfer_with_payload(deps, env, info, &data)
},
}
}
}
@ -90,31 +64,31 @@ fn complete_transfer_with_payload(
CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: cfg.token_bridge_contract,
msg: to_binary(&TokenBridgeExecuteMsg::CompleteTransferWithPayload {
data: data.clone(), relayer: info.sender.to_string()
data: data.clone(),
relayer: info.sender.to_string(),
})?,
funds: vec![],
}),
1,
),];
)];
let transfer_info = parse_transfer_vaa(deps.as_ref(), data)?;
Ok(Response::new()
.add_submessages(messages)
.add_attribute("action", "complete_transfer_with_payload")
.add_attribute("transfer_payload", Binary::from(transfer_info.payload).to_base64()))
.add_attribute(
"transfer_payload",
Binary::from(transfer_info.payload).to_base64(),
))
}
fn parse_transfer_vaa(
deps: Deps,
data: &Binary,
) -> StdResult<TransferInfoResponse> {
fn parse_transfer_vaa(deps: Deps, data: &Binary) -> StdResult<TransferInfoResponse> {
let cfg = config_read(deps.storage).load()?;
let transfer_info: TransferInfoResponse = deps.querier.query(&QueryRequest::Wasm(WasmQuery::Smart {
contract_addr: cfg.token_bridge_contract,
msg: to_binary(&TokenBridgeQueryMessage::TransferInfo {
vaa: data.clone(),
})?,
}))?;
let transfer_info: TransferInfoResponse =
deps.querier.query(&QueryRequest::Wasm(WasmQuery::Smart {
contract_addr: cfg.token_bridge_contract,
msg: to_binary(&TokenBridgeQueryMessage::TransferInfo { vaa: data.clone() })?,
}))?;
Ok(transfer_info)
}
}

11
terra/contracts/mock-bridge-integration/src/msg.rs
View File

@ -1,9 +1,6 @@
use cosmwasm_std::Binary;
use schemars::JsonSchema;
use serde::{
Deserialize,
Serialize,
};
use serde::{Deserialize, Serialize};
type HumanAddr = String;
@ -15,9 +12,7 @@ pub struct InstantiateMsg {
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub enum ExecuteMsg {
CompleteTransferWithPayload {
data: Binary,
},
CompleteTransferWithPayload { data: Binary },
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
@ -28,4 +23,4 @@ pub struct MigrateMsg {}
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
WrappedRegistry { chain: u16, address: Binary },
}
}

14
terra/contracts/mock-bridge-integration/src/state.rs
View File

@ -1,16 +1,8 @@
use schemars::JsonSchema;
use serde::{
Deserialize,
Serialize,
};
use serde::{Deserialize, Serialize};
use cosmwasm_std::Storage;
use cosmwasm_storage::{
singleton,
singleton_read,
ReadonlySingleton,
Singleton,
};
use cosmwasm_storage::{singleton, singleton_read, ReadonlySingleton, Singleton};
type HumanAddr = String;
@ -28,4 +20,4 @@ pub fn config(storage: &mut dyn Storage) -> Singleton<Config> {
pub fn config_read(storage: &dyn Storage) -> ReadonlySingleton<Config> {
singleton_read(storage, CONFIG_KEY)
}
}

86
terra/contracts/nft-bridge/src/contract.rs
View File

@ -1,87 +1,35 @@
use crate::{
msg::WrappedRegistryResponse,
state::{
spl_cache,
spl_cache_read,
wrapped_asset,
BoundedVec,
SplCacheItem,
},
token_id::{
from_external_token_id,
to_external_token_id,
},
state::{spl_cache, spl_cache_read, wrapped_asset, BoundedVec, SplCacheItem},
token_id::{from_external_token_id, to_external_token_id},
CHAIN_ID,
};
use cosmwasm_std::{
entry_point,
to_binary,
Binary,
CanonicalAddr,
CosmosMsg,
Deps,
DepsMut,
Empty,
Env,
MessageInfo,
QueryRequest,
Response,
StdError,
StdResult,
WasmMsg,
WasmQuery, Order,
entry_point, to_binary, Binary, CanonicalAddr, CosmosMsg, Deps, DepsMut, Empty, Env,
MessageInfo, Order, QueryRequest, Response, StdError, StdResult, WasmMsg, WasmQuery,
};
use crate::{
msg::{
ExecuteMsg,
InstantiateMsg,
MigrateMsg,
QueryMsg,
},
msg::{ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg},
state::{
bridge_contracts,
bridge_contracts_read,
config,
config_read,
wrapped_asset_address,
wrapped_asset_address_read,
wrapped_asset_read,
Action,
ConfigInfo,
RegisterChain,
TokenBridgeMessage,
TransferInfo,
UpgradeContract,
bridge_contracts, bridge_contracts_read, config, config_read, wrapped_asset_address,
wrapped_asset_address_read, wrapped_asset_read, Action, ConfigInfo, RegisterChain,
TokenBridgeMessage, TransferInfo, UpgradeContract,
},
};
use wormhole::{
byte_utils::{
extend_address_to_32,
extend_address_to_32_array,
get_string_from_32,
string_to_array,
extend_address_to_32, extend_address_to_32_array, get_string_from_32, string_to_array,
ByteUtils,
},
error::ContractError,
};
use wormhole::msg::{
ExecuteMsg as WormholeExecuteMsg,
QueryMsg as WormholeQueryMsg,
};
use wormhole::msg::{ExecuteMsg as WormholeExecuteMsg, QueryMsg as WormholeQueryMsg};
use wormhole::state::{
vaa_archive_add,
vaa_archive_check,
GovernancePacket,
ParsedVAA,
};
use wormhole::state::{vaa_archive_add, vaa_archive_check, GovernancePacket, ParsedVAA};
use sha3::{
Digest,
Keccak256,
};
use sha3::{Digest, Keccak256};
type HumanAddr = String;
@ -409,7 +357,10 @@ fn handle_initiate_transfer(
let mut messages: Vec<CosmosMsg> = vec![];
if wrapped_asset_address_read(deps.storage).load(asset_canonical.as_slice()).is_ok() {
if wrapped_asset_address_read(deps.storage)
.load(asset_canonical.as_slice())
.is_ok()
{
// This is a deployed wrapped asset, burn it
messages.push(CosmosMsg::Wasm(WasmMsg::Execute {
contract_addr: asset.clone(),
@ -525,9 +476,7 @@ pub fn query(deps: Deps, _env: Env, msg: QueryMsg) -> StdResult<Binary> {
QueryMsg::WrappedRegistry { chain, address } => {
to_binary(&query_wrapped_registry(deps, chain, address.as_slice())?)
}
QueryMsg::AllWrappedAssets { } => {
to_binary(&query_all_wrapped_assets(deps)?)
}
QueryMsg::AllWrappedAssets {} => to_binary(&query_all_wrapped_assets(deps)?),
}
}
@ -580,7 +529,6 @@ fn query_all_wrapped_assets(deps: Deps) -> StdResult<Vec<String>> {
Ok(result)
}
fn build_asset_id(chain: u16, address: &[u8]) -> Vec<u8> {
let mut asset_id: Vec<u8> = vec![];
asset_id.extend_from_slice(&chain.to_be_bytes());

7
terra/contracts/nft-bridge/src/msg.rs
View File

@ -1,9 +1,6 @@
use cosmwasm_std::Binary;
use schemars::JsonSchema;
use serde::{
Deserialize,
Serialize,
};
use serde::{Deserialize, Serialize};
type HumanAddr = String;
@ -45,7 +42,7 @@ pub struct MigrateMsg {}
#[serde(rename_all = "snake_case")]
pub enum QueryMsg {
WrappedRegistry { chain: u16, address: Binary },
AllWrappedAssets { },
AllWrappedAssets {},
}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]

19
terra/contracts/nft-bridge/src/state.rs
View File

@ -1,24 +1,11 @@
use std::convert::TryInto;
use schemars::JsonSchema;
use serde::{
Deserialize,
Serialize,
};
use serde::{Deserialize, Serialize};
use cosmwasm_std::{
StdError,
StdResult,
Storage,
};
use cosmwasm_std::{StdError, StdResult, Storage};
use cosmwasm_storage::{
bucket,
bucket_read,
singleton,
singleton_read,
Bucket,
ReadonlyBucket,
ReadonlySingleton,
bucket, bucket_read, singleton, singleton_read, Bucket, ReadonlyBucket, ReadonlySingleton,
Singleton,
};

11
terra/contracts/nft-bridge/src/token_id.rs
View File

@ -1,9 +1,5 @@
use bigint::U256;
use cosmwasm_std::{
StdError,
StdResult,
Storage,
};
use cosmwasm_std::{StdError, StdResult, Storage};
use sha3::{
digest::{consts::U32, generic_array::GenericArray},
@ -12,10 +8,7 @@ use sha3::{
use wormhole::byte_utils::ByteUtils;
use crate::{
state::{
token_id_hashes,
token_id_hashes_read,
},
state::{token_id_hashes, token_id_hashes_read},
CHAIN_ID,
};

109
terra/contracts/token-bridge/src/contract.rs
View File

@ -1,117 +1,44 @@
use cw20::{
BalanceResponse,
TokenInfoResponse,
};
use cw20_base::msg::{
ExecuteMsg as TokenMsg,
QueryMsg as TokenQuery,
};
use cw20::{BalanceResponse, TokenInfoResponse};
use cw20_base::msg::{ExecuteMsg as TokenMsg, QueryMsg as TokenQuery};
use cw20_wrapped::msg::{
ExecuteMsg as WrappedMsg,
InitHook,
InstantiateMsg as WrappedInit,
QueryMsg as WrappedQuery,
ExecuteMsg as WrappedMsg, InitHook, InstantiateMsg as WrappedInit, QueryMsg as WrappedQuery,
WrappedAssetInfoResponse,
};
use sha3::{
Digest,
Keccak256,
};
use sha3::{Digest, Keccak256};
use std::{
cmp::{
max,
min,
},
cmp::{max, min},
str::FromStr,
};
use terraswap::asset::{
Asset,
AssetInfo,
};
use terraswap::asset::{Asset, AssetInfo};
use terra_cosmwasm::TerraQuerier;
use wormhole::{
byte_utils::{
extend_address_to_32,
extend_address_to_32_array,
extend_string_to_32,
get_string_from_32,
extend_address_to_32, extend_address_to_32_array, extend_string_to_32, get_string_from_32,
ByteUtils,
},
error::ContractError,
msg::{
ExecuteMsg as WormholeExecuteMsg,
QueryMsg as WormholeQueryMsg,
},
state::{
vaa_archive_add,
vaa_archive_check,
GovernancePacket,
ParsedVAA,
},
msg::{ExecuteMsg as WormholeExecuteMsg, QueryMsg as WormholeQueryMsg},
state::{vaa_archive_add, vaa_archive_check, GovernancePacket, ParsedVAA},
};
use cosmwasm_std::{
coin,
entry_point,
to_binary,
BankMsg,
Binary,
CanonicalAddr,
Coin,
CosmosMsg,
Decimal,
Deps,
DepsMut,
Empty,
Env,
MessageInfo,
Order,
QuerierWrapper,
QueryRequest,
Reply,
Response,
StdError,
StdResult,
SubMsg,
Uint128,
WasmMsg,
WasmQuery,
coin, entry_point, to_binary, BankMsg, Binary, CanonicalAddr, Coin, CosmosMsg, Decimal, Deps,
DepsMut, Empty, Env, MessageInfo, Order, QuerierWrapper, QueryRequest, Reply, Response,
StdError, StdResult, SubMsg, Uint128, WasmMsg, WasmQuery,
};
use crate::{
msg::{
ExecuteMsg,
InstantiateMsg,
MigrateMsg,
QueryMsg,
TransferInfoResponse,
ExecuteMsg, InstantiateMsg, MigrateMsg, QueryMsg, TransferInfoResponse,
WrappedRegistryResponse,
},
state::{
bridge_contracts,
bridge_contracts_read,
bridge_deposit,
config,
config_read,
receive_native,
send_native,
wrapped_asset,
wrapped_asset_address,
wrapped_asset_address_read,
wrapped_asset_read,
wrapped_asset_seq,
wrapped_asset_seq_read,
wrapped_transfer_tmp,
Action,
AssetMeta,
ConfigInfo,
RegisterChain,
TokenBridgeMessage,
TransferInfo,
TransferState,
TransferWithPayloadInfo,
UpgradeContract,
bridge_contracts, bridge_contracts_read, bridge_deposit, config, config_read,
receive_native, send_native, wrapped_asset, wrapped_asset_address,
wrapped_asset_address_read, wrapped_asset_read, wrapped_asset_seq, wrapped_asset_seq_read,
wrapped_transfer_tmp, Action, AssetMeta, ConfigInfo, RegisterChain, TokenBridgeMessage,
TransferInfo, TransferState, TransferWithPayloadInfo, UpgradeContract,
},
};

15
terra/contracts/token-bridge/src/msg.rs
View File

@ -1,16 +1,7 @@
use cosmwasm_std::{
Binary,
Uint128,
};
use cosmwasm_std::{Binary, Uint128};
use schemars::JsonSchema;
use serde::{
Deserialize,
Serialize,
};
use terraswap::asset::{
Asset,
AssetInfo,
};
use serde::{Deserialize, Serialize};
use terraswap::asset::{Asset, AssetInfo};
type HumanAddr = String;

22
terra/contracts/token-bridge/src/state.rs
View File

@ -1,24 +1,9 @@
use schemars::JsonSchema;
use serde::{
Deserialize,
Serialize,
};
use serde::{Deserialize, Serialize};
use cosmwasm_std::{
CanonicalAddr,
StdError,
StdResult,
Storage,
Uint128,
};
use cosmwasm_std::{CanonicalAddr, StdError, StdResult, Storage, Uint128};
use cosmwasm_storage::{
bucket,
bucket_read,
singleton,
singleton_read,
Bucket,
ReadonlyBucket,
ReadonlySingleton,
bucket, bucket_read, singleton, singleton_read, Bucket, ReadonlyBucket, ReadonlySingleton,
Singleton,
};
@ -265,7 +250,6 @@ impl TransferWithPayloadInfo {
sender_address,
payload,
})
}
pub fn serialize(&self) -> Vec<u8> {

59
terra/contracts/token-bridge/src/testing/tests.rs
View File

@ -1,21 +1,10 @@
use cosmwasm_std::{
Binary,
StdResult,
};
use cosmwasm_std::{Binary, StdResult};
use wormhole::state::ParsedVAA;
use crate::{
contract::{
build_asset_id,
build_native_id,
},
state::{
Action,
TokenBridgeMessage,
TransferInfo,
TransferWithPayloadInfo,
},
contract::{build_asset_id, build_native_id},
state::{Action, TokenBridgeMessage, TransferInfo, TransferWithPayloadInfo},
};
#[test]
@ -138,27 +127,26 @@ fn deserialize_transfer_vaa() -> StdResult<()> {
#[test]
fn deserialize_transfer_with_payload_vaa() -> StdResult<()> {
// ┌──────────────────────────────────────────────────────────────────────────────┐
// │ Wormhole VAA v1 │ nonce: 2080370133 │ time: 0 │
// │ guardian set #0 │ #4568529024235897313 │ consistency: 32 │
// ├──────────────────────────────────────────────────────────────────────────────┤
// │ Signature: │
// │ #0: 2565e7ae10421624fd81118855acda893e752aeeef31c13fbfc417591ada... │
// ├──────────────────────────────────────────────────────────────────────────────┤
// │ Emitter: 11111111111111111111111111111115 (Solana) │
// ╞══════════════════════════════════════════════════════════════════════════════╡
// │ Token transfer with payload (aka payload 3) │
// │ Amount: 1.0 │
// │ Token: terra1qqqqqqqqqqqqqqqqqqqqqqqqqp6h2umyswfh6y (Terra) │
// │ Recipient: terra13nkgqrfymug724h8pprpexqj9h629sa3ncw7sh (Terra) │
// │ From: 1399a4e782b935d2bb36b97586d3df8747b07dc66902d807eed0ae99e00ed256 │
// ╞══════════════════════════════════════════════════════════════════════════════╡
// │ Custom payload: │
// │ Length: 30 (0x1e) bytes │
// │ 0000: 41 6c 6c 20 79 6f 75 72 20 62 61 73 65 20 61 72 All your base ar│
// │ 0010: 65 20 62 65 6c 6f 6e 67 20 74 6f 20 75 73 e belong to us │
// └──────────────────────────────────────────────────────────────────────────────┘
// ┌──────────────────────────────────────────────────────────────────────────────┐
// │ Wormhole VAA v1 │ nonce: 2080370133 │ time: 0 │
// │ guardian set #0 │ #4568529024235897313 │ consistency: 32 │
// ├──────────────────────────────────────────────────────────────────────────────┤
// │ Signature: │
// │ #0: 2565e7ae10421624fd81118855acda893e752aeeef31c13fbfc417591ada... │
// ├──────────────────────────────────────────────────────────────────────────────┤
// │ Emitter: 11111111111111111111111111111115 (Solana) │
// ╞══════════════════════════════════════════════════════════════════════════════╡
// │ Token transfer with payload (aka payload 3) │
// │ Amount: 1.0 │
// │ Token: terra1qqqqqqqqqqqqqqqqqqqqqqqqqp6h2umyswfh6y (Terra) │
// │ Recipient: terra13nkgqrfymug724h8pprpexqj9h629sa3ncw7sh (Terra) │
// │ From: 1399a4e782b935d2bb36b97586d3df8747b07dc66902d807eed0ae99e00ed256 │
// ╞══════════════════════════════════════════════════════════════════════════════╡
// │ Custom payload: │
// │ Length: 30 (0x1e) bytes │
// │ 0000: 41 6c 6c 20 79 6f 75 72 20 62 61 73 65 20 61 72 All your base ar│
// │ 0010: 65 20 62 65 6c 6f 6e 67 20 74 6f 20 75 73 e belong to us │
// └──────────────────────────────────────────────────────────────────────────────┘
let signed_vaa = "\
010000000001002565e7ae10421624fd81118855acda893e752aeeef31c13fbf\
@ -221,7 +209,6 @@ fn deserialize_transfer_with_payload_vaa() -> StdResult<()> {
"info.recipient_chain != expected"
);
let transfer_payload = "All your base are belong to us";
let transfer_payload = transfer_payload.as_bytes();
assert_eq!(

64
terra/contracts/wormhole/src/contract.rs
View File

@ -1,75 +1,33 @@
use cosmwasm_std::{
has_coins,
to_binary,
BankMsg,
Binary,
Coin,
CosmosMsg,
Deps,
DepsMut,
Env,
MessageInfo,
Response,
StdError,
StdResult,
Storage,
WasmMsg,
has_coins, to_binary, BankMsg, Binary, Coin, CosmosMsg, Deps, DepsMut, Env, MessageInfo,
Response, StdError, StdResult, Storage, WasmMsg,
};
#[cfg(not(feature = "library"))]
use cosmwasm_std::entry_point;
use crate::{
byte_utils::{
extend_address_to_32,
ByteUtils,
},
byte_utils::{extend_address_to_32, ByteUtils},
error::ContractError,
msg::{
ExecuteMsg,
GetAddressHexResponse,
GetStateResponse,
GuardianSetInfoResponse,
InstantiateMsg,
MigrateMsg,
QueryMsg,
ExecuteMsg, GetAddressHexResponse, GetStateResponse, GuardianSetInfoResponse,
InstantiateMsg, MigrateMsg, QueryMsg,
},
state::{
config,
config_read,
guardian_set_get,
guardian_set_set,
sequence_read,
sequence_set,
vaa_archive_add,
vaa_archive_check,
ConfigInfo,
ContractUpgrade,
GovernancePacket,
GuardianAddress,
GuardianSetInfo,
GuardianSetUpgrade,
ParsedVAA,
SetFee,
TransferFee,
config, config_read, guardian_set_get, guardian_set_set, sequence_read, sequence_set,
vaa_archive_add, vaa_archive_check, ConfigInfo, ContractUpgrade, GovernancePacket,
GuardianAddress, GuardianSetInfo, GuardianSetUpgrade, ParsedVAA, SetFee, TransferFee,
},
};
use k256::{
ecdsa::{
recoverable::{
Id as RecoverableId,
Signature as RecoverableSignature,
},
Signature,
VerifyingKey,
recoverable::{Id as RecoverableId, Signature as RecoverableSignature},
Signature, VerifyingKey,
},
EncodedPoint,
};
use sha3::{
Digest,
Keccak256,
};
use sha3::{Digest, Keccak256};
use generic_array::GenericArray;
use std::convert::TryFrom;

18
terra/contracts/wormhole/src/msg.rs
View File

@ -1,17 +1,8 @@
use cosmwasm_std::{
Binary,
Coin,
};
use cosmwasm_std::{Binary, Coin};
use schemars::JsonSchema;
use serde::{
Deserialize,
Serialize,
};
use serde::{Deserialize, Serialize};
use crate::state::{
GuardianAddress,
GuardianSetInfo,
};
use crate::state::{GuardianAddress, GuardianSetInfo};
type HumanAddr = String;
@ -33,8 +24,7 @@ pub enum ExecuteMsg {
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]
pub struct MigrateMsg {
}
pub struct MigrateMsg {}
#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, JsonSchema)]
#[serde(rename_all = "snake_case")]

43
terra/contracts/wormhole/src/state.rs
View File

@ -1,39 +1,15 @@
use schemars::{
JsonSchema,
};
use serde::{
Deserialize,
Serialize,
};
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use cosmwasm_std::{
Binary,
CanonicalAddr,
Coin,
StdResult,
Storage,
Uint128,
};
use cosmwasm_std::{Binary, CanonicalAddr, Coin, StdResult, Storage, Uint128};
use cosmwasm_storage::{
bucket,
bucket_read,
singleton,
singleton_read,
Bucket,
ReadonlyBucket,
ReadonlySingleton,
bucket, bucket_read, singleton, singleton_read, Bucket, ReadonlyBucket, ReadonlySingleton,
Singleton,
};
use crate::{
byte_utils::ByteUtils,
error::ContractError,
};
use crate::{byte_utils::ByteUtils, error::ContractError};
use sha3::{
Digest,
Keccak256,
};
use sha3::{Digest, Keccak256};
type HumanAddr = String;
@ -299,7 +275,7 @@ impl GovernancePacket {
}
// action 1
pub struct ContractUpgrade {
pub struct ContractUpgrade {
pub new_contract: u64,
}
@ -312,9 +288,7 @@ pub struct GuardianSetUpgrade {
impl ContractUpgrade {
pub fn deserialize(data: &[u8]) -> StdResult<Self> {
let new_contract = data.get_u64(24);
Ok(ContractUpgrade {
new_contract,
})
Ok(ContractUpgrade { new_contract })
}
}
@ -385,4 +359,3 @@ impl TransferFee {
Ok(TransferFee { amount, recipient })
}
}

2
terra/contracts/wormhole/src/testing/mod.rs
View File

@ -1 +1 @@
mod tests;
mod tests;

118
terra/contracts/wormhole/src/testing/tests.rs
View File

@ -1,26 +1,20 @@
use cosmwasm_std::{StdResult, CanonicalAddr};
use cosmwasm_std::{CanonicalAddr, StdResult};
use crate::state::{GuardianAddress, GuardianSetInfo, ParsedVAA};
use crate::byte_utils::ByteUtils;
use crate::state::{GuardianAddress, GuardianSetInfo, ParsedVAA};
#[test]
fn quardian_set_quorum() {
let num_guardians_trials: Vec<usize> = vec![
1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 20, 25, 100,
];
let num_guardians_trials: Vec<usize> = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 20, 25, 100];
let expected_quorums: Vec<usize> = vec![
1, 2, 3, 3, 4, 5, 5, 6, 7, 7, 8, 9, 14, 17, 67,
];
let expected_quorums: Vec<usize> = vec![1, 2, 3, 3, 4, 5, 5, 6, 7, 7, 8, 9, 14, 17, 67];
let make_guardian_set = |n: usize| -> GuardianSetInfo {
let mut addresses = Vec::with_capacity(n);
for _ in 0..n {
addresses.push(
GuardianAddress {
bytes: Vec::new().into(),
}
);
addresses.push(GuardianAddress {
bytes: Vec::new().into(),
});
}
GuardianSetInfo {
addresses,
@ -49,7 +43,10 @@ fn deserialize_round_1() -> StdResult<()> {
assert_eq!(parsed.version, version, "parsed.version != expected");
let guardian_set_index = 9u32;
assert_eq!(parsed.guardian_set_index, guardian_set_index, "parsed.guardian_set_index != expected");
assert_eq!(
parsed.guardian_set_index, guardian_set_index,
"parsed.guardian_set_index != expected"
);
let timestamp = 2837u32;
assert_eq!(parsed.timestamp, timestamp, "parsed.timestamp != expected");
@ -58,29 +55,40 @@ fn deserialize_round_1() -> StdResult<()> {
assert_eq!(parsed.nonce, nonce, "parsed.nonce != expected");
let len_signers = 1u8;
assert_eq!(parsed.len_signers, len_signers, "parsed.len_signers != expected");
assert_eq!(
parsed.len_signers, len_signers,
"parsed.len_signers != expected"
);
let emitter_chain = 2u16;
assert_eq!(parsed.emitter_chain, emitter_chain, "parsed.emitter_chain != expected");
assert_eq!(
parsed.emitter_chain, emitter_chain,
"parsed.emitter_chain != expected"
);
let emitter_address = "0001020304000000000000000000000000000000000000000000000000000000";
let emitter_address = hex::decode(emitter_address).unwrap();
assert_eq!(parsed.emitter_address, emitter_address, "parsed.emitter_address != expected");
assert_eq!(
parsed.emitter_address, emitter_address,
"parsed.emitter_address != expected"
);
let sequence = 10u64;
assert_eq!(parsed.sequence, sequence, "parsed.sequence != expected");
let consistency_level = 2u8;
assert_eq!(parsed.consistency_level, consistency_level, "parsed.consistency_level != expected");
assert_eq!(
parsed.consistency_level, consistency_level,
"parsed.consistency_level != expected"
);
let payload = vec![97u8, 98u8, 99u8, 100u8];
assert_eq!(parsed.payload, payload, "parsed.payload != expected");
let hash = vec![
164u8, 44u8, 82u8, 103u8, 33u8, 170u8, 183u8, 178u8,
188u8, 204u8, 35u8, 53u8, 78u8, 148u8, 160u8, 153u8,
122u8, 252u8, 84u8, 211u8, 26u8, 204u8, 128u8, 215u8,
37u8, 232u8, 222u8, 186u8, 222u8, 186u8, 98u8, 94u8,
164u8, 44u8, 82u8, 103u8, 33u8, 170u8, 183u8, 178u8, 188u8, 204u8, 35u8, 53u8, 78u8, 148u8,
160u8, 153u8, 122u8, 252u8, 84u8, 211u8, 26u8, 204u8, 128u8, 215u8, 37u8, 232u8, 222u8,
186u8, 222u8, 186u8, 98u8, 94u8,
];
assert_eq!(parsed.hash, hash, "parsed.hash != expected");
@ -106,7 +114,10 @@ fn deserialize_round_2() -> StdResult<()> {
assert_eq!(parsed.version, version, "parsed.version != expected");
let guardian_set_index = 0u32;
assert_eq!(parsed.guardian_set_index, guardian_set_index, "parsed.guardian_set_index != expected");
assert_eq!(
parsed.guardian_set_index, guardian_set_index,
"parsed.guardian_set_index != expected"
);
let timestamp = 0u32;
assert_eq!(parsed.timestamp, timestamp, "parsed.timestamp != expected");
@ -115,47 +126,49 @@ fn deserialize_round_2() -> StdResult<()> {
assert_eq!(parsed.nonce, nonce, "parsed.nonce != expected");
let len_signers = 1u8;
assert_eq!(parsed.len_signers, len_signers, "parsed.len_signers != expected");
assert_eq!(
parsed.len_signers, len_signers,
"parsed.len_signers != expected"
);
let emitter_chain = 1u16;
assert_eq!(parsed.emitter_chain, emitter_chain, "parsed.emitter_chain != expected");
assert_eq!(
parsed.emitter_chain, emitter_chain,
"parsed.emitter_chain != expected"
);
let emitter_address = "000000000000000000000000000000000000000000000000000000000000ffff";
let emitter_address = hex::decode(emitter_address).unwrap();
assert_eq!(parsed.emitter_address, emitter_address, "parsed.emitter_address != expected");
assert_eq!(
parsed.emitter_address, emitter_address,
"parsed.emitter_address != expected"
);
let sequence = 0u64;
assert_eq!(parsed.sequence, sequence, "parsed.sequence != expected");
let consistency_level = 0u8;
assert_eq!(parsed.consistency_level, consistency_level, "parsed.consistency_level != expected");
assert_eq!(
parsed.consistency_level, consistency_level,
"parsed.consistency_level != expected"
);
let payload = vec![
1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
0u8, 0u8, 0u8, 0u8, 0u8, 5u8, 245u8, 225u8,
0u8, 1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
0u8, 0u8, 0u8, 0u8, 0u8, 117u8, 117u8, 115u8,
100u8, 0u8, 3u8, 0u8, 0u8, 0u8, 0u8, 0u8,
0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 247u8,
247u8, 221u8, 232u8, 72u8, 231u8, 69u8, 10u8, 2u8,
156u8, 208u8, 169u8, 189u8, 155u8, 218u8, 228u8, 181u8,
20u8, 125u8, 179u8, 0u8, 3u8, 0u8, 0u8, 0u8,
0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
0u8, 0u8, 15u8, 66u8, 64u8,
1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 5u8, 245u8, 225u8, 0u8, 1u8, 0u8,
0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 117u8, 117u8, 115u8, 100u8, 0u8, 3u8, 0u8, 0u8,
0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 247u8, 247u8, 221u8, 232u8, 72u8, 231u8,
69u8, 10u8, 2u8, 156u8, 208u8, 169u8, 189u8, 155u8, 218u8, 228u8, 181u8, 20u8, 125u8,
179u8, 0u8, 3u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 15u8, 66u8, 64u8,
];
assert_eq!(parsed.payload, payload, "parsed.payload != expected");
let hash = vec![
114u8, 108u8, 111u8, 78u8, 204u8, 83u8, 150u8, 170u8,
240u8, 15u8, 193u8, 176u8, 165u8, 87u8, 174u8, 230u8,
94u8, 222u8, 106u8, 206u8, 179u8, 203u8, 193u8, 187u8,
1u8, 148u8, 17u8, 40u8, 248u8, 214u8, 147u8, 68u8,
114u8, 108u8, 111u8, 78u8, 204u8, 83u8, 150u8, 170u8, 240u8, 15u8, 193u8, 176u8, 165u8,
87u8, 174u8, 230u8, 94u8, 222u8, 106u8, 206u8, 179u8, 203u8, 193u8, 187u8, 1u8, 148u8,
17u8, 40u8, 248u8, 214u8, 147u8, 68u8,
];
assert_eq!(parsed.hash, hash, "parsed.hash != expected");
@ -164,8 +177,8 @@ fn deserialize_round_2() -> StdResult<()> {
#[test]
fn get_address_test() -> StdResult<()> {
let zeros_32: &[u8] = &[0;32];
let zeros_20: &[u8] = &[0;20];
let zeros_32: &[u8] = &[0; 32];
let zeros_20: &[u8] = &[0; 20];
assert_eq!(zeros_32.get_address(0), CanonicalAddr::from(zeros_20));
Ok(())
}
@ -174,15 +187,14 @@ fn get_address_test() -> StdResult<()> {
#[should_panic]
fn get_address_test_panic() -> () {
// panics because of junk in first 12 bytes
let ones_32: &[u8] = &[1;32];
let ones_32: &[u8] = &[1; 32];
ones_32.get_address(0);
}
#[test]
#[should_panic]
fn get_address_test_panic_2() -> () {
// panics because not enough bytes (need at least 32)
let short_address: &[u8] = &[0;31];
let short_address: &[u8] = &[0; 31];
short_address.get_address(0);
}

25
terra/contracts/wormhole/tests/integration.rs
View File

@ -1,29 +1,14 @@
use cosmwasm_std::{
from_slice,
testing::{
mock_dependencies,
mock_env,
mock_info,
MockApi,
MockQuerier,
MockStorage,
},
Coin,
OwnedDeps,
Response,
Storage,
testing::{mock_dependencies, mock_env, mock_info, MockApi, MockQuerier, MockStorage},
Coin, OwnedDeps, Response, Storage,
};
use cosmwasm_storage::to_length_prefixed;
use wormhole::{
contract::instantiate,
msg::InstantiateMsg,
state::{
ConfigInfo,
GuardianAddress,
GuardianSetInfo,
CONFIG_KEY,
},
state::{ConfigInfo, GuardianAddress, GuardianSetInfo, CONFIG_KEY},
};
use hex;
@ -33,9 +18,7 @@ static GOV_ADDR: &[u8] = b"GOVERNANCE_ADDRESS";
fn get_config_info<S: Storage>(storage: &S) -> ConfigInfo {
let key = to_length_prefixed(CONFIG_KEY);
let data = storage
.get(&key)
.expect("data should exist");
let data = storage.get(&key).expect("data should exist");
from_slice(&data).expect("invalid data")
}

8
terra/rustfmt.toml
View File

@ -1,11 +1,13 @@
# Unstable options are listed but commented out. We should re-enable them once they are stabilized.
# Merge similar crates together to avoid multiple use statements.
imports_granularity = "Crate"
# imports_granularity = "Crate"
# Consistency in formatting makes tool based searching/editing better.
empty_item_single_line = false
# empty_item_single_line = false
# Easier editing when arbitrary mixed use statements do not collapse.
imports_layout = "Vertical"
# imports_layout = "Vertical"
# Default rustfmt formatting of match arms with branches is awful.
match_arm_leading_pipes = "Preserve"