From c85982dbc58af26abb42c2daaf41c2117f878929 Mon Sep 17 00:00:00 2001 From: bitgobot Date: Thu, 24 Sep 2026 22:03:27 +0000 Subject: [PATCH] fix(dot): bind SS58 destinations to trusted chain material Validate recipient, payee, proxy, and self-transfer address prefixes before producing call data. Propagate an explicit generic-prefix policy through material and parser contexts, and cover mismatch regressions. Wallet approvals must not accept addresses labeled for another network then silently sign their AccountId in the selected chain. Ticket: WCN-1892 Session-Id: 4408559a-0119-4900-9471-eb853265da1b Task-Id: 3702a6ad-95cc-435a-8085-81d167f61534 --- packages/wasm-dot/js/builder.ts | 11 +- packages/wasm-dot/js/parser.ts | 2 + packages/wasm-dot/js/transaction.ts | 4 + packages/wasm-dot/js/types.ts | 23 +++- packages/wasm-dot/src/builder/calls.rs | 96 +++++++++++---- packages/wasm-dot/src/builder/mod.rs | 5 +- packages/wasm-dot/src/error.rs | 13 +- packages/wasm-dot/src/parser.rs | 10 +- packages/wasm-dot/src/types.rs | 88 ++++++++++++-- packages/wasm-dot/src/wasm/transaction.rs | 8 +- packages/wasm-dot/test/builder.ts | 140 +++++++++++++++++++++- 11 files changed, 354 insertions(+), 46 deletions(-) diff --git a/packages/wasm-dot/js/builder.ts b/packages/wasm-dot/js/builder.ts index 8a40ea4f6f7..a41d94ea067 100644 --- a/packages/wasm-dot/js/builder.ts +++ b/packages/wasm-dot/js/builder.ts @@ -15,7 +15,15 @@ import type { TransactionIntent, BuildContext } from "./types.js"; * * The intent describes *what* to do (payment, stake, etc.) and the context * provides *how* to build it (sender, nonce, material, validity). - * Multi-call intents are batched automatically. + * Multi-call intents are batched automatically. Destinations must have the + * SS58 prefix of context.material.chainName (Polkadot 0, Kusama 2, Westend 42). + * Other chains must supply material.ss58AddressPolicy.prefix. Generic prefix 42 + * is only accepted on another chain with allowGeneric: true; because calls + * encode AccountId32 without a prefix, parseTransaction will display its + * canonical chain-form address. The caller must show and obtain approval for + * that canonical address before using allowGeneric. + * A wrong-domain destination throws an Error with code "WrongNetwork", + * actualPrefix, and expectedPrefix. * * @param intent - Business intent (payment, stake, unstake, claim, etc.) * @param context - Build context (sender, nonce, material, validity, referenceBlock) @@ -26,6 +34,7 @@ import type { TransactionIntent, BuildContext } from "./types.js"; * ```typescript * import { buildTransaction } from '@bitgo/wasm-dot'; * + * // These prefix-42 examples assume Westend material in context. * // Payment * const tx = buildTransaction( * { type: 'payment', to: '5FHneW46...', amount: 1000000000000n }, diff --git a/packages/wasm-dot/js/parser.ts b/packages/wasm-dot/js/parser.ts index 07c5966a450..d4341b9ce34 100644 --- a/packages/wasm-dot/js/parser.ts +++ b/packages/wasm-dot/js/parser.ts @@ -66,6 +66,8 @@ function createParseContext(ctx: ParseContext): ParseContextJs { ctx.material.specVersion, ctx.material.txVersion, ctx.material.metadata, + ctx.material.ss58AddressPolicy?.prefix, + ctx.material.ss58AddressPolicy?.allowGeneric, ); return new ParseContextJs(material, ctx.sender ?? null); } diff --git a/packages/wasm-dot/js/transaction.ts b/packages/wasm-dot/js/transaction.ts index db6dfdb15f1..d29ecb918df 100644 --- a/packages/wasm-dot/js/transaction.ts +++ b/packages/wasm-dot/js/transaction.ts @@ -144,6 +144,8 @@ export class DotTransaction { material.specVersion, material.txVersion, material.metadata, + material.ss58AddressPolicy?.prefix, + material.ss58AddressPolicy?.allowGeneric, ); const validityJs = new ValidityJs(validity.firstValid, validity.maxDuration); this._wasm.setContext(materialJs, validityJs, referenceBlock); @@ -219,6 +221,8 @@ function createContext(material: Material): ParseContextJs { material.specVersion, material.txVersion, material.metadata, + material.ss58AddressPolicy?.prefix, + material.ss58AddressPolicy?.allowGeneric, ); return new ParseContextJs(m, null); } diff --git a/packages/wasm-dot/js/types.ts b/packages/wasm-dot/js/types.ts index 149b093413a..b51436ee87e 100644 --- a/packages/wasm-dot/js/types.ts +++ b/packages/wasm-dot/js/types.ts @@ -37,6 +37,20 @@ export interface Material { * SCALE decoding. */ metadata: string; + /** Required for chains outside the built-in Polkadot/Kusama/Westend mapping. + * For known chains, prefix must match the chain's canonical format. + */ + ss58AddressPolicy?: Ss58AddressPolicy; +} + +/** Accepted SS58 formats for addresses used by the transaction builder. */ +export interface Ss58AddressPolicy { + /** The canonical chain prefix, in the SS58 range 0..16383. */ + prefix: number; + /** Explicitly accept generic (42) inputs; they parse back in the chain format. + * Approve the canonical chain-form address before submitting such an intent. + */ + allowGeneric?: boolean; } /** @@ -221,16 +235,13 @@ export interface ParsedTransaction { } /** - * SS58 address format prefixes. - * Using a numeric union type rather than an enum so that callers can pass - * the raw SS58 prefix number directly without a cast. + * SS58 address format prefix (0..16383). Custom chains can use their + * verified numeric prefix without a cast. */ -export type AddressFormat = 0 | 2 | 42; +export type AddressFormat = number; /** * Named constants for common SS58 address formats. - * All existing call sites using AddressFormat.Polkadot / .Kusama / .Substrate - * continue to work unchanged. */ export const AddressFormat = { /** Polkadot mainnet (prefix 0, addresses start with '1') */ diff --git a/packages/wasm-dot/src/builder/calls.rs b/packages/wasm-dot/src/builder/calls.rs index 3e438fc77ce..c5cb8c3f3f7 100644 --- a/packages/wasm-dot/src/builder/calls.rs +++ b/packages/wasm-dot/src/builder/calls.rs @@ -8,6 +8,7 @@ use crate::address::decode_ss58; use crate::builder::types::{intent_to_calls, CallIntent, StakePayee, TransactionIntent}; use crate::error::WasmDotError; +use crate::types::Ss58AddressPolicy; use subxt_core::{ ext::scale_value::{Composite, Value}, metadata::Metadata, @@ -22,6 +23,7 @@ pub fn encode_intent( intent: &TransactionIntent, sender: &str, metadata: &Metadata, + policy: Ss58AddressPolicy, ) -> Result, WasmDotError> { let calls = intent_to_calls(intent, sender)?; @@ -29,13 +31,17 @@ pub fn encode_intent( 0 => Err(WasmDotError::InvalidInput( "Intent produced no calls".to_string(), )), - 1 => encode_call(&calls[0], metadata), - _ => encode_batch(&calls, metadata), + 1 => encode_call(&calls[0], metadata, policy), + _ => encode_batch(&calls, metadata, policy), } } /// Encode a single call-level intent to call data bytes. -fn encode_call(call: &CallIntent, metadata: &Metadata) -> Result, WasmDotError> { +fn encode_call( + call: &CallIntent, + metadata: &Metadata, + policy: Ss58AddressPolicy, +) -> Result, WasmDotError> { let payload = match call { CallIntent::Transfer { to, @@ -47,10 +53,10 @@ fn encode_call(call: &CallIntent, metadata: &Metadata) -> Result, WasmDo } else { "transfer_allow_death" }; - balances(method, to, *amount)? + balances(method, to, *amount, policy)? } - CallIntent::TransferAll { to, keep_alive } => transfer_all(to, *keep_alive)?, - CallIntent::Bond { amount, payee } => staking_bond(*amount, payee)?, + CallIntent::TransferAll { to, keep_alive } => transfer_all(to, *keep_alive, policy)?, + CallIntent::Bond { amount, payee } => staking_bond(*amount, payee, policy)?, CallIntent::BondExtra { amount } => staking_bond_extra(*amount), CallIntent::Unbond { amount } => staking_unbond(*amount), CallIntent::WithdrawUnbonded { slashing_spans } => { @@ -61,12 +67,12 @@ fn encode_call(call: &CallIntent, metadata: &Metadata) -> Result, WasmDo delegate, proxy_type, delay, - } => proxy_add(delegate, proxy_type, *delay)?, + } => proxy_add(delegate, proxy_type, *delay, policy)?, CallIntent::RemoveProxy { delegate, proxy_type, delay, - } => proxy_remove(delegate, proxy_type, *delay)?, + } => proxy_remove(delegate, proxy_type, *delay, policy)?, }; payload @@ -82,12 +88,13 @@ fn balances( method: &str, to: &str, amount: u64, + policy: Ss58AddressPolicy, ) -> Result { Ok(dynamic( "Balances", method, named([ - ("dest", multi_address(to)?), + ("dest", multi_address(to, policy)?), ("value", Value::u128(amount as u128)), ]), )) @@ -96,12 +103,13 @@ fn balances( fn transfer_all( to: &str, keep_alive: bool, + policy: Ss58AddressPolicy, ) -> Result { Ok(dynamic( "Balances", "transfer_all", named([ - ("dest", multi_address(to)?), + ("dest", multi_address(to, policy)?), ("keep_alive", Value::bool(keep_alive)), ]), )) @@ -114,13 +122,14 @@ fn transfer_all( fn staking_bond( amount: u64, payee: &StakePayee, + policy: Ss58AddressPolicy, ) -> Result { let payee_value = match payee { StakePayee::Staked => Value::unnamed_variant("Staked", []), StakePayee::Stash => Value::unnamed_variant("Stash", []), StakePayee::Controller => Value::unnamed_variant("Controller", []), StakePayee::Account { address } => { - Value::unnamed_variant("Account", [account_id(address)?]) + Value::unnamed_variant("Account", [account_id(address, policy)?]) } }; @@ -173,12 +182,13 @@ fn proxy_add( delegate: &str, proxy_type: &str, delay: u32, + policy: Ss58AddressPolicy, ) -> Result { Ok(dynamic( "Proxy", "add_proxy", named([ - ("delegate", multi_address(delegate)?), + ("delegate", multi_address(delegate, policy)?), ("proxy_type", Value::unnamed_variant(proxy_type, [])), ("delay", Value::u128(delay as u128)), ]), @@ -189,12 +199,13 @@ fn proxy_remove( delegate: &str, proxy_type: &str, delay: u32, + policy: Ss58AddressPolicy, ) -> Result { Ok(dynamic( "Proxy", "remove_proxy", named([ - ("delegate", multi_address(delegate)?), + ("delegate", multi_address(delegate, policy)?), ("proxy_type", Value::unnamed_variant(proxy_type, [])), ("delay", Value::u128(delay as u128)), ]), @@ -206,12 +217,16 @@ fn proxy_remove( // ============================================================================= /// Encode multiple calls as a batchAll (atomic batch). -fn encode_batch(calls: &[CallIntent], metadata: &Metadata) -> Result, WasmDotError> { +fn encode_batch( + calls: &[CallIntent], + metadata: &Metadata, + policy: Ss58AddressPolicy, +) -> Result, WasmDotError> { use parity_scale_codec::{Compact, Encode}; let encoded_calls: Result, _> = calls .iter() - .map(|call| encode_call(call, metadata)) + .map(|call| encode_call(call, metadata, policy)) .collect(); let encoded_calls = encoded_calls?; @@ -255,13 +270,19 @@ fn named(fields: [(&str, Value<()>); N]) -> Composite<()> { } /// Convert SS58 address to MultiAddress::Id value -fn multi_address(address: &str) -> Result, WasmDotError> { - Ok(Value::unnamed_variant("Id", [account_id(address)?])) +fn multi_address(address: &str, policy: Ss58AddressPolicy) -> Result, WasmDotError> { + Ok(Value::unnamed_variant("Id", [account_id(address, policy)?])) } /// Convert SS58 address to AccountId32 bytes value -fn account_id(address: &str) -> Result, WasmDotError> { - let (pubkey, _) = decode_ss58(address)?; +fn account_id(address: &str, policy: Ss58AddressPolicy) -> Result, WasmDotError> { + let (pubkey, prefix) = decode_ss58(address)?; + if prefix != policy.prefix && !(policy.allow_generic && prefix == 42) { + return Err(WasmDotError::WrongNetwork { + actual: prefix, + expected: policy.prefix, + }); + } let bytes: [u8; 32] = pubkey.try_into().map_err(|v: Vec| { WasmDotError::InvalidInput(format!( "Invalid pubkey length: expected 32, got {}", @@ -289,9 +310,38 @@ mod tests { } #[test] - fn test_account_id() { - // Valid SS58 address - let result = account_id("5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty"); - assert!(result.is_ok()); + fn test_account_id_network_binding() { + let pubkey = [7u8; 32]; + let polkadot = crate::address::encode_ss58(&pubkey, 0).unwrap(); + let kusama = crate::address::encode_ss58(&pubkey, 2).unwrap(); + let generic = crate::address::encode_ss58(&pubkey, 42).unwrap(); + + for (expected, accepted) in [(0, &polkadot), (2, &kusama), (42, &generic)] { + let policy = Ss58AddressPolicy { prefix: expected, allow_generic: false }; + assert!(account_id(accepted, policy).is_ok()); + for (actual, address) in [(0, &polkadot), (2, &kusama), (42, &generic)] { + if actual != expected { + assert!(matches!( + account_id(address, policy), + Err(WasmDotError::WrongNetwork { actual: found, expected: wanted }) + if found == actual && wanted == expected + )); + } + } + } + + let allow_generic = Ss58AddressPolicy { prefix: 0, allow_generic: true }; + assert!(account_id(&generic, allow_generic).is_ok()); + assert!(matches!( + account_id(&kusama, allow_generic), + Err(WasmDotError::WrongNetwork { actual: 2, expected: 0 }) + )); + + let mut malformed = generic.into_bytes(); + malformed[0] = b'!'; + assert!(matches!( + account_id(std::str::from_utf8(&malformed).unwrap(), allow_generic), + Err(WasmDotError::InvalidAddress(_)) + )); } } diff --git a/packages/wasm-dot/src/builder/mod.rs b/packages/wasm-dot/src/builder/mod.rs index 0d92300030a..6d01e679962 100644 --- a/packages/wasm-dot/src/builder/mod.rs +++ b/packages/wasm-dot/src/builder/mod.rs @@ -22,11 +22,12 @@ pub fn build_transaction( intent: TransactionIntent, context: BuildContext, ) -> Result { - // Decode metadata once + // Resolve the address domain before any destination becomes AccountId32. + let address_policy = context.material.address_policy()?; let metadata = decode_metadata(&context.material.metadata)?; // Compose intent into calls and encode (batching if needed) - let call_data = encode_intent(&intent, &context.sender, &metadata)?; + let call_data = encode_intent(&intent, &context.sender, &metadata, address_policy)?; // Calculate era from validity let era = compute_era(&context.validity); diff --git a/packages/wasm-dot/src/error.rs b/packages/wasm-dot/src/error.rs index 3a029083171..957de9c87e2 100644 --- a/packages/wasm-dot/src/error.rs +++ b/packages/wasm-dot/src/error.rs @@ -8,6 +8,8 @@ use wasm_bindgen::prelude::*; pub enum WasmDotError { /// Invalid SS58 address InvalidAddress(String), + /// Valid SS58 address from a disallowed network + WrongNetwork { actual: u16, expected: u16 }, /// Invalid transaction format InvalidTransaction(String), /// Invalid signature @@ -28,6 +30,9 @@ impl fmt::Display for WasmDotError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { WasmDotError::InvalidAddress(s) => write!(f, "Invalid address: {}", s), + WasmDotError::WrongNetwork { actual, expected } => { + write!(f, "Wrong SS58 network: prefix {} (expected {})", actual, expected) + }, WasmDotError::InvalidTransaction(s) => write!(f, "Invalid transaction: {}", s), WasmDotError::InvalidSignature(s) => write!(f, "Invalid signature: {}", s), WasmDotError::ScaleDecodeError(s) => write!(f, "SCALE decode error: {}", s), @@ -59,7 +64,13 @@ impl From for WasmDotError { // REQUIRED: Converts to JS Error with stack trace impl From for JsValue { fn from(err: WasmDotError) -> Self { - js_sys::Error::new(&err.to_string()).into() + let error: JsValue = js_sys::Error::new(&err.to_string()).into(); + if let WasmDotError::WrongNetwork { actual, expected } = err { + let _ = js_sys::Reflect::set(&error, &"code".into(), &"WrongNetwork".into()); + let _ = js_sys::Reflect::set(&error, &"actualPrefix".into(), &JsValue::from_f64(actual as f64)); + let _ = js_sys::Reflect::set(&error, &"expectedPrefix".into(), &JsValue::from_f64(expected as f64)); + } + error } } diff --git a/packages/wasm-dot/src/parser.rs b/packages/wasm-dot/src/parser.rs index 802ce8645de..5e2be143318 100644 --- a/packages/wasm-dot/src/parser.rs +++ b/packages/wasm-dot/src/parser.rs @@ -8,7 +8,7 @@ use crate::address::encode_ss58; use crate::error::WasmDotError; use crate::transaction::Transaction; -use crate::types::{AddressFormat, Era, ParseContext}; +use crate::types::{Era, ParseContext}; use serde::{Deserialize, Serialize}; /// Maximum nesting depth for batch/proxy recursive parsing. @@ -69,8 +69,9 @@ pub fn parse_transaction( // This avoids cloning the entire context (which contains megabytes of metadata hex). let prefix = context .as_ref() - .map(|ctx| AddressFormat::from_chain_name(&ctx.material.chain_name).prefix()) - .unwrap_or(42); // Default to Substrate generic + .map(|ctx| ctx.material.address_policy().map(|policy| policy.prefix)) + .transpose()? + .unwrap_or(42); // No context: default to Substrate generic let metadata = context .as_ref() @@ -90,7 +91,8 @@ pub fn parse_from_transaction( context: Option<&ParseContext>, ) -> Result { let prefix = context - .map(|ctx| AddressFormat::from_chain_name(&ctx.material.chain_name).prefix()) + .map(|ctx| ctx.material.address_policy().map(|policy| policy.prefix)) + .transpose()? .unwrap_or(42); let metadata = context.and_then(|ctx| decode_metadata(&ctx.material.metadata).ok()); diff --git a/packages/wasm-dot/src/types.rs b/packages/wasm-dot/src/types.rs index caac6bfaf53..0df15e16177 100644 --- a/packages/wasm-dot/src/types.rs +++ b/packages/wasm-dot/src/types.rs @@ -1,5 +1,6 @@ //! Shared types for DOT transactions +use crate::error::WasmDotError; use serde::{Deserialize, Serialize}; /// Chain material metadata required for transaction encoding/decoding @@ -24,6 +25,53 @@ pub struct Material { /// APIs. The hex-to-bytes decode happens once internally (in `decode_metadata`) /// right before SCALE decoding. pub metadata: String, + /// Explicit format for chains not in the built-in mapping and optional + /// generic-prefix acceptance for known chains. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub ss58_address_policy: Option, +} + +/// Address-domain policy supplied with trusted chain material. +#[derive(Debug, Clone, Copy, Serialize, Deserialize)] +#[serde(rename_all = "camelCase")] +pub struct Ss58AddressPolicy { + pub prefix: u16, + #[serde(default)] + pub allow_generic: bool, +} + +impl Material { + /// Derive the expected SS58 format; unknown chains must provide a verified prefix. + pub fn address_policy(&self) -> Result { + let known = AddressFormat::from_chain_name(&self.chain_name); + let policy = match (known, self.ss58_address_policy) { + (Some(format), None) => Ss58AddressPolicy { + prefix: format.prefix(), + allow_generic: false, + }, + (Some(format), Some(policy)) if policy.prefix == format.prefix() => policy, + (Some(format), Some(policy)) => { + return Err(WasmDotError::InvalidInput(format!( + "SS58 prefix {} conflicts with chain {} (prefix {})", + policy.prefix, self.chain_name, format.prefix() + ))); + } + (None, Some(policy)) => policy, + (None, None) => { + return Err(WasmDotError::MissingContext(format!( + "SS58 prefix required for chain {}", + self.chain_name + ))); + } + }; + if policy.prefix >= 16384 { + return Err(WasmDotError::InvalidInput(format!( + "Invalid SS58 prefix: {}", + policy.prefix + ))); + } + Ok(policy) + } } /// Validity window for mortal transactions @@ -95,12 +143,13 @@ impl AddressFormat { self as u16 } - /// Get format from chain name - pub fn from_chain_name(name: &str) -> Self { + /// Get a format only for known chains; unknown chains require a policy. + pub fn from_chain_name(name: &str) -> Option { match name.to_lowercase().as_str() { - "polkadot" | "statemint" | "polkadot asset hub" => AddressFormat::Polkadot, - "kusama" | "statemine" | "kusama asset hub" => AddressFormat::Kusama, - _ => AddressFormat::Substrate, + "polkadot" | "statemint" | "polkadot asset hub" => Some(Self::Polkadot), + "kusama" | "statemine" | "kusama asset hub" => Some(Self::Kusama), + "westend" | "substrate" => Some(Self::Substrate), + _ => None, } } } @@ -123,11 +172,36 @@ mod tests { fn test_address_format_from_chain() { assert_eq!( AddressFormat::from_chain_name("Polkadot"), - AddressFormat::Polkadot + Some(AddressFormat::Polkadot) ); assert_eq!( AddressFormat::from_chain_name("westend"), - AddressFormat::Substrate + Some(AddressFormat::Substrate) ); + assert_eq!(AddressFormat::from_chain_name("unknown"), None); + } + + #[test] + fn test_material_address_policy() { + let mut material: Material = serde_json::from_value(serde_json::json!({ + "genesisHash": "0x00", "chainName": "Polkadot", "specName": "polkadot", + "specVersion": 1, "txVersion": 1, "metadata": "0x00" + })) + .unwrap(); + assert_eq!(material.address_policy().unwrap().prefix, 0); + material.chain_name = "Kusama".into(); + assert_eq!(material.address_policy().unwrap().prefix, 2); + material.chain_name = "Westend".into(); + assert_eq!(material.address_policy().unwrap().prefix, 42); + material.chain_name = "Custom chain".into(); + assert!(matches!(material.address_policy(), Err(WasmDotError::MissingContext(_)))); + + material.ss58_address_policy = Some(Ss58AddressPolicy { prefix: 1000, allow_generic: false }); + assert_eq!(material.address_policy().unwrap().prefix, 1000); + material.chain_name = "Polkadot".into(); + assert!(matches!(material.address_policy(), Err(WasmDotError::InvalidInput(_)))); + material.chain_name = "Custom chain".into(); + material.ss58_address_policy = Some(Ss58AddressPolicy { prefix: 16384, allow_generic: false }); + assert!(matches!(material.address_policy(), Err(WasmDotError::InvalidInput(_)))); } } diff --git a/packages/wasm-dot/src/wasm/transaction.rs b/packages/wasm-dot/src/wasm/transaction.rs index 6290ae7b8cf..c73442d7a13 100644 --- a/packages/wasm-dot/src/wasm/transaction.rs +++ b/packages/wasm-dot/src/wasm/transaction.rs @@ -3,7 +3,7 @@ //! Thin wrapper around core Transaction with #[wasm_bindgen] use crate::transaction::{decode_metadata, Transaction}; -use crate::types::{Material, ParseContext, Validity}; +use crate::types::{Material, ParseContext, Ss58AddressPolicy, Validity}; use crate::WasmDotError; use wasm_bindgen::prelude::*; @@ -237,6 +237,8 @@ impl MaterialJs { spec_version: u32, tx_version: u32, metadata: &str, + ss58_prefix: Option, + allow_generic: Option, ) -> MaterialJs { MaterialJs { inner: Material { @@ -246,6 +248,10 @@ impl MaterialJs { spec_version, tx_version, metadata: metadata.to_string(), + ss58_address_policy: ss58_prefix.map(|prefix| Ss58AddressPolicy { + prefix, + allow_generic: allow_generic.unwrap_or(false), + }), }, } } diff --git a/packages/wasm-dot/test/builder.ts b/packages/wasm-dot/test/builder.ts index 34aa1ad2b93..65a58c44a7c 100644 --- a/packages/wasm-dot/test/builder.ts +++ b/packages/wasm-dot/test/builder.ts @@ -1,5 +1,11 @@ import * as assert from "assert"; -import { buildTransaction, type TransactionIntent, type BuildContext } from "../js/index.js"; +import { + buildTransaction, + encodeSs58, + parseTransaction, + type TransactionIntent, + type BuildContext, +} from "../js/index.js"; import { getWestendMetadata } from "./resources/westend.js"; /** Convert Uint8Array to hex string (no 0x prefix) */ @@ -183,6 +189,138 @@ describe("buildTransaction", () => { }); }); + describe("SS58 address domains", () => { + const pubkey = new Uint8Array(32).fill(7); + const addresses = new Map( + ([0, 2, 42] as const).map((prefix) => [prefix, encodeSs58(pubkey, prefix)] as const), + ); + const address = (prefix: number): string => addresses.get(prefix)!; + + // Reuse Westend runtime metadata to isolate address-domain handling. + // The chainName controls the trusted prefix, not the metadata contents. + const context = (chainName: string, prefix: number): BuildContext => ({ + ...testContext(), + sender: address(prefix), + material: { ...WESTEND_MATERIAL, chainName }, + }); + + const destinations = (to: string, proxy: string): [string, TransactionIntent][] => [ + ["payment", { type: "payment", to, amount: 1n }], + ["consolidate", { type: "consolidate", to }], + [ + "account payee", + { + type: "stake", + amount: 1n, + proxyAddress: proxy, + payee: { type: "account", address: to }, + }, + ], + ["add proxy", { type: "stake", amount: 1n, proxyAddress: to }], + ["remove proxy", { type: "unstake", amount: 1n, stopStaking: true, proxyAddress: to }], + ]; + + for (const [chainName, expected, wrong] of [ + ["Polkadot", 0, 2], + ["Kusama", 2, 0], + ] as const) { + for (const [name, intent] of destinations(address(wrong), address(expected))) { + it(`${chainName} rejects ${name} from prefix ${wrong} before creating a payload`, () => { + assert.throws( + () => buildTransaction(intent, context(chainName, expected)), + { code: "WrongNetwork", actualPrefix: wrong, expectedPrefix: expected }, + ); + }); + } + + it(`${chainName} rejects generic destinations unless allowed`, () => { + assert.throws( + () => + buildTransaction( + { type: "payment", to: address(42), amount: 1n }, + context(chainName, expected), + ), + /Wrong SS58 network/, + ); + }); + + for (const [name, intent] of destinations(address(expected), address(expected))) { + it(`${chainName} parses ${name} in the approved domain`, () => { + const ctx = context(chainName, expected); + const tx = buildTransaction(intent, ctx); + const args = parseTransaction(tx, { material: ctx.material }).method.args; + const calls = args.calls as { args: Record }[] | undefined; + const actual = + name === "account payee" + ? calls?.[0].args.payee + : name === "add proxy" + ? calls?.[1].args.delegate + : name === "remove proxy" + ? calls?.[0].args.delegate + : args.dest; + assert.strictEqual(actual, address(expected)); + }); + } + } + + it("accepts explicit generic inputs but parses the canonical chain address", () => { + const ctx = context("Polkadot", 0); + ctx.material.ss58AddressPolicy = { prefix: 0, allowGeneric: true }; + const tx = buildTransaction({ type: "payment", to: address(42), amount: 1n }, ctx); + assert.strictEqual( + parseTransaction(tx, { material: ctx.material }).method.args.dest, + address(0), + ); + }); + + it("keeps generic-chain inputs in the approved domain", () => { + const ctx = context("Westend", 42); + const tx = buildTransaction({ type: "consolidate", to: address(42) }, ctx); + assert.strictEqual( + parseTransaction(tx, { material: ctx.material }).method.args.dest, + address(42), + ); + }); + + it("requires an explicit format for unmapped chains", () => { + const ctx = context("Custom chain", 42); + const intent: TransactionIntent = { type: "payment", to: address(42), amount: 1n }; + assert.throws(() => buildTransaction(intent, ctx), /SS58 prefix required/); + ctx.material.ss58AddressPolicy = { prefix: 42 }; + const tx = buildTransaction(intent, ctx); + assert.strictEqual( + parseTransaction(tx, { material: ctx.material }).method.args.dest, + address(42), + ); + }); + + it("rejects an incorrect known-chain policy and an out-of-range prefix", () => { + const ctx = context("Polkadot", 0); + const intent: TransactionIntent = { type: "payment", to: address(0), amount: 1n }; + ctx.material.ss58AddressPolicy = { prefix: 2 }; + assert.throws(() => buildTransaction(intent, ctx), /conflicts with chain Polkadot/); + ctx.material = { + ...ctx.material, + chainName: "Custom chain", + ss58AddressPolicy: { prefix: 16384 }, + }; + assert.throws(() => buildTransaction(intent, ctx), /Invalid SS58 prefix/); + }); + + it("rejects malformed destination and wrong-domain fillNonce sender", () => { + const ctx = context("Polkadot", 0); + assert.throws( + () => buildTransaction({ type: "payment", to: "invalid!", amount: 1n }, ctx), + /Invalid address/, + ); + ctx.sender = address(2); + assert.throws( + () => buildTransaction({ type: "fillNonce" }, ctx), + /Wrong SS58 network: prefix 2/, + ); + }); + }); + describe("batch composition", () => { it("new stake call data should differ from top-up (bond+addProxy vs bondExtra)", () => { const topUp: TransactionIntent = {