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 = {