diff --git a/packages/wasm-solana/README.md b/packages/wasm-solana/README.md index b93b89d5414..4e3b26ddb2d 100644 --- a/packages/wasm-solana/README.md +++ b/packages/wasm-solana/README.md @@ -2,6 +2,18 @@ WASM bindings for Solana cryptographic operations. This package provides Rust-based bindings for Ed25519 keypair generation, public key operations, and signature verification for Solana. +## Reviewing imported transactions + +`StakeInitialize` parser results include the complete Stake Program lockup: +`unixTimestamp` and `epoch` are lossless `bigint` values, and `custodian` is +its base58 public key. The WebUI displays all three terms and warns whenever +the lockup differs from Solana's default. + +For approval flows, parse and review a `Transaction` instance and use that +same instance's `signablePayload()` as the approval/signing message. Parsed +instructions are a semantic view; signing and serialization preserve the +original message bytes. This package does not implement an approval policy. + ## Building ### Mac diff --git a/packages/wasm-solana/js/index.ts b/packages/wasm-solana/js/index.ts index 6ba44860c00..095561831e4 100644 --- a/packages/wasm-solana/js/index.ts +++ b/packages/wasm-solana/js/index.ts @@ -80,6 +80,7 @@ export type { NonceAdvanceParams, CreateNonceAccountParams, NonceInitializeParams, + StakeLockup, StakeInitializeParams, StakingActivateParams, StakingDeactivateParams, diff --git a/packages/wasm-solana/js/parser.ts b/packages/wasm-solana/js/parser.ts index 538582d203a..882488bca0c 100644 --- a/packages/wasm-solana/js/parser.ts +++ b/packages/wasm-solana/js/parser.ts @@ -55,12 +55,23 @@ export interface NonceInitializeParams { authAddress: string; } +/** Lockup terms stored by the Stake Program. */ +export interface StakeLockup { + /** Unix timestamp as a lossless signed 64-bit integer. */ + unixTimestamp: bigint; + /** Epoch as a lossless unsigned 64-bit integer. */ + epoch: bigint; + /** Stake lockup custodian public key. */ + custodian: string; +} + /** Stake initialize parameters (intermediate - combined into StakingActivate) */ export interface StakeInitializeParams { type: "StakeInitialize"; stakingAddress: string; staker: string; withdrawer: string; + lockup: StakeLockup; } /** Staking activate parameters (combined type) */ @@ -71,6 +82,7 @@ export interface StakingActivateParams { amount: bigint; validator: string; stakingType: "NATIVE" | "JITO" | "MARINADE"; + lockup: StakeLockup; } /** Staking deactivate parameters */ @@ -106,14 +118,6 @@ export interface StakingAuthorizeParams { custodianAddress?: string; } -/** Stake initialize parameters (intermediate type) */ -export interface StakeInitializeParams { - type: "StakeInitialize"; - stakingAddress: string; - staker: string; - withdrawer: string; -} - /** Set compute unit limit parameters */ export interface SetComputeUnitLimitParams { type: "SetComputeUnitLimit"; diff --git a/packages/wasm-solana/js/transaction.ts b/packages/wasm-solana/js/transaction.ts index ef2fa6e3db3..886a97a9eec 100644 --- a/packages/wasm-solana/js/transaction.ts +++ b/packages/wasm-solana/js/transaction.ts @@ -38,8 +38,10 @@ export interface Instruction { * * const tx = Transaction.fromBytes(txBytes); * - * // Parse for decoded instructions + * // Parse for decoded instructions. Review the signable payload from this + * // same Transaction instance; the parsed data is only its semantic view. * const parsed = parseTransaction(tx); + * const reviewedMessage = tx.signablePayload(); * for (const instr of parsed.instructionsData) { * if (instr.type === 'Transfer') { * console.log(`${instr.amount} lamports to ${instr.toAddress}`); diff --git a/packages/wasm-solana/src/instructions/decode.rs b/packages/wasm-solana/src/instructions/decode.rs index 09de2403537..d2c00e1c88f 100644 --- a/packages/wasm-solana/src/instructions/decode.rs +++ b/packages/wasm-solana/src/instructions/decode.rs @@ -138,7 +138,7 @@ fn decode_stake_instruction(ctx: InstructionContext) -> ParsedInstruction { make_unknown(ctx) } } - StakeInstruction::Initialize(authorized, _lockup) => { + StakeInstruction::Initialize(authorized, lockup) => { // This is part of StakingActivate flow - parsed as intermediate StakeInitialize // Will be combined with CreateAccount + DelegateStake in post-processing // Accounts: [0] stake, [1] rent_sysvar @@ -147,6 +147,11 @@ fn decode_stake_instruction(ctx: InstructionContext) -> ParsedInstruction { staking_address: ctx.accounts[0].clone(), staker: authorized.staker.to_string(), withdrawer: authorized.withdrawer.to_string(), + lockup: StakeLockupParams { + unix_timestamp: lockup.unix_timestamp, + epoch: lockup.epoch, + custodian: lockup.custodian.to_string(), + }, }) } else { make_unknown(ctx) diff --git a/packages/wasm-solana/src/instructions/try_into_js_value.rs b/packages/wasm-solana/src/instructions/try_into_js_value.rs index 8b1aa725a6d..d202c0a1fb0 100644 --- a/packages/wasm-solana/src/instructions/try_into_js_value.rs +++ b/packages/wasm-solana/src/instructions/try_into_js_value.rs @@ -114,6 +114,16 @@ impl TryIntoJsValue for NonceInitializeParams { // Stake Program Params // ============================================================================= +impl TryIntoJsValue for StakeLockupParams { + fn try_to_js_value(&self) -> Result { + js_obj!( + "unixTimestamp" => self.unix_timestamp, + "epoch" => self.epoch, + "custodian" => self.custodian + ) + } +} + impl TryIntoJsValue for StakingActivateParams { fn try_to_js_value(&self) -> Result { js_obj!( @@ -122,7 +132,8 @@ impl TryIntoJsValue for StakingActivateParams { "stakingAddress" => self.staking_address, "amount" => self.amount, "validator" => self.validator, - "stakingType" => self.staking_type + "stakingType" => self.staking_type, + "lockup" => self.lockup ) } } @@ -178,7 +189,8 @@ impl TryIntoJsValue for StakeInitializeParams { "type" => "StakeInitialize", "stakingAddress" => self.staking_address, "staker" => self.staker, - "withdrawer" => self.withdrawer + "withdrawer" => self.withdrawer, + "lockup" => self.lockup ) } } diff --git a/packages/wasm-solana/src/instructions/types.rs b/packages/wasm-solana/src/instructions/types.rs index 946bb53a363..64c8e334f65 100644 --- a/packages/wasm-solana/src/instructions/types.rs +++ b/packages/wasm-solana/src/instructions/types.rs @@ -125,6 +125,7 @@ pub struct StakingActivateParams { pub amount: u64, pub validator: String, pub staking_type: crate::intent::StakingType, + pub lockup: StakeLockupParams, } #[derive(Debug, Clone)] @@ -156,6 +157,14 @@ pub struct StakingAuthorizeParams { pub custodian_address: Option, } +/// Lockup terms stored by the Stake Program. +#[derive(Debug, Clone)] +pub struct StakeLockupParams { + pub unix_timestamp: i64, + pub epoch: u64, + pub custodian: String, +} + /// Intermediate type for StakeInstruction::Initialize /// Will be combined with CreateAccount + DelegateStake to form StakingActivate #[derive(Debug, Clone)] @@ -163,6 +172,7 @@ pub struct StakeInitializeParams { pub staking_address: String, pub staker: String, pub withdrawer: String, + pub lockup: StakeLockupParams, } // ============================================================================= diff --git a/packages/wasm-solana/src/intent/build.rs b/packages/wasm-solana/src/intent/build.rs index d23664bd040..2c365b34580 100644 --- a/packages/wasm-solana/src/intent/build.rs +++ b/packages/wasm-solana/src/intent/build.rs @@ -1311,6 +1311,15 @@ mod tests { result.generated_keypairs[0].purpose, KeypairPurpose::StakeAccount ); + let initialize = &result.transaction.message().instructions[1]; + let solana_stake_interface::instruction::StakeInstruction::Initialize(_, lockup) = + bincode::deserialize(&initialize.data).unwrap() + else { + panic!("Expected StakeInstruction::Initialize"); + }; + assert_eq!(lockup.unix_timestamp, 0); + assert_eq!(lockup.epoch, 0); + assert_eq!(lockup.custodian, Pubkey::default()); } #[test] @@ -1471,6 +1480,15 @@ mod tests { 2, "Marinade stake should have exactly 2 instructions (CreateAccount + Initialize)" ); + let initialize = &msg.instructions[1]; + let solana_stake_interface::instruction::StakeInstruction::Initialize(_, lockup) = + bincode::deserialize(&initialize.data).unwrap() + else { + panic!("Expected StakeInstruction::Initialize"); + }; + assert_eq!(lockup.unix_timestamp, 0); + assert_eq!(lockup.epoch, 0); + assert_eq!(lockup.custodian, Pubkey::default()); } #[test] diff --git a/packages/wasm-solana/src/parser.rs b/packages/wasm-solana/src/parser.rs index 6882f78cb32..cd6f55e4f75 100644 --- a/packages/wasm-solana/src/parser.rs +++ b/packages/wasm-solana/src/parser.rs @@ -216,6 +216,9 @@ fn parse_transaction_inner( mod tests { use super::*; use base64::prelude::*; + use solana_pubkey::Pubkey; + use solana_stake_interface::instruction::StakeInstruction; + use solana_stake_interface::state::Lockup; // Test transaction from @solana/web3.js - a simple SOL transfer const TEST_TX_BASE64: &str = "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDFVMqpim7tqEi2XL8R6KKkP0DYJvY3eiRXLlL1P9EjYgXKQC+k0FKnqyC4AZGJR7OhJXfpPP3NHOhS8t/6G7bLAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA/1c7Oaj3RbyLIjU0/ZPpsmVfVUWAzc8g36fK5g6A0JoBAgIAAQwCAAAAoIYBAAAAAAA="; @@ -251,6 +254,95 @@ mod tests { // Note: Combining is now done in TypeScript, so we expect raw instructions here const MARINADE_STAKING_ACTIVATE: &str = "AuRFS0r7hJ+/+WuDQbbwdjSgxfnKOWi94EnWEha9uaBPt8VZOXiOoSiSoES34VkyBNLlLqlfK0fP3d5eJR+srQvN04gqzpOZPTVzqiomyMXqwQ6FYoQg5nEkdiDVny8SsyhRnAeDMzexkKD+3rwSGP0E+XN/2crTL6PZRnip42YFAgADBUXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItBYnsvugEnYfm5Gbz5TLtMncgFHZ8JMpkxTTlJIzJovekAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAah2BeRN1QqmDQ3vf4qerJVf1NcinhyK2ikncAAAAAABqfVFxksXFEhjMlMPUrxf1ja7gibof1E49vZigAAAADjMtr5L6vs6LY/96RABeX9/Zr6FYdWthxalfkEs7jQgQICAgABNAAAAADgkwQAAAAAAMgAAAAAAAAABqHYF5E3VCqYNDe9/ip6slV/U1yKeHIraKSdwAAAAAADAgEEdAAAAACx+Xl4mhxH0TxI2HovJxcQ63+TJglRFzFikL1sKdr12UXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItBAAAAAAAAAAAAAAAAAAAAAEXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItB"; + fn transaction_with_lockup(lockup: Lockup) -> VersionedTransaction { + let bytes = BASE64_STANDARD.decode(MARINADE_STAKING_ACTIVATE).unwrap(); + let mut tx = VersionedTransaction::from_bytes(&bytes).unwrap(); + let VersionedMessage::Legacy(message) = &mut tx.message else { + panic!("Expected legacy transaction fixture"); + }; + let initialize = &mut message.instructions[1]; + let StakeInstruction::Initialize(authorized, _) = + bincode::deserialize(&initialize.data).unwrap() + else { + panic!("Expected StakeInstruction::Initialize fixture"); + }; + initialize.data = + bincode::serialize(&StakeInstruction::Initialize(authorized, lockup)).unwrap(); + tx + } + + fn parsed_stake_initialize( + tx: &VersionedTransaction, + ) -> (String, String, String, i64, u64, String) { + let parsed = parse_transaction(&tx.to_bytes().unwrap()).unwrap(); + let ParsedInstruction::StakeInitialize(params) = &parsed.instructions_data[1] else { + panic!("Expected StakeInitialize instruction"); + }; + ( + params.staking_address.clone(), + params.staker.clone(), + params.withdrawer.clone(), + params.lockup.unix_timestamp, + params.lockup.epoch, + params.lockup.custodian.clone(), + ) + } + + #[test] + fn test_parse_stake_initialize_preserves_default_and_adversarial_lockups() { + let default_tx = transaction_with_lockup(Lockup::default()); + let custodian = Pubkey::new_from_array([42; 32]); + let adversarial_tx = transaction_with_lockup(Lockup { + unix_timestamp: i64::MAX, + epoch: u64::MAX, + custodian: custodian.clone(), + }); + + let default = parsed_stake_initialize(&default_tx); + let adversarial = parsed_stake_initialize(&adversarial_tx); + assert_eq!( + (&default.0, &default.1, &default.2), + (&adversarial.0, &adversarial.1, &adversarial.2) + ); + assert_eq!(default.3, 0); + assert_eq!(default.4, 0); + assert_eq!(default.5, Pubkey::default().to_string()); + assert_eq!(adversarial.3, i64::MAX); + assert_eq!(adversarial.4, u64::MAX); + assert_eq!(adversarial.5, custodian.to_string()); + + let expected_message = adversarial_tx.message.serialize(); + let serialized = adversarial_tx.to_bytes().unwrap(); + let roundtrip = VersionedTransaction::from_bytes(&serialized).unwrap(); + assert_eq!(roundtrip.signable_payload(), expected_message); + assert_eq!(parsed_stake_initialize(&roundtrip), adversarial); + } + + #[test] + fn test_parse_expired_and_single_field_lockups() { + let default_custodian = Pubkey::default(); + let changed_custodian = Pubkey::new_from_array([24; 32]); + let cases = [ + (-1, 0, default_custodian), + (i64::MAX, 0, default_custodian), + (0, u64::MAX, default_custodian), + (0, 0, changed_custodian), + ]; + + for (timestamp, epoch, custodian) in cases { + let expected_custodian = custodian.to_string(); + let tx = transaction_with_lockup(Lockup { + unix_timestamp: timestamp, + epoch, + custodian, + }); + let parsed = parsed_stake_initialize(&tx); + assert_eq!(parsed.3, timestamp); + assert_eq!(parsed.4, epoch); + assert_eq!(parsed.5, expected_custodian); + } + } + #[test] fn test_parse_marinade_staking_activate() { let bytes = BASE64_STANDARD.decode(MARINADE_STAKING_ACTIVATE).unwrap(); @@ -298,6 +390,9 @@ mod tests { params.withdrawer, "5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe" ); + assert_eq!(params.lockup.unix_timestamp, 0); + assert_eq!(params.lockup.epoch, 0); + assert_eq!(params.lockup.custodian, params.withdrawer); } other => panic!("Expected StakeInitialize instruction, got {:?}", other), } diff --git a/packages/wasm-solana/src/wasm/try_into_js_value.rs b/packages/wasm-solana/src/wasm/try_into_js_value.rs index f8f5783575e..37630fd473e 100644 --- a/packages/wasm-solana/src/wasm/try_into_js_value.rs +++ b/packages/wasm-solana/src/wasm/try_into_js_value.rs @@ -73,6 +73,12 @@ impl TryIntoJsValue for u64 { } } +impl TryIntoJsValue for i64 { + fn try_to_js_value(&self) -> Result { + Ok(js_sys::BigInt::from(*self).into()) + } +} + impl TryIntoJsValue for bool { fn try_to_js_value(&self) -> Result { Ok(JsValue::from_bool(*self)) diff --git a/packages/wasm-solana/test/intentBuilder.ts b/packages/wasm-solana/test/intentBuilder.ts index c0e298cc6f2..dd486cf1584 100644 --- a/packages/wasm-solana/test/intentBuilder.ts +++ b/packages/wasm-solana/test/intentBuilder.ts @@ -141,6 +141,11 @@ describe("buildFromIntent", function () { const stakeInit = parsed.instructionsData.find((i: any) => i.type === "StakeInitialize"); assert(stakeInit, "Should have StakeInitialize instruction"); + assert.deepStrictEqual((stakeInit as any).lockup, { + unixTimestamp: 0n, + epoch: 0n, + custodian: "11111111111111111111111111111111", + }); const stakeDelegate = parsed.instructionsData.find((i: any) => i.type === "StakingDelegate"); assert(stakeDelegate, "Should have StakingDelegate instruction"); diff --git a/packages/webui/src/wasm-solana/transaction/index.ts b/packages/webui/src/wasm-solana/transaction/index.ts index 1557eb10d89..2c9768dfc0f 100644 --- a/packages/webui/src/wasm-solana/transaction/index.ts +++ b/packages/webui/src/wasm-solana/transaction/index.ts @@ -13,6 +13,7 @@ import { parseTransaction, type ParsedTransaction, type InstructionParams, + type StakeLockup, } from "@bitgo/wasm-solana"; /** @@ -51,6 +52,16 @@ function formatInstructionType(type: string): string { return type.replace(/([A-Z])/g, " $1").trim(); } +const DEFAULT_STAKE_LOCKUP_CUSTODIAN = "11111111111111111111111111111111"; + +function hasNonDefaultStakeLockup(lockup: StakeLockup): boolean { + return ( + lockup.unixTimestamp !== 0n || + lockup.epoch !== 0n || + lockup.custodian !== DEFAULT_STAKE_LOCKUP_CUSTODIAN + ); +} + /** * Get instruction type color */ @@ -191,6 +202,16 @@ class SolanaTransactionParser extends BaseComponent { border-radius: 6px; } + .stake-lockup-warning { + margin-bottom: 0.75rem; + padding: 0.75rem; + border: 1px solid rgba(248, 81, 73, 0.6); + border-radius: 6px; + background: rgba(248, 81, 73, 0.1); + color: #ff7b72; + font-weight: 600; + } + .instruction-header { display: flex; align-items: center; @@ -635,8 +656,18 @@ class SolanaTransactionParser extends BaseComponent { const type = instr.type; const typeColor = getTypeColor(type); - // Extract params (everything except 'type') - const params = Object.entries(instr).filter(([key]) => key !== "type"); + const lockup = + instr.type === "StakeInitialize" || instr.type === "StakingActivate" ? instr.lockup : null; + const params: [string, unknown][] = Object.entries(instr).filter( + ([key]) => key !== "type" && key !== "lockup", + ); + if (lockup) { + params.push( + ["lockup.unixTimestamp", lockup.unixTimestamp], + ["lockup.epoch", lockup.epoch], + ["lockup.custodian", lockup.custodian], + ); + } return h( "div", @@ -651,6 +682,14 @@ class SolanaTransactionParser extends BaseComponent { formatInstructionType(type), ), ), + lockup && hasNonDefaultStakeLockup(lockup) + ? h( + "div", + { class: "stake-lockup-warning", role: "alert" }, + "Non-default stake lockup. Review all terms: active terms can restrict " + + "withdrawals and authority changes.", + ) + : null, params.length > 0 ? h( "div", diff --git a/packages/webui/tests/solana-parser.spec.ts b/packages/webui/tests/solana-parser.spec.ts new file mode 100644 index 00000000000..5c3dbaf563f --- /dev/null +++ b/packages/webui/tests/solana-parser.spec.ts @@ -0,0 +1,32 @@ +import { test, expect } from "@playwright/test"; + +const MARINADE_STAKING_ACTIVATE = + "AuRFS0r7hJ+/+WuDQbbwdjSgxfnKOWi94EnWEha9uaBPt8VZOXiOoSiSoES34VkyBNLlLqlfK0fP3d5eJR+srQvN04gqzpOZPTVzqiomyMXqwQ6FYoQg5nEkdiDVny8SsyhRnAeDMzexkKD+3rwSGP0E+XN/2crTL6PZRnip42YFAgADBUXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItBYnsvugEnYfm5Gbz5TLtMncgFHZ8JMpkxTTlJIzJovekAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAah2BeRN1QqmDQ3vf4qerJVf1NcinhyK2ikncAAAAAABqfVFxksXFEhjMlMPUrxf1ja7gibof1E49vZigAAAADjMtr5L6vs6LY/96RABeX9/Zr6FYdWthxalfkEs7jQgQICAgABNAAAAADgkwQAAAAAAMgAAAAAAAAABqHYF5E3VCqYNDe9/ip6slV/U1yKeHIraKSdwAAAAAADAgEEdAAAAACx+Xl4mhxH0TxI2HovJxcQ63+TJglRFzFikL1sKdr12UXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItBAAAAAAAAAAAAAAAAAAAAAEXlebz5JTz2i0ff8fs6OlwsIbrFsjwJrhKm4FVr8ItB"; + +test("stake initialization renders all lockup fields with a warning", async ({ page }) => { + await page.goto("/#/wasm-solana/transaction"); + const parser = page.locator("solana-transaction-parser"); + await parser.locator("#tx-input").fill(MARINADE_STAKING_ACTIVATE); + + const instruction = parser + .locator(".instruction-card") + .filter({ hasText: "Stake Initialize" }); + await expect(instruction).toBeVisible(); + await expect(instruction.locator(".stake-lockup-warning")).toContainText( + "Non-default stake lockup", + ); + await expect(instruction.locator(".instruction-params > span")).toHaveText([ + "stakingAddress", + "7dRuGFbU2y2kijP6o1LYNzVyz4yf13MooqoionCzv5Za", + "staker", + "CyjoLt3kjqB57K7ewCBHmnHq3UgEj3ak6A7m6EsBsuhA", + "withdrawer", + "5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe", + "lockup.unixTimestamp", + "0", + "lockup.epoch", + "0", + "lockup.custodian", + "5hr5fisPi6DXNuuRpm5XUbzpiEnmdyxXuBDTwzwZj5Pe", + ]); +});