From b7fd282f650eaf2661fcf171642fbf1b0efbe8bd Mon Sep 17 00:00:00 2001 From: 0xh3rman <119309671+0xh3rman@users.noreply.github.com> Date: Mon, 4 May 2026 22:37:02 +0900 Subject: [PATCH] refactor chain address validation --- crates/gem_algorand/Cargo.toml | 6 +- crates/gem_algorand/src/address.rs | 22 +++-- crates/gem_algorand/src/lib.rs | 4 +- crates/gem_aptos/src/{signer => }/address.rs | 36 +++++++- crates/gem_aptos/src/lib.rs | 2 + .../src/models/signer_transaction.rs | 2 +- crates/gem_aptos/src/move/parser.rs | 2 +- crates/gem_aptos/src/move/types.rs | 2 +- crates/gem_aptos/src/move/values.rs | 2 +- crates/gem_aptos/src/signer/chain_signer.rs | 4 +- crates/gem_aptos/src/signer/mod.rs | 2 - crates/gem_aptos/src/signer/transaction.rs | 3 +- crates/gem_cosmos/src/address.rs | 86 ++++++++++++++++++ crates/gem_cosmos/src/converter.rs | 34 ------- crates/gem_cosmos/src/lib.rs | 4 +- crates/gem_evm/src/address.rs | 44 ++++++++-- crates/gem_evm/src/lib.rs | 2 +- crates/gem_near/Cargo.toml | 4 +- crates/gem_near/src/address.rs | 38 ++++++++ crates/gem_near/src/lib.rs | 2 + crates/gem_solana/src/address.rs | 23 +++++ crates/gem_solana/src/lib.rs | 6 +- crates/gem_solana/src/pubkey.rs | 17 +++- crates/gem_stellar/src/address.rs | 22 +++-- crates/gem_stellar/src/lib.rs | 2 +- crates/gem_sui/src/address.rs | 39 ++++++++ crates/gem_sui/src/lib.rs | 2 + crates/gem_ton/src/address.rs | 6 ++ crates/gem_ton/src/lib.rs | 2 +- crates/gem_tron/src/address/mod.rs | 72 ++++++++++++--- crates/gem_tron/src/lib.rs | 1 + crates/pricer/src/price_alert_client.rs | 5 +- crates/primitives/src/chain_address.rs | 8 ++ crates/primitives/src/chain_cosmos.rs | 8 +- crates/swapper/src/squid/provider.rs | 4 +- gemstone/src/address.rs | 88 +++++++++++++++++++ gemstone/src/lib.rs | 1 + 37 files changed, 503 insertions(+), 104 deletions(-) rename crates/gem_aptos/src/{signer => }/address.rs (55%) create mode 100644 crates/gem_cosmos/src/address.rs delete mode 100644 crates/gem_cosmos/src/converter.rs create mode 100644 crates/gem_near/src/address.rs create mode 100644 crates/gem_solana/src/address.rs create mode 100644 crates/gem_sui/src/address.rs create mode 100644 gemstone/src/address.rs diff --git a/crates/gem_algorand/Cargo.toml b/crates/gem_algorand/Cargo.toml index f72ef3f0a..2425523f9 100644 --- a/crates/gem_algorand/Cargo.toml +++ b/crates/gem_algorand/Cargo.toml @@ -6,7 +6,7 @@ edition = { workspace = true } [features] default = [] rpc = ["dep:chrono", "dep:chain_traits", "dep:gem_client"] -signer = ["dep:gem_hash", "dep:hex", "dep:num-traits", "dep:signer"] +signer = ["dep:hex", "dep:num-traits"] reqwest = ["gem_client/reqwest"] chain_integration_tests = ["rpc", "reqwest", "settings/testkit"] @@ -23,9 +23,9 @@ chrono = { workspace = true, optional = true } primitives = { path = "../primitives" } chain_traits = { path = "../chain_traits", optional = true } gem_client = { path = "../gem_client", optional = true } -gem_hash = { path = "../gem_hash", optional = true } +gem_hash = { path = "../gem_hash" } hex = { workspace = true, optional = true } -signer = { path = "../signer", optional = true } +signer = { path = "../signer" } [dev-dependencies] tokio = { workspace = true, features = ["macros", "rt"] } diff --git a/crates/gem_algorand/src/address.rs b/crates/gem_algorand/src/address.rs index a6b3fdfc0..31845313a 100644 --- a/crates/gem_algorand/src/address.rs +++ b/crates/gem_algorand/src/address.rs @@ -34,6 +34,10 @@ impl Address for AlgorandAddress { } } +pub fn validate_address(address: &str) -> bool { + AlgorandAddress::is_valid(address) +} + impl AlgorandAddress { fn checksum(bytes: &[u8; 32]) -> [u8; ADDRESS_CHECKSUM_LENGTH] { let digest = sha512_256(bytes); @@ -53,15 +57,19 @@ impl fmt::Display for AlgorandAddress { mod tests { use super::*; + const VALID_ADDRESS: &str = "QKDS2YGDHDFZFAAGA4HAF3AJIKW5ZN46P66QDR3ELCXKKJUJTPJSXVHNQU"; + #[test] fn test_algorand_address() { - assert!(AlgorandAddress::is_valid("QKDS2YGDHDFZFAAGA4HAF3AJIKW5ZN46P66QDR3ELCXKKJUJTPJSXVHNQU")); - assert!(!AlgorandAddress::is_valid("")); - assert!(!AlgorandAddress::is_valid("invalid")); - assert!(!AlgorandAddress::is_valid("QKDS2YGDHDFZFAAGA4HAF3AJIKW5ZN46P66QDR3ELCXKKJUJTPJSXVHNQX")); + let parsed = AlgorandAddress::from_str(VALID_ADDRESS).unwrap(); + + assert!(validate_address(VALID_ADDRESS)); + assert_eq!(parsed.to_string(), VALID_ADDRESS); + assert_eq!(parsed.as_bytes().len(), 32); - let addr = AlgorandAddress::from_str("QKDS2YGDHDFZFAAGA4HAF3AJIKW5ZN46P66QDR3ELCXKKJUJTPJSXVHNQU").unwrap(); - assert_eq!(addr.to_string(), "QKDS2YGDHDFZFAAGA4HAF3AJIKW5ZN46P66QDR3ELCXKKJUJTPJSXVHNQU"); - assert_eq!(addr.as_bytes().len(), 32); + assert!(!validate_address("")); + assert!(!validate_address("invalid")); + // wrong checksum (last char flipped) + assert!(!validate_address("QKDS2YGDHDFZFAAGA4HAF3AJIKW5ZN46P66QDR3ELCXKKJUJTPJSXVHNQX")); } } diff --git a/crates/gem_algorand/src/lib.rs b/crates/gem_algorand/src/lib.rs index 9abe40872..4cd2d70ea 100644 --- a/crates/gem_algorand/src/lib.rs +++ b/crates/gem_algorand/src/lib.rs @@ -4,15 +4,13 @@ pub mod rpc; #[cfg(feature = "rpc")] pub mod provider; -#[cfg(feature = "signer")] pub mod address; pub mod constants; pub mod models; #[cfg(feature = "signer")] pub mod signer; -#[cfg(feature = "signer")] -pub use address::AlgorandAddress; +pub use address::{AlgorandAddress, validate_address}; #[cfg(feature = "rpc")] pub use rpc::client::AlgorandClient; #[cfg(feature = "signer")] diff --git a/crates/gem_aptos/src/signer/address.rs b/crates/gem_aptos/src/address.rs similarity index 55% rename from crates/gem_aptos/src/signer/address.rs rename to crates/gem_aptos/src/address.rs index b967226aa..db43f6e92 100644 --- a/crates/gem_aptos/src/signer/address.rs +++ b/crates/gem_aptos/src/address.rs @@ -1,4 +1,4 @@ -use primitives::{SignerError, decode_hex}; +use primitives::{Address as AddressTrait, SignerError, decode_hex}; use serde::{Deserialize, Serialize}; use std::fmt; use std::str::FromStr; @@ -39,6 +39,24 @@ impl FromStr for AccountAddress { } } +impl AddressTrait for AccountAddress { + fn try_parse(address: &str) -> Option { + Self::from_hex(address).ok() + } + + fn as_bytes(&self) -> &[u8] { + &self.0 + } + + fn encode(&self) -> String { + self.to_string() + } +} + +pub fn validate_address(address: &str) -> bool { + AccountAddress::is_valid(address) +} + impl fmt::Display for AccountAddress { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { write!(f, "0x{}", ::hex::encode(self.0)) @@ -49,9 +67,19 @@ impl fmt::Display for AccountAddress { mod tests { use super::*; + const VALID_ADDRESS: &str = "0x6467997d9c3a5bc9f714e17a168984595ce9bec7350645713a1fe7983a7f5fcc"; + #[test] - fn parse_address_short_hex() { - let address = AccountAddress::from_hex("0x1").unwrap(); - assert_eq!(address.to_string(), format!("0x{}", "00".repeat(31) + "01")); + fn test_aptos_address() { + let parsed = AccountAddress::from_hex(VALID_ADDRESS).unwrap(); + + assert!(validate_address(VALID_ADDRESS)); + assert_eq!(parsed.to_string(), VALID_ADDRESS); + assert_eq!(parsed.as_bytes().len(), 32); + assert!(!validate_address("invalid")); + + // short hex is left-padded to 32 bytes (Aptos framework address convention) + let short = AccountAddress::from_hex("0x1").unwrap(); + assert_eq!(short.to_string(), format!("0x{}", "00".repeat(31) + "01")); } } diff --git a/crates/gem_aptos/src/lib.rs b/crates/gem_aptos/src/lib.rs index 0f29967d5..b1e904280 100644 --- a/crates/gem_aptos/src/lib.rs +++ b/crates/gem_aptos/src/lib.rs @@ -1,5 +1,7 @@ pub mod constants; pub use constants::*; +pub mod address; +pub use address::{AccountAddress, validate_address}; pub mod models; pub use models::*; pub mod r#move; diff --git a/crates/gem_aptos/src/models/signer_transaction.rs b/crates/gem_aptos/src/models/signer_transaction.rs index abf014962..11ed2cef7 100644 --- a/crates/gem_aptos/src/models/signer_transaction.rs +++ b/crates/gem_aptos/src/models/signer_transaction.rs @@ -1,5 +1,5 @@ +use crate::AccountAddress; use crate::r#move::{EntryFunction, TypeTag}; -use crate::signer::AccountAddress; use serde::{Deserialize, Serialize}; #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] diff --git a/crates/gem_aptos/src/move/parser.rs b/crates/gem_aptos/src/move/parser.rs index 5a8c5d46e..43058ce5f 100644 --- a/crates/gem_aptos/src/move/parser.rs +++ b/crates/gem_aptos/src/move/parser.rs @@ -1,4 +1,4 @@ -use crate::signer::AccountAddress; +use crate::AccountAddress; use num_bigint::BigUint; use num_traits::ToPrimitive; use primitives::{SignerError, decode_hex}; diff --git a/crates/gem_aptos/src/move/types.rs b/crates/gem_aptos/src/move/types.rs index ce568fedd..9fb3aca9e 100644 --- a/crates/gem_aptos/src/move/types.rs +++ b/crates/gem_aptos/src/move/types.rs @@ -1,4 +1,4 @@ -use crate::signer::AccountAddress; +use crate::AccountAddress; use serde::{Deserialize, Serialize}; #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)] diff --git a/crates/gem_aptos/src/move/values.rs b/crates/gem_aptos/src/move/values.rs index 316efeb5c..3a04fab85 100644 --- a/crates/gem_aptos/src/move/values.rs +++ b/crates/gem_aptos/src/move/values.rs @@ -1,4 +1,4 @@ -use crate::signer::AccountAddress; +use crate::AccountAddress; use serde::Serialize; use serde::ser::{SerializeSeq, Serializer}; diff --git a/crates/gem_aptos/src/signer/chain_signer.rs b/crates/gem_aptos/src/signer/chain_signer.rs index 8bb076779..d8cf842d9 100644 --- a/crates/gem_aptos/src/signer/chain_signer.rs +++ b/crates/gem_aptos/src/signer/chain_signer.rs @@ -5,9 +5,9 @@ use std::str::from_utf8; use super::abi::{PANORA_ROUTER_ENTRY_PARAMS, PANORA_ROUTER_FUNCTION, PANORA_ROUTER_MODULE}; use super::{ - AccountAddress, EntryFunction, EntryFunctionPayload, build_raw_transaction, build_submit_transaction_bcs, expiration_timestamp_secs, sign_message as sign_aptos_message, - sign_raw_transaction, + EntryFunction, EntryFunctionPayload, build_raw_transaction, build_submit_transaction_bcs, expiration_timestamp_secs, sign_message as sign_aptos_message, sign_raw_transaction, }; +use crate::AccountAddress; use crate::token_id::is_fungible_asset_token_id; use crate::{APTOS_TRANSFER_FUNCTION, DELEGATION_POOL_ADD_STAKE_FUNCTION, DELEGATION_POOL_UNLOCK_FUNCTION, DELEGATION_POOL_WITHDRAW_FUNCTION, ENTRY_FUNCTION_PAYLOAD_TYPE}; diff --git a/crates/gem_aptos/src/signer/mod.rs b/crates/gem_aptos/src/signer/mod.rs index fac912b0b..ddaee779a 100644 --- a/crates/gem_aptos/src/signer/mod.rs +++ b/crates/gem_aptos/src/signer/mod.rs @@ -1,12 +1,10 @@ mod abi; -mod address; mod chain_signer; mod payload; mod transaction; pub use crate::models::{DeprecatedPayload, RawTransaction, Script, TransactionPayloadBCS}; pub use crate::r#move::{EntryFunction, ModuleId, StructTag, TypeTag}; -pub use address::AccountAddress; pub use chain_signer::AptosChainSigner; pub use payload::EntryFunctionPayload; pub use transaction::{build_raw_transaction, build_submit_transaction_bcs, expiration_timestamp_secs, sign_message, sign_raw_transaction}; diff --git a/crates/gem_aptos/src/signer/transaction.rs b/crates/gem_aptos/src/signer/transaction.rs index ecf7b3690..6108de3b6 100644 --- a/crates/gem_aptos/src/signer/transaction.rs +++ b/crates/gem_aptos/src/signer/transaction.rs @@ -5,7 +5,8 @@ use primitives::SignerError; use signer::Ed25519KeyPair; use std::time::SystemTime; -use super::{AccountAddress, EntryFunction}; +use super::EntryFunction; +use crate::AccountAddress; const RAW_TRANSACTION_SALT: &[u8] = b"APTOS::RawTransaction"; const MESSAGE_SALT: &[u8] = b"APTOS::Message"; diff --git a/crates/gem_cosmos/src/address.rs b/crates/gem_cosmos/src/address.rs new file mode 100644 index 000000000..7a2bbb5d7 --- /dev/null +++ b/crates/gem_cosmos/src/address.rs @@ -0,0 +1,86 @@ +use bech32::hrp::Hrp; +use primitives::chain_cosmos::CosmosChain; +use primitives::{Address as AddressTrait, Chain}; +use std::error::Error; + +pub struct CosmosAddress { + hrp: String, + bytes: Vec, +} + +impl CosmosAddress { + fn has_chain_hrp(address: &str, chain: Chain) -> bool { + let Some(cosmos_chain) = CosmosChain::from_chain(chain) else { + return false; + }; + Self::try_parse(address).is_some_and(|address| address.hrp == cosmos_chain.hrp()) + } + + pub fn is_valid_for_chain(address: &str, chain: Chain) -> bool { + Self::has_chain_hrp(address, chain) + } + + pub fn convert(address: &str, hrp: &str) -> Result> { + let (_, decoded) = bech32::decode(address)?; + let new_hrp = Hrp::parse(hrp)?; + let encoded = bech32::encode::(new_hrp, decoded.as_slice())?; + + Ok(encoded) + } +} + +impl AddressTrait for CosmosAddress { + fn try_parse(address: &str) -> Option { + let (hrp, bytes) = bech32::decode(address).ok()?; + let hrp = hrp.as_str().to_string(); + (CosmosChain::all().any(|chain| chain.hrp() == hrp) && bytes.len() == 20).then_some(Self { hrp, bytes }) + } + + fn as_bytes(&self) -> &[u8] { + &self.bytes + } + + fn encode(&self) -> String { + let hrp = Hrp::parse(&self.hrp).expect("valid Cosmos address hrp"); + bech32::encode::(hrp, &self.bytes).expect("valid Cosmos address bytes") + } +} + +pub fn validate_address(address: &str, chain: Chain) -> bool { + CosmosAddress::is_valid_for_chain(address, chain) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_cosmos_address_convert() { + let cosmos_address = "cosmos1h3laqcrmul79zwtw6j63ncsl0adfj07wgupylj"; + let expected = "osmosis1h3laqcrmul79zwtw6j63ncsl0adfj07wm8vf00"; + + let output_address = CosmosAddress::convert(cosmos_address, "osmosis").unwrap(); + assert_eq!(expected, output_address); + } + + #[test] + fn test_invalid_cosmos_address() { + // invalid checksum + let cosmos_address = "cosmos1h3laqcrmul79zwtw6j63ncsl0adfj07wgu"; + + let result = CosmosAddress::convert(cosmos_address, "osmosis"); + assert!(result.is_err()); + } + + #[test] + fn test_cosmos_address() { + let address = "cosmos1h3laqcrmul79zwtw6j63ncsl0adfj07wgupylj"; + let parsed = CosmosAddress::try_parse(address).unwrap(); + + assert!(validate_address(address, Chain::Cosmos)); + assert_eq!(parsed.as_bytes().len(), 20); + assert_eq!(parsed.encode(), address); + assert!(!validate_address(address, Chain::Osmosis)); + assert!(!validate_address("invalid", Chain::Cosmos)); + } +} diff --git a/crates/gem_cosmos/src/converter.rs b/crates/gem_cosmos/src/converter.rs deleted file mode 100644 index 34cab0f32..000000000 --- a/crates/gem_cosmos/src/converter.rs +++ /dev/null @@ -1,34 +0,0 @@ -use std::error::Error; -/// This function simply decodes the bech32 address and encodes it with a different hrp. -/// The caller is responsible for validating the data and hrp, more specifically, in the case of -/// Cosmos, the encoded data is sha256 hash of the public key. -pub fn convert_cosmos_address(address: &str, hrp: &str) -> Result> { - let (_, decoded) = bech32::decode(address)?; - let new_hrp = bech32::hrp::Hrp::parse(hrp)?; - let encoded = bech32::encode::(new_hrp, decoded.as_slice())?; - - Ok(encoded) -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_cosmos_address_convert() { - let cosmos_address = "cosmos1h3laqcrmul79zwtw6j63ncsl0adfj07wgupylj"; - let expected = "osmosis1h3laqcrmul79zwtw6j63ncsl0adfj07wm8vf00"; - - let output_address = convert_cosmos_address(cosmos_address, "osmosis").unwrap(); - assert_eq!(expected, output_address); - } - - #[test] - fn test_invalid_cosmos_address() { - // invalid checksum - let cosmos_address = "cosmos1h3laqcrmul79zwtw6j63ncsl0adfj07wgu"; - - let result = convert_cosmos_address(cosmos_address, "osmosis"); - assert!(result.is_err()); - } -} diff --git a/crates/gem_cosmos/src/lib.rs b/crates/gem_cosmos/src/lib.rs index d634a9cc3..0c6c41471 100644 --- a/crates/gem_cosmos/src/lib.rs +++ b/crates/gem_cosmos/src/lib.rs @@ -1,5 +1,5 @@ +pub mod address; pub mod constants; -pub mod converter; #[cfg(feature = "rpc")] pub mod rpc; @@ -11,3 +11,5 @@ pub mod provider; pub mod signer; pub mod models; + +pub use address::validate_address; diff --git a/crates/gem_evm/src/address.rs b/crates/gem_evm/src/address.rs index 10902db19..f221e5028 100644 --- a/crates/gem_evm/src/address.rs +++ b/crates/gem_evm/src/address.rs @@ -1,4 +1,5 @@ use alloy_primitives::{Address, AddressError}; +use primitives::Address as AddressTrait; use std::str::FromStr; pub fn ethereum_address_checksum(address: &str) -> Result { @@ -9,24 +10,55 @@ pub fn ethereum_address_from_topic(topic: &str) -> Option { ethereum_address_checksum(topic.trim_start_matches("0x000000000000000000000000")).ok() } +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct EthereumAddress(Address); + +impl AddressTrait for EthereumAddress { + fn try_parse(address: &str) -> Option { + Address::from_str(address).ok().map(Self) + } + + fn as_bytes(&self) -> &[u8] { + self.0.as_ref() + } + + fn encode(&self) -> String { + self.0.to_checksum(None) + } +} + +pub fn validate_address(address: &str) -> bool { + EthereumAddress::is_valid(address) +} + #[cfg(test)] mod tests { use super::*; + pub(crate) const VALID_ADDRESS: &str = "0x5615E8AB93b9d695b6d4d6545f7792aA59e1069a"; + #[test] - fn test_ethereum_address_checksum() { - let expected = "0x5615E8AB93b9d695b6d4d6545f7792aA59e1069a"; - assert_eq!(ethereum_address_checksum("0x5615e8ab93b9d695b6d4d6545f7792aa59e1069a").unwrap(), expected); - assert_eq!(ethereum_address_checksum("5615e8ab93b9d695b6d4d6545f7792aa59e1069a").unwrap(), expected); - assert!(ethereum_address_checksum("0X5615e8ab93b9d695b6d4d6545f7792aa59e1069a").is_err()); + fn test_ethereum_address() { + let lowercase = VALID_ADDRESS.to_lowercase(); + let uppercase_prefix = lowercase.replacen("0x", "0X", 1); + + assert_eq!(ethereum_address_checksum(&lowercase).unwrap(), VALID_ADDRESS); + assert_eq!(ethereum_address_checksum(lowercase.trim_start_matches("0x")).unwrap(), VALID_ADDRESS); + assert!(ethereum_address_checksum(&uppercase_prefix).is_err()); assert!(ethereum_address_checksum("invalid").is_err()); + + let parsed = EthereumAddress::try_parse(&lowercase).unwrap(); + assert!(validate_address(&lowercase)); + assert_eq!(parsed.as_bytes().len(), 20); + assert_eq!(parsed.encode(), VALID_ADDRESS); + assert!(!validate_address(&uppercase_prefix)); } #[test] fn test_ethereum_address_from_topic() { assert_eq!( ethereum_address_from_topic("0x0000000000000000000000005615e8ab93b9d695b6d4d6545f7792aa59e1069a"), - Some("0x5615E8AB93b9d695b6d4d6545f7792aA59e1069a".to_string()) + Some(VALID_ADDRESS.to_string()) ); } } diff --git a/crates/gem_evm/src/lib.rs b/crates/gem_evm/src/lib.rs index a4f492482..c5358261a 100644 --- a/crates/gem_evm/src/lib.rs +++ b/crates/gem_evm/src/lib.rs @@ -43,7 +43,7 @@ pub mod testkit; pub const ETHEREUM_MESSAGE_PREFIX: &str = "\x19Ethereum Signed Message:\n"; -pub use address::ethereum_address_checksum; +pub use address::{ethereum_address_checksum, validate_address}; pub use eip712::{EIP712Domain, EIP712Field, EIP712Type, EIP712TypedValue, eip712_domain_types}; pub fn parse_u256(value: &str) -> Option { diff --git a/crates/gem_near/Cargo.toml b/crates/gem_near/Cargo.toml index fca419b8f..f3529fbcf 100644 --- a/crates/gem_near/Cargo.toml +++ b/crates/gem_near/Cargo.toml @@ -18,7 +18,7 @@ chain_traits = { path = "../chain_traits", optional = true } async-trait = { workspace = true, optional = true } chrono = { workspace = true, features = ["serde"], optional = true } bs58 = { workspace = true, optional = true } -hex = { workspace = true, optional = true } +hex = { workspace = true } futures = { workspace = true, optional = true } gem_encoding = { path = "../gem_encoding", optional = true } gem_hash = { path = "../gem_hash", optional = true } @@ -32,7 +32,7 @@ hex = { workspace = true } [features] default = [] -rpc = ["dep:gem_jsonrpc", "dep:gem_client", "dep:chain_traits", "dep:async-trait", "dep:chrono", "dep:bs58", "dep:hex", "dep:futures"] +rpc = ["dep:gem_jsonrpc", "dep:gem_client", "dep:chain_traits", "dep:async-trait", "dep:chrono", "dep:bs58", "dep:futures"] signer = ["dep:gem_encoding", "dep:bs58", "dep:gem_hash", "dep:signer"] reqwest = ["gem_client/reqwest", "gem_jsonrpc/reqwest"] chain_integration_tests = ["rpc", "reqwest", "settings/testkit"] diff --git a/crates/gem_near/src/address.rs b/crates/gem_near/src/address.rs new file mode 100644 index 000000000..e0214228d --- /dev/null +++ b/crates/gem_near/src/address.rs @@ -0,0 +1,38 @@ +use primitives::Address as AddressTrait; + +pub struct NearAddress([u8; 32]); + +impl AddressTrait for NearAddress { + fn try_parse(address: &str) -> Option { + hex::decode(address).ok()?.try_into().ok().map(Self) + } + + fn as_bytes(&self) -> &[u8] { + &self.0 + } + + fn encode(&self) -> String { + hex::encode(self.0) + } +} + +pub fn validate_address(address: &str) -> bool { + NearAddress::is_valid(address) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_near_address() { + let address = "e3ac115fd911eb985ffd884ee60302c84dc94df52127ccde8d6fb97ad6d22945"; + let parsed = NearAddress::try_parse(address).unwrap(); + + assert!(validate_address(address)); + assert_eq!(parsed.as_bytes().len(), 32); + assert_eq!(parsed.encode(), address); + assert!(!validate_address("invalid")); + assert!(!validate_address("e3ac115fd911eb985ffd884ee60302c84dc94df52127ccde8d6fb97ad6d229")); + } +} diff --git a/crates/gem_near/src/lib.rs b/crates/gem_near/src/lib.rs index b09fb1c79..ea535f4d8 100644 --- a/crates/gem_near/src/lib.rs +++ b/crates/gem_near/src/lib.rs @@ -1,3 +1,5 @@ +pub mod address; +pub use address::validate_address; #[cfg(feature = "rpc")] pub mod rpc; diff --git a/crates/gem_solana/src/address.rs b/crates/gem_solana/src/address.rs new file mode 100644 index 000000000..fda5552cb --- /dev/null +++ b/crates/gem_solana/src/address.rs @@ -0,0 +1,23 @@ +use primitives::Address as AddressTrait; + +use crate::pubkey::Pubkey; + +pub fn validate_address(address: &str) -> bool { + Pubkey::is_valid(address) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_solana_address() { + let address = "GvhwZwtV32kYUXUw965CUM3KGPdtBsDwPVpi92brY5R2"; + let parsed = Pubkey::try_parse(address).unwrap(); + + assert!(validate_address(address)); + assert_eq!(parsed.as_bytes().len(), 32); + assert_eq!(parsed.encode(), address); + assert!(!validate_address("invalid")); + } +} diff --git a/crates/gem_solana/src/lib.rs b/crates/gem_solana/src/lib.rs index e96668194..38e9e3729 100644 --- a/crates/gem_solana/src/lib.rs +++ b/crates/gem_solana/src/lib.rs @@ -1,3 +1,4 @@ +pub mod address; pub mod constants; pub mod hash; pub mod jsonrpc; @@ -17,6 +18,7 @@ pub mod transaction; #[cfg(feature = "signer")] pub mod signer; +pub use address::validate_address; pub use jsonrpc::SolanaRpc; pub use transaction::{decode_transaction, try_decode_transaction}; @@ -78,8 +80,8 @@ pub fn get_token_program_id_by_address(address: &str) -> Result Option { match &asset_id.token_id { - Some(token_id) => Pubkey::from_str(token_id).ok(), - None => Pubkey::from_str(WSOL_TOKEN_ADDRESS).ok(), + Some(token_id) => ::from_str(token_id).ok(), + None => ::from_str(WSOL_TOKEN_ADDRESS).ok(), } } diff --git a/crates/gem_solana/src/pubkey.rs b/crates/gem_solana/src/pubkey.rs index 87db95d8d..99c92c754 100644 --- a/crates/gem_solana/src/pubkey.rs +++ b/crates/gem_solana/src/pubkey.rs @@ -3,6 +3,7 @@ use { borsh::{BorshDeserialize, BorshSerialize}, + primitives::Address as AddressTrait, std::{convert::TryFrom, fmt, mem, str::FromStr}, }; @@ -70,7 +71,7 @@ pub struct Pubkey(pub(crate) [u8; 32]); impl TryFrom<&str> for Pubkey { type Error = ParsePubkeyError; fn try_from(s: &str) -> Result { - Pubkey::from_str(s) + ::from_str(s) } } @@ -99,6 +100,20 @@ impl FromStr for Pubkey { } } +impl AddressTrait for Pubkey { + fn try_parse(address: &str) -> Option { + ::from_str(address).ok() + } + + fn as_bytes(&self) -> &[u8] { + self.as_ref() + } + + fn encode(&self) -> String { + self.to_string() + } +} + impl From<[u8; 32]> for Pubkey { #[inline] fn from(from: [u8; 32]) -> Self { diff --git a/crates/gem_stellar/src/address.rs b/crates/gem_stellar/src/address.rs index e534cdb7b..afa5d2345 100644 --- a/crates/gem_stellar/src/address.rs +++ b/crates/gem_stellar/src/address.rs @@ -43,6 +43,10 @@ impl Address for StellarAddress { } } +pub fn validate_address(address: &str) -> bool { + StellarAddress::is_valid(address) +} + impl StellarAddress { fn crc16_xmodem(data: &[u8]) -> u16 { let mut crc: u16 = 0; @@ -66,15 +70,19 @@ impl fmt::Display for StellarAddress { mod tests { use super::*; + const VALID_ADDRESS: &str = "GAE2SZV4VLGBAPRYRFV2VY7YYLYGYIP5I7OU7BSP6DJT7GAZ35OKFDYI"; + #[test] fn test_stellar_address() { - assert!(StellarAddress::is_valid("GAE2SZV4VLGBAPRYRFV2VY7YYLYGYIP5I7OU7BSP6DJT7GAZ35OKFDYI")); - assert!(!StellarAddress::is_valid("")); - assert!(!StellarAddress::is_valid("invalid")); - assert!(!StellarAddress::is_valid("GAE2SZV4VLGBAPRYRFV2VY7YYLYGYIP5I7OU7BSP6DJT7GAZ35OKFDYZ")); + let parsed = StellarAddress::from_str(VALID_ADDRESS).unwrap(); + + assert!(validate_address(VALID_ADDRESS)); + assert_eq!(parsed.to_string(), VALID_ADDRESS); + assert_eq!(parsed.as_bytes().len(), 32); - let addr = StellarAddress::from_str("GAE2SZV4VLGBAPRYRFV2VY7YYLYGYIP5I7OU7BSP6DJT7GAZ35OKFDYI").unwrap(); - assert_eq!(addr.to_string(), "GAE2SZV4VLGBAPRYRFV2VY7YYLYGYIP5I7OU7BSP6DJT7GAZ35OKFDYI"); - assert_eq!(addr.as_bytes().len(), 32); + assert!(!validate_address("")); + assert!(!validate_address("invalid")); + // wrong checksum (last char flipped) + assert!(!validate_address("GAE2SZV4VLGBAPRYRFV2VY7YYLYGYIP5I7OU7BSP6DJT7GAZ35OKFDYZ")); } } diff --git a/crates/gem_stellar/src/lib.rs b/crates/gem_stellar/src/lib.rs index a7018d4cc..c8e18e874 100644 --- a/crates/gem_stellar/src/lib.rs +++ b/crates/gem_stellar/src/lib.rs @@ -12,6 +12,6 @@ pub mod models; pub mod signer; #[cfg(feature = "signer")] -pub use address::StellarAddress; +pub use address::{StellarAddress, validate_address}; #[cfg(feature = "signer")] pub use signer::*; diff --git a/crates/gem_sui/src/address.rs b/crates/gem_sui/src/address.rs new file mode 100644 index 000000000..f81955c19 --- /dev/null +++ b/crates/gem_sui/src/address.rs @@ -0,0 +1,39 @@ +use primitives::Address as AddressTrait; +use std::str::FromStr; +use sui_types::Address; + +pub struct SuiAddress(Address); + +impl AddressTrait for SuiAddress { + fn try_parse(address: &str) -> Option { + Address::from_str(address).ok().map(Self) + } + + fn as_bytes(&self) -> &[u8] { + self.0.as_ref() + } + + fn encode(&self) -> String { + self.0.to_string() + } +} + +pub fn validate_address(address: &str) -> bool { + SuiAddress::is_valid(address) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_sui_address() { + let address = "0xada112cfb90b44ba889cc5d39ac2bf46281e4a91f7919c693bcd9b8323e81ed2"; + let parsed = SuiAddress::try_parse(address).unwrap(); + + assert!(validate_address(address)); + assert_eq!(parsed.as_bytes().len(), 32); + assert_eq!(parsed.encode(), address); + assert!(!validate_address("invalid")); + } +} diff --git a/crates/gem_sui/src/lib.rs b/crates/gem_sui/src/lib.rs index d95a70b04..a006c08ef 100644 --- a/crates/gem_sui/src/lib.rs +++ b/crates/gem_sui/src/lib.rs @@ -1,3 +1,5 @@ +pub mod address; +pub use address::validate_address; #[cfg(feature = "rpc")] pub mod rpc; #[cfg(feature = "rpc")] diff --git a/crates/gem_ton/src/address.rs b/crates/gem_ton/src/address.rs index ef8d56b35..7dfbc2ebb 100644 --- a/crates/gem_ton/src/address.rs +++ b/crates/gem_ton/src/address.rs @@ -123,6 +123,10 @@ impl AddressTrait for Address { } } +pub fn validate_address(address: &str) -> bool { + Address::is_valid(address) +} + pub fn hex_to_base64_address(hex_str: &str) -> Option { Address::try_parse_hex(hex_str).map(|address| address.encode()) } @@ -146,6 +150,7 @@ mod tests { assert_eq!(
::from_str(encoded).unwrap(), address); assert_eq!(Address::try_parse(encoded), Some(address)); assert!(Address::is_valid(encoded)); + assert!(validate_address(encoded)); assert_eq!(address.as_bytes().len(), RAW_ADDRESS_LEN); assert_eq!(address.workchain(), 0); assert_eq!(hex::encode(address.hash_part()), "8e874b7ad9bbebbfc48810b8939c98f50580246f19982040dbcb253c4c3daf78"); @@ -166,6 +171,7 @@ mod tests { assert!(Address::try_parse_hex("0:invalid_hex").is_none()); assert!(Address::try_parse_hex("0:abcd1234").is_none()); assert!(!Address::is_valid("invalid")); + assert!(!validate_address("invalid")); assert!(Address::try_parse("invalid").is_none()); } diff --git a/crates/gem_ton/src/lib.rs b/crates/gem_ton/src/lib.rs index f5b0564c2..b492b266b 100644 --- a/crates/gem_ton/src/lib.rs +++ b/crates/gem_ton/src/lib.rs @@ -14,5 +14,5 @@ pub mod address; pub mod constants; pub mod models; -pub use address::Address; +pub use address::{Address, validate_address}; pub use primitives::AddressError; diff --git a/crates/gem_tron/src/address/mod.rs b/crates/gem_tron/src/address/mod.rs index 2e9302654..e200ab9d5 100644 --- a/crates/gem_tron/src/address/mod.rs +++ b/crates/gem_tron/src/address/mod.rs @@ -1,12 +1,13 @@ pub mod serializer; use alloy_primitives::Address; +use primitives::Address as AddressTrait; const ADDRESS_PREFIX: u8 = 0x41; const ADDRESS_LEN: usize = 20; const PREFIXED_ADDRESS_LEN: usize = ADDRESS_LEN + 1; -pub struct TronAddress; +pub struct TronAddress([u8; PREFIXED_ADDRESS_LEN]); impl TronAddress { pub fn from_hex(hex_value: &str) -> Option { @@ -21,19 +22,39 @@ impl TronAddress { pub fn to_addr(address: &str) -> Option
{ let decoded = bs58::decode(address).with_check(None).into_vec().ok()?; - match decoded.len() { - PREFIXED_ADDRESS_LEN if decoded[0] == ADDRESS_PREFIX => { - let mut addr = [0u8; ADDRESS_LEN]; - addr.copy_from_slice(&decoded[1..PREFIXED_ADDRESS_LEN]); - Some(Address::from(addr)) - } - ADDRESS_LEN => { - let mut addr = [0u8; ADDRESS_LEN]; - addr.copy_from_slice(&decoded[..ADDRESS_LEN]); - Some(Address::from(addr)) - } - _ => None, - } + let payload = match decoded.as_slice() { + [ADDRESS_PREFIX, payload @ ..] => payload, + payload => payload, + }; + + (payload.len() == ADDRESS_LEN).then(|| Address::from_slice(payload)) + } +} + +impl AddressTrait for TronAddress { + fn try_parse(address: &str) -> Option { + Self::to_addr(address).map(Self::from) + } + + fn as_bytes(&self) -> &[u8] { + &self.0 + } + + fn encode(&self) -> String { + bs58::encode(self.0).with_check().into_string() + } +} + +pub fn validate_address(address: &str) -> bool { + TronAddress::is_valid(address) +} + +impl From
for TronAddress { + fn from(address: Address) -> Self { + let mut bytes = [0u8; PREFIXED_ADDRESS_LEN]; + bytes[0] = ADDRESS_PREFIX; + bytes[1..].copy_from_slice(address.as_ref()); + Self(bytes) } } @@ -66,4 +87,27 @@ mod tests { let expected = Address::from_slice(&hex::decode("357a7401a0f0c2d4a44a1881a0c622f15d986291").unwrap()); assert_eq!(TronAddress::to_addr("TEqyWRKCzREYC2bK2fc3j7pp8XjAa6tJK1").unwrap(), expected); } + + #[test] + fn test_try_parse_normalizes_prefixed_and_unprefixed_payloads() { + let prefixed = "TEqyWRKCzREYC2bK2fc3j7pp8XjAa6tJK1"; + let payload = hex::decode("357a7401a0f0c2d4a44a1881a0c622f15d986291").unwrap(); + let unprefixed = bs58::encode(&payload).with_check().into_string(); + let expected = hex::decode("41357a7401a0f0c2d4a44a1881a0c622f15d986291").unwrap(); + + assert!(validate_address(prefixed)); + assert!(validate_address(&unprefixed)); + assert_eq!(TronAddress::try_parse(prefixed).unwrap().as_bytes(), expected); + assert_eq!(TronAddress::try_parse(&unprefixed).unwrap().as_bytes(), expected); + } + + #[test] + fn test_try_parse_rejects_wrong_prefix() { + let mut decoded = hex::decode("41357a7401a0f0c2d4a44a1881a0c622f15d986291").unwrap(); + decoded[0] = 0x42; + let address = bs58::encode(decoded).with_check().into_string(); + + assert!(TronAddress::try_parse(&address).is_none()); + assert!(!validate_address(&address)); + } } diff --git a/crates/gem_tron/src/lib.rs b/crates/gem_tron/src/lib.rs index b4c0f51f9..7ac9b1911 100644 --- a/crates/gem_tron/src/lib.rs +++ b/crates/gem_tron/src/lib.rs @@ -1,6 +1,7 @@ pub mod address; pub mod signer; +pub use address::validate_address; pub use signer::TronChainSigner; #[cfg(feature = "rpc")] diff --git a/crates/pricer/src/price_alert_client.rs b/crates/pricer/src/price_alert_client.rs index 06b613af0..8887722c9 100644 --- a/crates/pricer/src/price_alert_client.rs +++ b/crates/pricer/src/price_alert_client.rs @@ -227,10 +227,7 @@ impl PriceAlertClient { }; let data = PushNotification { - data: serde_json::to_value(&PushNotificationAsset { - asset_id: alert.asset.id.clone(), - }) - .ok(), + data: serde_json::to_value(&PushNotificationAsset { asset_id: alert.asset.id.clone() }).ok(), notification_type: PushNotificationTypes::PriceAlert, }; diff --git a/crates/primitives/src/chain_address.rs b/crates/primitives/src/chain_address.rs index b9dc63a0e..cc0f06ec5 100644 --- a/crates/primitives/src/chain_address.rs +++ b/crates/primitives/src/chain_address.rs @@ -16,6 +16,14 @@ impl ChainAddress { pub fn new(chain: Chain, address: String) -> Self { Self { chain, address } } + + pub fn address(&self) -> &str { + &self.address + } + + pub fn chain(&self) -> Chain { + self.chain + } } impl fmt::Display for ChainAddress { diff --git a/crates/primitives/src/chain_cosmos.rs b/crates/primitives/src/chain_cosmos.rs index 438adef86..3bec3be24 100644 --- a/crates/primitives/src/chain_cosmos.rs +++ b/crates/primitives/src/chain_cosmos.rs @@ -1,12 +1,12 @@ use std::str::FromStr; use serde::{Deserialize, Serialize}; -use strum::{AsRefStr, EnumIter, EnumString}; +use strum::{AsRefStr, EnumIter, EnumString, IntoEnumIterator}; use typeshare::typeshare; use crate::Chain; -#[derive(Copy, Clone, Debug, Serialize, Deserialize, EnumString, AsRefStr, PartialEq)] +#[derive(Copy, Clone, Debug, Serialize, Deserialize, EnumString, EnumIter, AsRefStr, PartialEq)] #[typeshare(swift = "Equatable, CaseIterable, Sendable")] #[serde(rename_all = "lowercase")] #[strum(serialize_all = "lowercase")] @@ -21,6 +21,10 @@ pub enum CosmosChain { } impl CosmosChain { + pub fn all() -> impl Iterator { + Self::iter() + } + pub fn from_chain(chain: Chain) -> Option { CosmosChain::from_str(chain.as_ref()).ok() } diff --git a/crates/swapper/src/squid/provider.rs b/crates/swapper/src/squid/provider.rs index 5084756fe..41e44f768 100644 --- a/crates/swapper/src/squid/provider.rs +++ b/crates/swapper/src/squid/provider.rs @@ -2,7 +2,7 @@ use std::sync::Arc; use async_trait::async_trait; use gem_client::Client; -use gem_cosmos::{converter::convert_cosmos_address, models::message::send_msg_json}; +use gem_cosmos::{address::CosmosAddress, models::message::send_msg_json}; use primitives::{AssetId, Chain, chain_cosmos::CosmosChain, swap::SwapQuoteDataType}; use super::{SQUID_COSMOS_MULTICALL, SUPPORTED_CHAINS, client::SquidClient, model::*}; @@ -61,7 +61,7 @@ where if base.is_empty() { return None; } - convert_cosmos_address(base, cosmos_chain.hrp()).ok() + CosmosAddress::convert(base, cosmos_chain.hrp()).ok() } } } diff --git a/gemstone/src/address.rs b/gemstone/src/address.rs new file mode 100644 index 000000000..d70e013d4 --- /dev/null +++ b/gemstone/src/address.rs @@ -0,0 +1,88 @@ +use crate::GemstoneError; +use gem_bitcoin::models::address::Address as BitcoinAddress; +use primitives::{Chain, ChainAddress, ChainType}; +use std::sync::Arc; + +#[derive(uniffi::Object)] +pub struct GemChainAddress { + inner: ChainAddress, +} + +#[uniffi::export] +impl GemChainAddress { + #[uniffi::constructor] + pub fn new(address: String, chain: Chain) -> Result, GemstoneError> { + if !validate_address(&address, chain) { + return Err(GemstoneError::AnyError { + msg: format!("Invalid address for {chain}"), + }); + } + Ok(Arc::new(Self { + inner: ChainAddress::new(chain, address), + })) + } + + pub fn address(&self) -> String { + self.inner.address().to_string() + } +} + +#[uniffi::export] +pub fn validate_address(address: &str, chain: Chain) -> bool { + match chain.chain_type() { + ChainType::Ethereum | ChainType::HyperCore => gem_evm::validate_address(address), + ChainType::Solana => gem_solana::validate_address(address), + ChainType::Cosmos => gem_cosmos::validate_address(address, chain), + ChainType::Ton => gem_ton::validate_address(address), + ChainType::Tron => gem_tron::validate_address(address), + ChainType::Aptos => gem_aptos::validate_address(address), + ChainType::Sui => gem_sui::validate_address(address), + ChainType::Near => gem_near::validate_address(address), + ChainType::Stellar => gem_stellar::validate_address(address), + ChainType::Algorand => gem_algorand::validate_address(address), + ChainType::Bitcoin | ChainType::Xrp | ChainType::Polkadot | ChainType::Cardano => false, + } +} + +#[uniffi::export] +pub fn short_address(address: &str, chain: Chain) -> String { + match chain { + Chain::BitcoinCash => BitcoinAddress::new(address, Chain::BitcoinCash).short().to_string(), + _ => address.to_string(), + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_chain_address_validation() { + assert!(validate_address("0x5615e8ab93b9d695b6d4d6545f7792aa59e1069a", Chain::Ethereum)); + assert!(!validate_address("0X5615e8ab93b9d695b6d4d6545f7792aa59e1069a", Chain::Ethereum)); + assert!(validate_address("cosmos1h3laqcrmul79zwtw6j63ncsl0adfj07wgupylj", Chain::Cosmos)); + assert!(validate_address("GvhwZwtV32kYUXUw965CUM3KGPdtBsDwPVpi92brY5R2", Chain::Solana)); + } + + #[test] + fn test_new_returns_err_for_invalid() { + assert!(GemChainAddress::new("invalid".to_string(), Chain::Ethereum).is_err()); + assert!(GemChainAddress::new("0x5615e8ab93b9d695b6d4d6545f7792aa59e1069a".to_string(), Chain::Ethereum).is_ok()); + } + + #[test] + fn test_short_address_bitcoincash() { + let prefixed = "bitcoincash:qpzl3jxkzgvfd9flnd26leud5duv795fnv7vuaha70"; + let stripped = "qpzl3jxkzgvfd9flnd26leud5duv795fnv7vuaha70"; + + for input in [prefixed, stripped] { + assert_eq!(short_address(input, Chain::BitcoinCash), stripped); + } + } + + #[test] + fn test_short_address_passthrough() { + let eth = "0x5615E8AB93b9d695b6d4d6545f7792aA59e1069a"; + assert_eq!(short_address(eth, Chain::Ethereum), eth); + } +} diff --git a/gemstone/src/lib.rs b/gemstone/src/lib.rs index 292831ee3..be402020e 100644 --- a/gemstone/src/lib.rs +++ b/gemstone/src/lib.rs @@ -1,3 +1,4 @@ +pub mod address; pub mod address_formatter; pub mod alien; pub mod api_client;