From edf9d1db3a235a52fcc9e14839c7cbe7f142854a Mon Sep 17 00:00:00 2001 From: Veetrag Jain Date: Thu, 29 Oct 2026 02:26:48 +0530 Subject: [PATCH] feat(zec): refresh anchor and witnesses on ironwood spend psbts Ticket: CSHLD-2098 --- .../ZcashIronwoodBitGoPsbt.ts | 43 ++- .../bitgo_psbt/zcash/error.rs | 12 + .../bitgo_psbt/zcash/ironwood_spend.rs | 98 +++++- .../bitgo_psbt/zcash/tests/ironwood_spend.rs | 312 +++++++++++++++++- .../wasm/fixed_script_wallet/zcash_psbt.rs | 73 +++- .../wasm-utxo/src/zcash/ironwood_build.rs | 86 ++++- packages/wasm-utxo/src/zcash/ironwood_pczt.rs | 27 ++ .../test/fixedScript/zcashIronwoodKeyless.ts | 19 ++ .../test/fixedScript/zcashIronwoodSpend.ts | 138 +++++++- .../fixedScript/zcashIronwoodSpend.util.ts | 7 + .../zcash/ironwood_spend_deshield.json | 58 +++- .../zcash/ironwood_spend_transfer.json | 103 +++++- 12 files changed, 930 insertions(+), 46 deletions(-) diff --git a/packages/wasm-utxo/js/fixedScriptWallet/ZcashIronwoodBitGoPsbt.ts b/packages/wasm-utxo/js/fixedScriptWallet/ZcashIronwoodBitGoPsbt.ts index 05bd62e1259..d3416577e89 100644 --- a/packages/wasm-utxo/js/fixedScriptWallet/ZcashIronwoodBitGoPsbt.ts +++ b/packages/wasm-utxo/js/fixedScriptWallet/ZcashIronwoodBitGoPsbt.ts @@ -21,6 +21,7 @@ import { type ZcashShieldedSpend, type ZcashShieldedSpendRequest, } from "./ZcashIronwoodTypes.js"; +import { type ZcashIronwoodWitness } from "./ZcashIronwoodWitness.js"; import { Zip317Dimensions } from "./Zip317Dimensions.js"; /** @@ -160,7 +161,10 @@ type IronwoodParsedBase = ParsedTransaction, + ): void { + this.wasm.update_ironwood_anchor_and_witnesses( + anchor, + entries.map((entry) => ({ + actionIndex: entry.actionIndex, + witness: { position: entry.witness.position, authPath: entry.witness.authPath }, + })), + ); + } + /** * Install the signer's randomized `rk`s: one `{ actionIndex, alpha, rk }` entry per real * spend, with `rk = ak.randomize(alpha)`. **Only `rk` is stored** — the PSBT never carries diff --git a/packages/wasm-utxo/src/fixed_script_wallet/bitgo_psbt/zcash/error.rs b/packages/wasm-utxo/src/fixed_script_wallet/bitgo_psbt/zcash/error.rs index 889fe60e060..8fe24957b2d 100644 --- a/packages/wasm-utxo/src/fixed_script_wallet/bitgo_psbt/zcash/error.rs +++ b/packages/wasm-utxo/src/fixed_script_wallet/bitgo_psbt/zcash/error.rs @@ -73,6 +73,13 @@ pub enum IronwoodPsbtError { /// The real spends' action indices without an `alpha`. action_indices: Vec, }, + /// The anchor update named no witness for these real spends: the anchor is bundle-level, + /// so changing it invalidates every real spend's witness — one re-witnessed path per real + /// spend must be supplied. + WitnessMissing { + /// The real spends' action indices without a witness. + action_indices: Vec, + }, /// The proof is not the canonical size for the bundle's action count. ProofLength { /// `orchard::Proof::expected_proof_size` for the bundle's actions. @@ -170,6 +177,11 @@ impl std::fmt::Display for IronwoodPsbtError { "no alpha was supplied for real spends {action_indices:?}; the proof request \ needs one per real spend" ), + IronwoodPsbtError::WitnessMissing { action_indices } => write!( + f, + "no witness was supplied for real spends {action_indices:?}; changing the \ + anchor re-witnesses every real spend" + ), IronwoodPsbtError::ProofLength { expected, actual } => write!( f, "the proof is {actual} bytes; a bundle of this many actions needs {expected}" diff --git a/packages/wasm-utxo/src/fixed_script_wallet/bitgo_psbt/zcash/ironwood_spend.rs b/packages/wasm-utxo/src/fixed_script_wallet/bitgo_psbt/zcash/ironwood_spend.rs index e0a7fb459b8..832a9ff1f82 100644 --- a/packages/wasm-utxo/src/fixed_script_wallet/bitgo_psbt/zcash/ironwood_spend.rs +++ b/packages/wasm-utxo/src/fixed_script_wallet/bitgo_psbt/zcash/ironwood_spend.rs @@ -422,8 +422,10 @@ impl ZcashBitGoPsbt { /// [`Self::combine_ironwood_proof`]; it is never stored in the PSBT. /// /// Every real output's `out_ciphertext`, every real spend's randomized `rk`, and every - /// real spend's `spend_auth_sig` must be installed first. Signing freezes the bundle, so - /// the proof is always made over the final action data. + /// real spend's `spend_auth_sig` must be installed first. Signing freezes the action data, + /// so the proof is always made over the final action data; the anchor is not action data + /// and can still be refreshed ([`Self::update_anchor_and_witnesses`]) — request the proof + /// after the last refresh. /// /// The PSBT never stores `alpha` (with `rk` it would reveal the wallet's `ak`), so the /// caller supplies exactly one `(action_index, alpha)` per real spend: each index must @@ -611,6 +613,98 @@ impl ZcashBitGoPsbt { Ok(()) } + /// Refresh the bundle's anchor and every real spend's Merkle witness — the re-witness + /// step a build whose approval sat too long runs before proving: the anchor is read once, + /// fresh witnesses are fetched for every spent note, and both land in one call. Allowed + /// before *and after* signing: the v6 sighash does not commit the anchor (it sits in the + /// authorizing digest, bound by the proof), so the spend-auth and transparent signatures + /// stay valid across a refresh, and the binding signature is only made at + /// [`Self::combine_ironwood_proof`]. A refresh does invalidate any proof request already + /// handed out — the proof must be requested ([`Self::proof_request`]) after the last + /// refresh, or the combined transaction carries a proof over the old anchor. + /// + /// `anchor` is the new note-commitment-tree root (32 bytes); `entries` carries exactly + /// one `(action_index, witness)` per real spend — each index must exist + /// ([`IronwoodPsbtError::UnknownAction`]), name a real spend + /// ([`IronwoodPsbtError::DummyAction`]) and appear once + /// ([`IronwoodPsbtError::DuplicateAction`]), and every real spend must be covered + /// ([`IronwoodPsbtError::WitnessMissing`]: the anchor is bundle-level, so a spend left + /// on its old witness would make the bundle internally inconsistent). Every supplied + /// witness is validated against the *new* anchor over its spend's own note commitment — + /// a stale witness for the old anchor is rejected + /// ([`IronwoodBuildError::WitnessAnchorMismatch`] under [`IronwoodPsbtError::Build`]) — + /// so the call can never leave the bundle anchoring nothing. **Atomic** — every entry is + /// validated before anything is written, so one bad entry stores nothing. Dummy spends + /// keep their builder-fabricated witnesses: the circuit checks the anchor only for real + /// spends, so dummies need no re-witnessing. + /// + /// Only spend bundles take an anchor refresh ([`IronwoodPsbtError::NotSpendBundle`]), + /// and the batch must not be empty ([`IronwoodPsbtError::NothingPending`]). + /// + /// [`IronwoodBuildError::WitnessAnchorMismatch`]: + /// crate::zcash::ironwood_build::IronwoodBuildError::WitnessAnchorMismatch + pub fn update_anchor_and_witnesses( + &mut self, + anchor: &crate::zcash::ironwood_build::AnchorBytes, + entries: &[(usize, crate::zcash::ironwood_build::IronwoodWitness)], + ) -> Result<(), IronwoodPsbtError> { + use crate::zcash::ironwood_build::build_ironwood_witness; + + let (bytes, pczt) = self.stored_ironwood_pczt()?; + if !Self::bundle_has_real_spends(&pczt) { + return Err(IronwoodPsbtError::NotSpendBundle); + } + if entries.is_empty() { + return Err(IronwoodPsbtError::NothingPending); + } + Self::require_distinct_actions(entries.iter().map(|&(action_index, _)| action_index))?; + let missing: Vec = pczt + .actions() + .iter() + .enumerate() + .filter(|&(_, action)| action.spend().dummy_sk().is_none()) + .map(|(action_index, _)| action_index) + .filter(|action_index| !entries.iter().any(|&(index, _)| index == *action_index)) + .collect(); + if !missing.is_empty() { + return Err(IronwoodPsbtError::WitnessMissing { + action_indices: missing, + }); + } + // The pre-update bundle must verify: the refresh is written only over a consistent + // bundle, so a tampered stored PCZT fails here instead of being re-anchored. The + // verified report carries each real spend's recomputed note commitment — the leaf + // its new witness must anchor; an entry naming no verified spend names an + // out-of-range action ([`IronwoodPsbtError::UnknownAction`]) or a dummy one + // ([`IronwoodPsbtError::DummyAction`]). + let report = self + .keyless_verify(&pczt) + .map_err(IronwoodPsbtError::Verify)?; + for &(action_index, witness) in entries { + let cmx = report + .spends + .iter() + .find(|spend| spend.action_index == action_index) + .map(|spend| spend.cmx) + .ok_or_else(|| { + if action_index < pczt.actions().len() { + IronwoodPsbtError::DummyAction + } else { + IronwoodPsbtError::UnknownAction + } + })?; + build_ironwood_witness(&cmx, witness.position, &witness.auth_path, anchor) + .map_err(IronwoodPsbtError::Build)?; + } + + // Validate-then-write: the PSBT is replaced only on full success. + let patched = + crate::zcash::ironwood_pczt::with_anchor_and_witnesses(&bytes, *anchor, entries) + .map_err(IronwoodPsbtError::Pczt)?; + super::propkv::set_ironwood_pczt(&mut self.psbt, patched); + Ok(()) + } + /// The orchestration view of the shielded workflow: the input kind, what is still pending /// at each stage, and whether the PSBT is ready for its proof. A PSBT without a PCZT is a /// transparent one with nothing pending and nothing to prove; errors only when the stored diff --git a/packages/wasm-utxo/src/fixed_script_wallet/bitgo_psbt/zcash/tests/ironwood_spend.rs b/packages/wasm-utxo/src/fixed_script_wallet/bitgo_psbt/zcash/tests/ironwood_spend.rs index 9f49036d3cc..f1c0756eb98 100644 --- a/packages/wasm-utxo/src/fixed_script_wallet/bitgo_psbt/zcash/tests/ironwood_spend.rs +++ b/packages/wasm-utxo/src/fixed_script_wallet/bitgo_psbt/zcash/tests/ironwood_spend.rs @@ -12,8 +12,10 @@ use crate::fixed_script_wallet::bitgo_psbt::zcash::ironwood_spend::{ use crate::fixed_script_wallet::bitgo_psbt::BitGoPsbt; use crate::fixed_script_wallet::script_id::ScriptId; use crate::networks::Network; +use crate::zcash::ironwood_build::test_util::refreshed_two_leaf_tree; use crate::zcash::ironwood_build::{ - compute_out_ciphertext, IronwoodActionMap, IronwoodVerifyCheck, IronwoodVerifyError, + compute_out_ciphertext, test_field_bytes, IronwoodActionMap, IronwoodBuildError, + IronwoodVerifyCheck, IronwoodVerifyError, IronwoodWitness, }; use crate::zcash::ironwood_construct::test_util::keyless_fixture; #[cfg(feature = "orchard-proving")] @@ -1413,6 +1415,289 @@ fn add_out_ciphertexts_rejects_after_a_transparent_signature() { assert!(matches!(error, IronwoodPsbtError::AlreadySigned)); } +// ---- The anchor refresh (`update_anchor_and_witnesses`) ---- + +/// Fresh witnesses for the spent notes under an extended tree: the same leaves (same +/// commitments, same positions) re-witnessed to a new root, as an anchor refresh delivers. +/// Tree slots beyond `cmxs` are filled with arbitrary canonical commitments — the tree only +/// needs to contain the spent leaves. +fn refreshed_anchor_and_witnesses( + cmxs: &[&[u8; 32]], + map: &IronwoodActionMap, +) -> ([u8; 32], Vec<(usize, IronwoodWitness)>) { + assert!( + (1..=2).contains(&cmxs.len()), + "the refreshed fixture tree holds one or two spent leaves" + ); + let filler = test_field_bytes(999); + let first = *cmxs[0]; + let second = cmxs.get(1).copied().unwrap_or(&filler); + let (anchor, witnesses) = refreshed_two_leaf_tree(&[first, *second], &test_field_bytes(202)); + let entries = witnesses + .iter() + .take(cmxs.len()) + .enumerate() + .map(|(spend_index, witness)| (map.spend_action_index(spend_index).unwrap(), *witness)) + .collect(); + (anchor, entries) +} + +/// The anchor refresh: re-point the bundle to a fresh anchor with fresh witnesses — the step +/// a build whose approval sat too long runs before signing. The refreshed bundle verifies +/// under the new root, and the rest of the lifecycle (signatures, extraction) proceeds over +/// it, anchoring the broadcast transaction to the new root. +#[test] +fn update_anchor_and_witnesses_repoints_the_bundle_to_a_fresh_anchor() { + let seed = "ironwood_v6_keyless_anchor_refresh"; + let (specs, old_anchor, _fvk, _ak) = keyless_fixture(); + let (mut z, map, ak, fvk, ask) = keyless_transfer_psbt(seed); + + // Ciphertexts and randomizers land before the refresh; neither freezes the bundle. + fvk_out_ciphertexts(&mut z, &map.actions, &fvk); + let triples = install_randomizer_triples(&mut z, &map.actions, &ask, &ak); + assert_eq!( + z.verify_shielded_bundle(None, &[]).unwrap().anchor, + old_anchor, + "the bundle anchors to the build-time root before the refresh" + ); + let sighash_before = z.spend_sighash().unwrap(); + + let (new_anchor, entries) = + refreshed_anchor_and_witnesses(&[&specs[0].cmx, &specs[1].cmx], &map.actions); + z.update_anchor_and_witnesses(&new_anchor, &entries) + .unwrap(); + + // The ZIP-244 digest covers action data only: the anchor is excluded (it is the proof, + // not the sighash, that commits it), so the refresh leaves the digest untouched. + assert_eq!( + z.spend_sighash().unwrap(), + sighash_before, + "the anchor must not affect the ZIP-244 digest" + ); + + // The refresh survives the PSBT wire, and the verifier accepts the refreshed bundle with + // the caller's randomizers. + let bytes = z.serialize_v6(); + let mut z = ZcashBitGoPsbt::deserialize_v6(&bytes, Network::ZcashTestnet).unwrap(); + let report = z.verify_shielded_bundle(Some(&ak), &triples).unwrap(); + assert_eq!(report.anchor, new_anchor); + assert_eq!(z.spend_sighash().unwrap(), sighash_before); + + // Signatures over the post-refresh digest verify against the installed `rk`s, and the + // broadcast transaction anchors to the refreshed root. + let pairs: Vec<(usize, [u8; 32])> = triples + .iter() + .map(|&(action_index, alpha, _)| (action_index, alpha)) + .collect(); + install_spend_signatures(&mut z, &pairs, &ask); + let raw = z + .combine_ironwood_proof(vec![0u8; Proof::expected_proof_size(2)], OsRng) + .unwrap(); + let tx = crate::zcash::v6::decode_v6_transaction(&raw).unwrap(); + assert_eq!( + tx.ironwood_bundle.as_ref().unwrap().anchor, + new_anchor, + "the broadcast transaction anchors to the refreshed root" + ); +} + +/// A stale witness — one still anchoring the old root — is rejected against the new anchor, +/// and a rejected batch stores nothing. Re-delivering the current anchor with the current +/// witnesses is an accepted no-op. +#[test] +fn update_anchor_and_witnesses_rejects_a_stale_witness_atomically() { + let seed = "ironwood_v6_keyless_anchor_stale"; + let (specs, old_anchor, _fvk, _ak) = keyless_fixture(); + let (mut z, map, ak, fvk, _ask) = keyless_transfer_psbt(seed); + fvk_out_ciphertexts(&mut z, &map.actions, &fvk); + let before = z.raw_ironwood_pczt_bytes().unwrap(); + + let (new_anchor, _entries) = + refreshed_anchor_and_witnesses(&[&specs[0].cmx, &specs[1].cmx], &map.actions); + let stale: Vec<(usize, IronwoodWitness)> = map + .actions + .spend_action_indices() + .iter() + .zip(specs.iter()) + .map(|(&action_index, spec)| (action_index, spec.witness)) + .collect(); + + // The old witnesses do not recompute to the new anchor, and nothing is written. + let error = z + .update_anchor_and_witnesses(&new_anchor, &stale) + .unwrap_err(); + assert!(matches!( + error, + IronwoodPsbtError::Build(IronwoodBuildError::WitnessAnchorMismatch) + )); + assert_eq!( + z.raw_ironwood_pczt_bytes().unwrap(), + before, + "the stale batch stored nothing" + ); + + // The same anchor with the same witnesses is a no-op rewrite. + z.update_anchor_and_witnesses(&old_anchor, &stale).unwrap(); + assert_eq!(z.raw_ironwood_pczt_bytes().unwrap(), before); + assert_eq!( + z.verify_shielded_bundle(Some(&ak), &[]).unwrap().anchor, + old_anchor + ); + + // One good entry plus one stale entry rejects the whole batch. + let (good_anchor, good_entries) = + refreshed_anchor_and_witnesses(&[&specs[0].cmx, &specs[1].cmx], &map.actions); + let mixed = vec![good_entries[0], stale[1]]; + let error = z + .update_anchor_and_witnesses(&good_anchor, &mixed) + .unwrap_err(); + assert!(matches!( + error, + IronwoodPsbtError::Build(IronwoodBuildError::WitnessAnchorMismatch) + )); + assert_eq!(z.raw_ironwood_pczt_bytes().unwrap(), before); +} + +/// The batch shape: exactly one entry per real spend, no repeats, no dummies, no empty +/// batch — and a non-canonical anchor is rejected before anything is written. +#[test] +fn update_anchor_and_witnesses_rejects_bad_batches_atomically() { + let seed = "ironwood_v6_keyless_anchor_batch"; + let (specs, _old_anchor, _fvk, _ak) = keyless_fixture(); + let (mut z, map, _ak2, fvk, _ask2) = keyless_transfer_psbt(seed); + fvk_out_ciphertexts(&mut z, &map.actions, &fvk); + let (new_anchor, entries) = + refreshed_anchor_and_witnesses(&[&specs[0].cmx, &specs[1].cmx], &map.actions); + let before = z.raw_ironwood_pczt_bytes().unwrap(); + + // An empty batch. + let error = z.update_anchor_and_witnesses(&new_anchor, &[]).unwrap_err(); + assert!(matches!(error, IronwoodPsbtError::NothingPending)); + + // A repeated action index. + let duplicate = vec![entries[0], entries[0]]; + let error = z + .update_anchor_and_witnesses(&new_anchor, &duplicate) + .unwrap_err(); + assert!(matches!( + error, + IronwoodPsbtError::DuplicateAction { action_index } if action_index == entries[0].0 + )); + + // A batch covering only one of the two real spends: the anchor is bundle-level, so the + // uncovered spend would be left anchoring the old root. + let partial = vec![entries[0]]; + let error = z + .update_anchor_and_witnesses(&new_anchor, &partial) + .unwrap_err(); + assert!(matches!( + error, + IronwoodPsbtError::WitnessMissing { action_indices } + if action_indices == vec![entries[1].0] + )); + + // Every real spend covered, plus one out-of-range index. + let mut unknown = entries.clone(); + unknown.push((usize::MAX, entries[0].1)); + let error = z + .update_anchor_and_witnesses(&new_anchor, &unknown) + .unwrap_err(); + assert!(matches!(error, IronwoodPsbtError::UnknownAction)); + + // A non-canonical anchor fails the witness validation before anything is written. + let error = z + .update_anchor_and_witnesses(&[0xff; 32], &entries) + .unwrap_err(); + assert!(matches!( + error, + IronwoodPsbtError::Build(IronwoodBuildError::BadAnchor) + )); + assert_eq!( + z.raw_ironwood_pczt_bytes().unwrap(), + before, + "no rejected batch stored anything" + ); +} + +/// Dummy spends take no witness — the circuit checks the anchor only for real spends — a +/// shielding bundle takes no refresh at all, and neither does a PSBT without a PCZT. +#[test] +fn update_anchor_and_witnesses_rejects_a_dummy_a_shield_and_an_empty_psbt() { + let seed = "ironwood_v6_keyless_anchor_dummy"; + let (specs, _old_anchor, _fvk, _ak) = keyless_fixture(); + let (mut z, map, _ak2, fvk, _ask2) = keyless_surplus_psbt(seed); + fvk_out_ciphertexts(&mut z, &map.actions, &fvk); + let (new_anchor, entries) = refreshed_anchor_and_witnesses(&[&specs[0].cmx], &map.actions); + let witness = specs[0].witness; + // The surplus shape's second action is a dummy spend. + let action_count = z.ironwood_pczt().unwrap().actions().len(); + let real = map.actions.spend_action_indices(); + let dummy_index = (0..action_count).find(|i| !real.contains(i)).unwrap(); + let mut batch = entries.clone(); + batch.push((dummy_index, entries[0].1)); + let error = z + .update_anchor_and_witnesses(&new_anchor, &batch) + .unwrap_err(); + assert!(matches!(error, IronwoodPsbtError::DummyAction)); + + // A shielding bundle (dummy spends only) takes no anchor refresh. + let mut shield = build_shield_psbt("ironwood_v6_keyless_anchor_shield"); + let error = shield + .update_anchor_and_witnesses(&new_anchor, &[(0, witness)]) + .unwrap_err(); + assert!(matches!(error, IronwoodPsbtError::NotSpendBundle)); + + // A PSBT without a PCZT has nothing to refresh. + let error = empty_v6_psbt("ironwood_v6_keyless_anchor_empty") + .update_anchor_and_witnesses(&new_anchor, &[(0, witness)]) + .unwrap_err(); + assert!(matches!(error, IronwoodPsbtError::NotSpendBundle)); +} + +/// Not frozen by signing: the v6 sighash does not commit the anchor, so a bundle refreshed +/// after its spend-auth signatures keeps them valid — the proof request is served, and the +/// combined transaction (which re-verifies every spend-auth signature against the sighash) +/// anchors to the refreshed root without a re-sign. +#[test] +fn update_anchor_and_witnesses_is_allowed_after_spend_signatures() { + let seed = "ironwood_v6_keyless_anchor_spend_sig"; + let (specs, old_anchor, _fvk, _ak) = keyless_fixture(); + let (mut z, map, _ak2, fvk, ask) = keyless_transfer_psbt(seed); + fvk_out_ciphertexts(&mut z, &map.actions, &fvk); + let pairs = install_randomizers(&mut z, &map.actions, &ask); + install_spend_signatures(&mut z, &pairs, &ask); + let sighash = z.spend_sighash().unwrap(); + assert_eq!( + z.verify_shielded_bundle(None, &[]).unwrap().anchor, + old_anchor + ); + + let (new_anchor, entries) = + refreshed_anchor_and_witnesses(&[&specs[0].cmx, &specs[1].cmx], &map.actions); + z.update_anchor_and_witnesses(&new_anchor, &entries) + .unwrap(); + + // The signatures are over a digest the refresh does not touch. + assert_eq!(z.spend_sighash().unwrap(), sighash); + assert_eq!( + z.verify_shielded_bundle(None, &[]).unwrap().anchor, + new_anchor + ); + let request = z.proof_request(&pairs).unwrap(); + let requested = crate::zcash::ironwood_pczt::deserialize_pczt(&request).unwrap(); + assert_eq!( + requested.anchor().to_bytes(), + new_anchor, + "the proof request is over the refreshed anchor" + ); + + let raw = z + .combine_ironwood_proof(vec![0u8; Proof::expected_proof_size(2)], OsRng) + .unwrap(); + let tx = crate::zcash::v6::decode_v6_transaction(&raw).unwrap(); + assert_eq!(tx.ironwood_bundle.as_ref().unwrap().anchor, new_anchor); +} + /// The proof request refuses a spend bundle until its ciphertexts, then its randomizers, /// then its spend signatures are installed; a shielding bundle is served as-is. #[test] @@ -1859,6 +2144,16 @@ fn spend_fixture_json( Err(error) => panic!("unexpected out-ciphertext request error: {error}"), }; + // The anchor refresh: the build's approval is assumed to have sat long enough that the + // anchor moved, so the refresh lands after the ciphertexts and before the signing + // rounds. The same leaves (same commitments, same positions) re-witnessed to a + // fresh root; the digest, signatures, proof and txid below are all over the refreshed + // bundle, and the TS lifecycle replays `updateAnchorAndWitnesses` at this exact point. + let cmxs: Vec<&[u8; 32]> = specs.iter().map(|spec| &spec.cmx).collect(); + let (refresh_anchor, refresh_entries) = refreshed_anchor_and_witnesses(&cmxs, &map.actions); + z.update_anchor_and_witnesses(&refresh_anchor, &refresh_entries) + .unwrap(); + // The FROST stand-in: one (alpha, rk = ak.randomize(alpha)) pair per real spend. Only // `rk` is stored; the alphas ride along out of band for the proof request. let randomizers: Vec<(usize, [u8; 32], [u8; 32])> = map @@ -1945,6 +2240,21 @@ fn spend_fixture_json( "actionIndex": action_index, "outCiphertext": to_hex(&out_ciphertext), })).collect::>(), + "refresh": { + "anchor": to_hex(&refresh_anchor), + "witnesses": refresh_entries + .iter() + .zip(specs.iter()) + .map(|((action_index, witness), spec)| { + serde_json::json!({ + "actionIndex": *action_index, + "cmx": to_hex(&spec.cmx), + "position": witness.position, + "authPath": witness.auth_path.iter().map(|h| to_hex(h)).collect::>(), + }) + }) + .collect::>(), + }, "randomizers": randomizers.iter().map(|&(action_index, alpha, rk)| serde_json::json!({ "actionIndex": action_index, diff --git a/packages/wasm-utxo/src/wasm/fixed_script_wallet/zcash_psbt.rs b/packages/wasm-utxo/src/wasm/fixed_script_wallet/zcash_psbt.rs index 5fccfbe28ab..74ea9d1b9ab 100644 --- a/packages/wasm-utxo/src/wasm/fixed_script_wallet/zcash_psbt.rs +++ b/packages/wasm-utxo/src/wasm/fixed_script_wallet/zcash_psbt.rs @@ -767,6 +767,45 @@ impl BitGoPsbt { .map_err(WasmUtxoError::from) } + /// Refresh the bundle's anchor and every real spend's Merkle witness: `anchor` is the new + /// note-commitment-tree root (32 bytes), `entries` an array of + /// `{ actionIndex: number, witness: { position: number, authPath: Uint8Array } }` — + /// exactly one entry per real spend (`IronwoodPsbtError.WitnessMissing` otherwise), each + /// `authPath` the 32 sibling hashes flattened (as `IronwoodWitness.auth_path` returns + /// it). Every witness is validated against the new anchor over the spend's own note + /// commitment before anything is written — **atomic**, one bad entry stores nothing. + /// + /// **Allowed before and after signing**: the v6 sighash does not commit the anchor (the + /// proof does), so existing signatures stay valid. A refresh invalidates any proof request + /// already handed out — request the proof after the last refresh. + pub fn update_ironwood_anchor_and_witnesses( + &mut self, + anchor: &[u8], + entries: JsValue, + ) -> Result<(), WasmUtxoError> { + let anchor: AnchorBytes = fixed_bytes(anchor, "anchor")?; + let entries: Vec = serde_wasm_bindgen::from_value(entries) + .map_err(|e| WasmUtxoError::new(&format!("invalid anchor/witness entries: {e}")))?; + let entries = entries + .into_iter() + .map(|entry| { + Ok(( + entry.action_index, + IronwoodWitness { + position: entry.witness.position, + auth_path: split_auth_path(fixed_bytes( + &entry.witness.auth_path, + "authPath", + )?), + }, + )) + }) + .collect::, IronwoodPsbtError>>()?; + self.zcash_mut()? + .update_anchor_and_witnesses(&anchor, &entries) + .map_err(WasmUtxoError::from) + } + /// Install the signer's randomized `rk`s: an array of /// `{ actionIndex: number, alpha: Uint8Array, rk: Uint8Array }` — one per real spend, /// with `rk = ak.randomize(alpha)`. **Only `rk` is stored**: the PSBT never carries @@ -986,6 +1025,16 @@ fn required_fixed_bytes( Ok(fixed_bytes(&bytes, field)?) } +/// Split a flattened `authPath` (as `IronwoodWitness.auth_path` returns it) into its +/// `IRONWOOD_MERKLE_DEPTH` sibling hashes. +fn split_auth_path(bytes: [u8; IRONWOOD_MERKLE_DEPTH * 32]) -> WitnessAuthPath { + let mut path: WitnessAuthPath = [[0u8; 32]; IRONWOOD_MERKLE_DEPTH]; + for (node, chunk) in path.iter_mut().zip(bytes.chunks_exact(32)) { + node.copy_from_slice(chunk); + } + path +} + /// One `add_ironwood_out_ciphertexts` entry from JS: `{ actionIndex, outCiphertext }`. #[derive(serde::Deserialize)] #[serde(rename_all = "camelCase")] @@ -1011,6 +1060,23 @@ struct SpendSignatureEntry { signature: serde_bytes::ByteBuf, } +/// One `update_ironwood_anchor_and_witnesses` entry from JS: +/// `{ actionIndex, witness: { position, authPath } }` — the re-witnessed Merkle path +/// (`authPath` the 32 sibling hashes flattened, as `IronwoodWitness.auth_path` returns it). +#[derive(serde::Deserialize)] +#[serde(rename_all = "camelCase")] +struct AnchorWitnessEntry { + action_index: usize, + witness: WitnessEntry, +} + +#[derive(serde::Deserialize)] +#[serde(rename_all = "camelCase")] +struct WitnessEntry { + position: u32, + auth_path: serde_bytes::ByteBuf, +} + /// One `ironwood_proof_request` randomizer from JS: `{ actionIndex, alpha }`. #[derive(serde::Deserialize)] #[serde(rename_all = "camelCase")] @@ -1025,12 +1091,7 @@ struct ProofRequestAlpha { impl TryFromJsValue for IronwoodKeylessSpendSpec { fn try_from_js_value(item: &JsValue) -> Result { let witness = get_required_raw_field(item, "witness")?; - let auth_path: [u8; IRONWOOD_MERKLE_DEPTH * 32] = - required_fixed_bytes(&witness, "authPath")?; - let mut path: WitnessAuthPath = [[0u8; 32]; IRONWOOD_MERKLE_DEPTH]; - for (node, chunk) in path.iter_mut().zip(auth_path.chunks_exact(32)) { - node.copy_from_slice(chunk); - } + let path = split_auth_path(required_fixed_bytes(&witness, "authPath")?); Ok(Self { recipient: required_fixed_bytes(item, "recipient")?, value: get_required_u64_field(item, "value")?, diff --git a/packages/wasm-utxo/src/zcash/ironwood_build.rs b/packages/wasm-utxo/src/zcash/ironwood_build.rs index 7e494c8224c..913cf66616e 100644 --- a/packages/wasm-utxo/src/zcash/ironwood_build.rs +++ b/packages/wasm-utxo/src/zcash/ironwood_build.rs @@ -3914,6 +3914,24 @@ pub(crate) mod test_util { pub witness: IronwoodWitness, } + /// Fold a leaf up to the root through `siblings[d]` (its sibling at depth `d`). + /// Orchard's `combine` takes the CHILDREN's level: leaves combine at level 0. + pub(crate) fn fold_leaf_to_root( + start: MerkleHashOrchard, + index: u64, + siblings: &[MerkleHashOrchard; IRONWOOD_MERKLE_DEPTH], + ) -> MerkleHashOrchard { + let mut node = start; + for (d, sibling) in siblings.iter().enumerate() { + node = if index & (1 << d) == 0 { + MerkleHashOrchard::combine(Level::new(d as u8), &node, sibling) + } else { + MerkleHashOrchard::combine(Level::new(d as u8), sibling, &node) + }; + } + node + } + /// Build a real, internally consistent 2-leaf Orchard note-commitment tree over two notes /// owned by `fvk` — `(value, rho, rseed)` per leaf, recipients `fvk.address_at(i)`. Leaves /// are real commitments, the level-1 parent folds them with `MerkleHashOrchard::combine`, @@ -3957,27 +3975,12 @@ pub(crate) mod test_util { }; let (leaf0, leaf1) = (leaf(&cmxs[0]), leaf(&cmxs[1])); let empty = MerkleHashOrchard::empty_leaf(); - // Fold a leaf up to the root through `siblings[d]` (its sibling at depth `d`). - // Orchard's `combine` takes the CHILDREN's level: leaves combine at level 0. - let fold = |start: MerkleHashOrchard, - index: u64, - siblings: &[MerkleHashOrchard; IRONWOOD_MERKLE_DEPTH]| { - let mut node = start; - for (d, sibling) in siblings.iter().enumerate() { - node = if index & (1 << d) == 0 { - MerkleHashOrchard::combine(Level::new(d as u8), &node, sibling) - } else { - MerkleHashOrchard::combine(Level::new(d as u8), sibling, &node) - }; - } - node - }; let mut sibs0 = [empty; IRONWOOD_MERKLE_DEPTH]; sibs0[0] = leaf1; let mut sibs1 = [empty; IRONWOOD_MERKLE_DEPTH]; sibs1[0] = leaf0; - let root0 = fold(leaf0, 0, &sibs0); - let root1 = fold(leaf1, 1, &sibs1); + let root0 = fold_leaf_to_root(leaf0, 0, &sibs0); + let root1 = fold_leaf_to_root(leaf1, 1, &sibs1); assert_eq!(root0, root1, "both leaves fold to the same root"); let to_path = |s: &[MerkleHashOrchard; IRONWOOD_MERKLE_DEPTH]| { std::array::from_fn(|i| s[i].to_bytes()) @@ -3998,4 +4001,53 @@ pub(crate) mod test_util { }; (root0.to_bytes(), [mk_leaf(0, &sibs0), mk_leaf(1, &sibs1)]) } + + /// Extend the two-leaf fixture tree with a third leaf and re-witness the two original + /// leaves under the extended root — the anchor-refresh fixture: the leaves are unchanged + /// (they are the spent notes' commitments), only the tree grows past them, so the fresh + /// witnesses recomputing to the new root are exactly what an anchor refresh supplies. + /// `third_leaf_cmx` is any canonical commitment; nothing spends it. + #[cfg(not(target_arch = "wasm32"))] + pub(crate) fn refreshed_two_leaf_tree( + cmxs: &[[u8; 32]; 2], + third_leaf_cmx: &[u8; 32], + ) -> (AnchorBytes, [IronwoodWitness; 2]) { + let leaf = |bytes: &[u8; 32]| { + MerkleHashOrchard::from_cmx( + &Option::::from(ExtractedNoteCommitment::from_bytes( + bytes, + )) + .unwrap(), + ) + }; + let (leaf0, leaf1, leaf2) = (leaf(&cmxs[0]), leaf(&cmxs[1]), leaf(third_leaf_cmx)); + let empty = MerkleHashOrchard::empty_leaf(); + // The level-1 node covering positions 2-3: the new leaf plus an empty right sibling. + let upper = MerkleHashOrchard::combine(Level::new(0), &leaf2, &empty); + let mut sibs0 = [empty; IRONWOOD_MERKLE_DEPTH]; + sibs0[0] = leaf1; + sibs0[1] = upper; + let mut sibs1 = [empty; IRONWOOD_MERKLE_DEPTH]; + sibs1[0] = leaf0; + sibs1[1] = upper; + let root0 = fold_leaf_to_root(leaf0, 0, &sibs0); + let root1 = fold_leaf_to_root(leaf1, 1, &sibs1); + assert_eq!(root0, root1, "both leaves fold to the extended root"); + let to_path = |s: &[MerkleHashOrchard; IRONWOOD_MERKLE_DEPTH]| { + std::array::from_fn(|i| s[i].to_bytes()) + }; + ( + root0.to_bytes(), + [ + IronwoodWitness { + position: 0, + auth_path: to_path(&sibs0), + }, + IronwoodWitness { + position: 1, + auth_path: to_path(&sibs1), + }, + ], + ) + } } diff --git a/packages/wasm-utxo/src/zcash/ironwood_pczt.rs b/packages/wasm-utxo/src/zcash/ironwood_pczt.rs index 9e75a6d0d91..ff42fd0f81d 100644 --- a/packages/wasm-utxo/src/zcash/ironwood_pczt.rs +++ b/packages/wasm-utxo/src/zcash/ironwood_pczt.rs @@ -368,6 +368,33 @@ pub fn with_spend_alpha( }) } +/// Replace the bundle's anchor and the Merkle witnesses of the named actions' spends in an +/// already-serialized PCZT — the anchor-refresh write +/// ([`ZcashBitGoPsbt::update_anchor_and_witnesses`]). +/// +/// The caller validates every new witness against the new anchor before this runs; this only +/// writes. Each named index must exist (`BadFieldEncoding` otherwise). +pub fn with_anchor_and_witnesses( + bytes: &[u8], + anchor: super::ironwood_build::AnchorBytes, + witnesses: &[(usize, super::ironwood_build::IronwoodWitness)], +) -> Result, IronwoodPcztError> { + with_patched_wire(bytes, |wire| { + wire.anchor = anchor; + for &(action_index, witness) in witnesses { + wire.actions + .get_mut(action_index) + .ok_or(IronwoodPcztError::BadFieldEncoding("actions[action_index]"))? + .spend + .witness = Some(WitnessWire { + position: witness.position, + auth_path: witness.auth_path.to_vec(), + }); + } + Ok(()) + }) +} + /// Test-only: the wire action at `action_index`, for the tamper patchers below. #[cfg(test)] fn wire_action( diff --git a/packages/wasm-utxo/test/fixedScript/zcashIronwoodKeyless.ts b/packages/wasm-utxo/test/fixedScript/zcashIronwoodKeyless.ts index 8a986ff004e..c68abf36d9f 100644 --- a/packages/wasm-utxo/test/fixedScript/zcashIronwoodKeyless.ts +++ b/packages/wasm-utxo/test/fixedScript/zcashIronwoodKeyless.ts @@ -91,6 +91,25 @@ describe("ZcashIronwoodBitGoPsbt keyless MPC surface", function () { }); }); + describe("updateAnchorAndWitnesses", function () { + it("refuses a PSBT that carries no shielded bundle", function () { + const psbt = ZcashIronwoodBitGoPsbt.createEmptyKeyless( + "zcashTest", + createOptions(NU6_3_TESTNET_HEIGHT), + ); + // A valid witness (the fixture's, against its own anchor): the NotSpendBundle gate + // runs before any validation, so the anchor is arbitrary. + const [spend] = spendRequests(loadFixture("deshield")); + assertErrorCode( + () => + psbt.updateAnchorAndWitnesses(new Uint8Array(32), [ + { actionIndex: 0, witness: spend.witness }, + ]), + "IronwoodPsbtError.NotSpendBundle", + ); + }); + }); + describe("parseShieldedTransaction", function () { it("parses a keyless deshield build: the verified spend, the transparent output, fee, value balance", function () { const fixture = loadFixture("deshield"); diff --git a/packages/wasm-utxo/test/fixedScript/zcashIronwoodSpend.ts b/packages/wasm-utxo/test/fixedScript/zcashIronwoodSpend.ts index 3c54ddbb8f7..c1d7bfbf03c 100644 --- a/packages/wasm-utxo/test/fixedScript/zcashIronwoodSpend.ts +++ b/packages/wasm-utxo/test/fixedScript/zcashIronwoodSpend.ts @@ -335,13 +335,28 @@ describe("ZcashIronwoodBitGoPsbt shielded spends", function () { alpha: hex(entry.alpha), })); const ak = hex(fixture.ak); + /** The anchor refresh: one re-witnessed entry per real spend under the refreshed root. */ + const refreshEntries = fixture.refresh.witnesses.map((entry) => ({ + actionIndex: entry.actionIndex, + witness: ZcashIronwoodWitness.build( + hex(entry.cmx), + entry.position, + entry.authPath.map(hex), + hex(fixture.refresh.anchor), + ), + })); + function refreshAnchor(psbt: ZcashIronwoodBitGoPsbt): void { + psbt.updateAnchorAndWitnesses(hex(fixture.refresh.anchor), refreshEntries); + } - /** Drives a fresh PSBT to the signed state (ciphertexts → randomizers → signatures). */ + /** Drives a fresh PSBT to the signed state (ciphertexts → refresh → randomizers → + * signatures), with the anchor refresh before any signature. */ function psbtReadyForProof(): ZcashIronwoodBitGoPsbt { const psbt = freshPsbt(fixture); if (ciphertextEntries.length > 0) { psbt.addOutCiphertexts(ciphertextEntries); } + refreshAnchor(psbt); psbt.addSpendRandomizers(randomizerEntries, { spendValidatingKey: ak }); psbt.addSpendSignatures(signatureEntries); return psbt; @@ -373,6 +388,10 @@ describe("ZcashIronwoodBitGoPsbt shielded spends", function () { assertErrorCode(() => psbt.getOutCiphertextRequest(), "IronwoodPsbtError.NothingPending"); } + // The anchor refresh lands before the signing rounds: the build's approval is + // assumed to have sat long enough that the anchor moved. + refreshAnchor(psbt); + // Randomizers next: no sighash while any real spend still carries the placeholder rk. assertErrorCode(() => psbt.spendSighash(), "IronwoodPsbtError.RandomizerPending"); assertErrorCode( @@ -408,6 +427,123 @@ describe("ZcashIronwoodBitGoPsbt shielded spends", function () { ); }); + it("refreshes the anchor and every spend's witness, and the lifecycle proceeds over it", function () { + const psbt = freshPsbt(fixture); + if (ciphertextEntries.length > 0) { + psbt.addOutCiphertexts(ciphertextEntries); + } + assert.strictEqual( + Buffer.from(psbt.verifyShieldedBundle().anchor).toString("hex"), + fixture.request.anchor, + "the bundle anchors to the build-time root before the refresh", + ); + + // The refresh re-anchors the bundle; the key-free verifier accepts it, since every + // fresh witness recomputes to the new root over its spend's own cmx. The refresh + // survives the wire round-trip. + refreshAnchor(psbt); + assert.strictEqual( + Buffer.from(psbt.verifyShieldedBundle().anchor).toString("hex"), + fixture.refresh.anchor, + ); + const round = roundtrip(psbt); + assert.strictEqual( + Buffer.from(round.verifyShieldedBundle().anchor).toString("hex"), + fixture.refresh.anchor, + ); + + // The refreshed bundle carries the same digest as the fixture's post-refresh run. + round.addSpendRandomizers(randomizerEntries, { spendValidatingKey: ak }); + assert.strictEqual(Buffer.from(round.spendSighash()).toString("hex"), fixture.sighash); + }); + + it("rejects a stale witness (still anchoring the old root) and stores nothing", function () { + const psbt = freshPsbt(fixture); + if (ciphertextEntries.length > 0) { + psbt.addOutCiphertexts(ciphertextEntries); + } + const before = psbt.getPczt(); + // The build-time witnesses — validated against the old anchor — no longer recompute + // to the refreshed root, and one bad entry stores nothing. + const stale = fixture.request.spends.map((spend, i) => ({ + actionIndex: fixture.refresh.witnesses[i].actionIndex, + witness: ZcashIronwoodWitness.build( + hex(spend.cmx), + spend.witness.position, + spend.witness.authPath.map(hex), + hex(fixture.request.anchor), + ), + })); + assertErrorCode( + () => psbt.updateAnchorAndWitnesses(hex(fixture.refresh.anchor), stale), + "IronwoodBuildError.WitnessAnchorMismatch", + ); + assert.deepStrictEqual(Buffer.from(psbt.getPczt()), Buffer.from(before)); + }); + + it("rejects bad batches: empty, duplicate, partial coverage, unknown action", function () { + const psbt = freshPsbt(fixture); + if (ciphertextEntries.length > 0) { + psbt.addOutCiphertexts(ciphertextEntries); + } + const anchor = hex(fixture.refresh.anchor); + assertErrorCode( + () => psbt.updateAnchorAndWitnesses(anchor, []), + "IronwoodPsbtError.NothingPending", + ); + assertErrorCode( + () => psbt.updateAnchorAndWitnesses(anchor, [refreshEntries[0], refreshEntries[0]]), + "IronwoodPsbtError.DuplicateAction", + ); + if (refreshEntries.length > 1) { + // A batch covering only one of the two real spends: the anchor is bundle-level, + // so the uncovered spend would be left anchoring the old root. + assertErrorCode( + () => psbt.updateAnchorAndWitnesses(anchor, [refreshEntries[0]]), + "IronwoodPsbtError.WitnessMissing", + ); + } + // Every real spend covered, plus one out-of-range index. + assertErrorCode( + () => + psbt.updateAnchorAndWitnesses(anchor, [ + ...refreshEntries, + { actionIndex: 99, witness: refreshEntries[0].witness }, + ]), + "IronwoodPsbtError.UnknownAction", + ); + }); + + it("refreshes the anchor after signing, keeping the signatures valid", function () { + // Signed over the build-time anchor: the v6 sighash does not commit the anchor, so the + // fixture's signatures (made over the refreshed bundle) are valid here too. + let psbt = freshPsbt(fixture); + if (ciphertextEntries.length > 0) { + psbt.addOutCiphertexts(ciphertextEntries); + } + psbt.addSpendRandomizers(randomizerEntries, { spendValidatingKey: ak }); + assert.strictEqual(Buffer.from(psbt.spendSighash()).toString("hex"), fixture.sighash); + psbt.addSpendSignatures(signatureEntries); + assert.strictEqual( + Buffer.from(psbt.verifyShieldedBundle().anchor).toString("hex"), + fixture.request.anchor, + ); + + // The refresh after signing lands the same bundle the refresh-then-sign order builds: + // the proof request matches the fixture's byte for byte, and the fixture's proof + // combines over it. + refreshAnchor(psbt); + psbt = roundtrip(psbt); + assert.strictEqual(Buffer.from(psbt.spendSighash()).toString("hex"), fixture.sighash); + assert.strictEqual( + Buffer.from(psbt.getProofRequest(alphaEntries)).toString("hex"), + fixture.proofRequest, + ); + const tx = ZcashV6Transaction.fromBytes(psbt.combineProof(hex(fixture.proof))); + assert.ok(tx.ironwoodAnchor); + assert.strictEqual(Buffer.from(tx.ironwoodAnchor).toString("hex"), fixture.refresh.anchor); + }); + it("keeps the alphas out of the PSBT", function () { const psbt = psbtReadyForProof(); psbt.getProofRequest(alphaEntries); diff --git a/packages/wasm-utxo/test/fixedScript/zcashIronwoodSpend.util.ts b/packages/wasm-utxo/test/fixedScript/zcashIronwoodSpend.util.ts index d5e91f9acb1..2cc78e92a3a 100644 --- a/packages/wasm-utxo/test/fixedScript/zcashIronwoodSpend.util.ts +++ b/packages/wasm-utxo/test/fixedScript/zcashIronwoodSpend.util.ts @@ -16,6 +16,9 @@ import { ZcashIronwoodBitGoPsbt } from "../../js/fixedScriptWallet/ZcashIronwood * - `randomizers` / `signatures` are the stand-in signer's round, keyed to the same run's * ciphertexts (the sighash chain depends on them); * - `proofRequest` is the exact alpha-patched PCZT `getProofRequest` must return. + * - `refresh` is the anchor refresh the generator applied before the signing rounds (fresh + * witnesses for every spend under the refreshed root), as `updateAnchorAndWitnesses` + * replays it; */ export type IronwoodSpendFixture = { name: string; @@ -41,6 +44,10 @@ export type IronwoodSpendFixture = { transparentOutput: { script: string; value: string } | null; }; psbt: string; + refresh: { + anchor: string; + witnesses: Array<{ actionIndex: number; cmx: string; position: number; authPath: string[] }>; + }; spendActionIndices: number[]; outputActionIndices: number[]; ak: string; diff --git a/packages/wasm-utxo/test/fixtures/zcash/ironwood_spend_deshield.json b/packages/wasm-utxo/test/fixtures/zcash/ironwood_spend_deshield.json index 884d1b05abf..0f3fd733ca3 100644 --- a/packages/wasm-utxo/test/fixtures/zcash/ironwood_spend_deshield.json +++ b/packages/wasm-utxo/test/fixtures/zcash/ironwood_spend_deshield.json @@ -1,21 +1,65 @@ { "ak": "6ebb833c1d2f8433080abceabe47906097f90678d603f577d0486c9111737b07", "blockHeight": 4134000, - "expectedTxid": "43543c44cd09b2a55516f2834fa2928c7323b46cfaec823edf9941c03c17bd95", + "expectedTxid": "94f14308841d387ecdb4c5877bc5401a298e7fd07755e1d69bf3e313030a7e7f", "name": "deshield", "network": "zcashTest", "outCiphertexts": [], "outputActionIndices": [], - "proof": "ee010bcd9fa00c55b79c0b03208628a91bee363e167b803fe06f91f88f008981b9340cdb30685825a32a34e80a7b229166626cb89b00ac4c6ae7bdf03f243016f53116d811af567c858cc89734a9fe6ebdf791fb3fd31bb53f5d562fdf29349db3f1b671b7307089c6b0854aaf31061cc944516c2de5f4fe92a5e9e703e8108642d505692eac88a8428ab937db083bf002d88db7ae0f68c92710c73840023d2a6ad2a10418dd98d3e755868e7ab94b98eb2d6485038c9262b54dfc902c752836de915b119d1059f715d09b7b40f3f8292dddd143c0b4ad9a2b5913824be6d80a2f47d6de501abc49fde663f934a9fe73f3cb8d19a4406f6959f8a61ce2191a1cda87faf2e88b5635caa1b2fd00ef5d69367cbc81cefdd83431e7f1818d3eaaba75cd3dad4f7e7832b140d83aebd7e3cbfeeac4f6ee87c8105c9c18a74379f6a389813f3cc548a6c2f162438d2e702d5a09cde82af5cbe10d7efd0ce8ca7305b6763da08e62cda01fea340dbebf385e82cb270d1b1ee6fb145094cee1fc9ef7adbacca80cbae3aeb56089731eeb15116cc23ab4280a7f0679b1e573c00d270923a5683d03407724d4b88bf24a55be349634743cb952f6a6ca214a58674665a91d9a34234024e4edb2e84761bfc8644fede66e54e01aa0cd6b37467f905abd6f09c5bb65fdf7446ed645408978720aeb0f5ccb691e3471f893374a2a2595f53fb625a673d3077f3e227510f12e532ec7383f7ea701575d2d6901518e4018cb5200e6a52efc1b5f3b714e840b7f260fdb89e2bd1d67729740fda38cf7c289a0662af4668f48cd15957685b62ed33ecb27dbf4e35709eb1a280fb8133d38fbd42393d63f203808fa0975d55968cb9819c204e744f104df585ae0271642a03543c2ae25d637e7bbe940da3cabd5ede7080146f700daae8f286263ad1405b1c9c651b04d107ba813ab8a6c36dd2fdd203f739db3129be8f993bdd15d18f3b9af1a7c14f653801043d958566a8a7635e0cfb8d416081b6f877b18a2880977be3d8ad68d65a002cf07ef7ad5b46dfcb7d981befc208f4f45c172c771c18b703fe3c19fba57ac9d4731d3c6c0fad2530574bc9f935d2edd0745f6b7283008026ddaa9f09304dc2ce8be41cbd19f17bf9741cbd5f7d58b6646abba7ea2baf2e87c765959378a280f50b0c4435820bb0012d8723e10c3133b9d99f92a8cb20165066bfd1f970e61920c3cf1b731f57e3913963779d954acf1918377680aacb5dac62e56833c933494d35f5afc2255598a60653a049277c9dbf86a39522ff5c3cf089e6a7889d46d8b0309f586031da5914e77fa409f611fa99f1e520a8538801eca81dcdea6325ccb2babf17dd31c07afc24392bfe99c3da8fb4fcf5f1c18bdc6dc5400b004b4cddc450f6ac7040257d4c3397f4363ad65795a8e64598cb5bcfcd2a82e7003b5cf7a3b75d8058bea0d75c551e9c8056aa824920c0dff7f453773eab9d05931e71860e3fbe8b9fed1f12d481686f16295cbb8ffb64dc9440305a123b8997d19bf2853984e4db706d5958cc634de69c308e5bac4532057ed7d5b624e59fa7d0ebd5404d36a5608cb44ae970f55e2f8df4d4999d210579106a6a0a57a879a6f33fa3f80ce678483405932b44e7df36cbcd8656cd14db8976ecd92401b72fdd53e94f4990d616f4c709c70a138736a2db64645fdbee615e99b6d8aeb67e248652f1c8ee9aaf6047be7441416268e0b32280ff827c89b600b2719b276225b85ac18a51346522d35a4a8245381ca7a1a34e95e7e303c2402cde70a0918b736a25d0eb5e9f55828b1126ee9669bda08414fd3079adce2f3f057979da410244f973131bcb058101d4618f42fa38588d6f1a814402088707cebeace3fd010666b49a111c3a7f763e10b1a4962d24c2c773625d5ee9675d8f0a5c8d78222fc0a2ba5503a64df67345d1a7d4bd79916949e40d993ed17c108e329f786458e47e92782cc23c06b5396077ee50264daf4e322360aa24de12deeb8ec38f6d27e52710e632b2e7f1dbff41e6afb1dfa503620a1d389398d5a81471e4b0bf0fcfe2ad0df16ea39cbdf68b8295c3aead11290b1efb0e83221c4d801e4926493ad0013ff28d8c316cd8bf48aa50a8a70e628f361db86de15b913d140d1c7645a5af914690800aa090c06f4b5ea804d1cc7e0fea66a94a6cc61e46cfcc6ac0f2c63945c1b841c7b0b971bfffa85d739df667e2b55cd82a35901a80019e116830830ce5b8de06abe3ea36dcd72e7cf9ed251621fdda0a5f65e5482df1082967fd2a65a5c33e301a72a1531c11a5c35df26d706fe45f1c347e7195af2ae197cf0ae18bf250fed5e08381e60a08f43a9f86fccc58c2bd015a357d69c9109f5c11619b4306ee9e401083f9ad52925cbfab88a6cf2cbe2c995212af7509cb88e39767e171e68525f05dd150666b92a91162fb66560b047a7e9a384ff0dd2897caacc8ea179d388fb848f2b6170f943e612e027faf120d22389403bcec1e79fec8741b5335962624cee48280a0b36213d0a390313b1dd1ad1b27cd1ef8e8b96ad27ee4deedb2a009cfdbb0c5e842bd5b2969c021d6d2c2d28e152298538863196a4b27c977a28407d01e43b0243baf04fe8493e69a4c0cbee1bed45387b0e1220b11aa16ee998af9aae3831d187f310e6c6040731490346548e960daa18e294f51df47ad5f1b6494704e210e5998a114ab368785ec2bebab11e9a024a9f695b9dc391b3148b79ecefe7ae288a93b1e97b482f898fd9ef94c99b57aa7e1166fd8baf849588bd4873eec99e37848b776e5988cf1a7833111cf44a01da02677f09aee85f389000554ed78bfd00a3e48854c1ee59577b6da798f4b035861dfa42390ed18fbaea1a7ddc28d1a30f7651dbb719d788e71ee198fb785c035f3e5601ff27a5692433bc1598bf65fb315657a920f7a69b4914cbf1eeed14ad8186387881b1c473cc14b702ac6230a831d082b05497630cf0f26dcd7879294487585aa5c2f11919d76cb8c8c62aa1121854451777d5dc9df3d57a867078a8a9f52cb70f50d75b40d48f2e49ee7768211d7f876885ddc2521f2c9b61ab15c95210a5acb9ac60410b716b74c8036ecb1633840ad60301b11a0b478262586bee0d72b93bba057c71e18f76691af2fe9770354cdf8fec26818d680438c1800d721dd523e17b177ca226f6c6037f4a8c014f1f289bd3d815816aa5e00edd883e687de423cc0a26b74968a9beed9ddd3f90fd23d6f9b8a589a1ba97c59f2b9e0217dab1f9a1dd669cada4fc4d3bd6e6572aaf2e955c376115ab849c44300ebe40fef0ab91803d069f4c97d32cd69b7347dbe51d60d1faacc8910af854bdad19e4076e408bed8e3c3581c9de1a7f9b7b6d88dd0eb1add1e439a0a9daac317743e2c1db3941edd75534f9b45df95fc85261f534347de8074159d2fd08907018855b71c379f620cc76cc9eb6696ff411fab32afd017de1a0f950b67eb52494d44b9b70e971efb4d66cdcb4148b5fc11941ea95e13c626c0b7915cd2edf5eb0d7fa6521315d656be0edf0ffc9a2b3a1985cba96de02ebbf27fc561f8536dcbae2a3e3c3b98abf0078e5f8c4f258652ddbeee63c9f07d57b47fcfab3bf77f8c5040cdb1dda64c40c952a19a8060faec5786cb7d5410bf4d1a7dd9b06ecd0966bfec3e7806e93056560dbe353c2039baa08a2a60bca0e1a180f69afb1dd633bfbb44b160d065a94817d887a4fbdb636191bbe0d464c1351edac8720bc7d1911a36ee17f79cdc42ddefce4ed1430a4b05e53efe692a01962f2c57f7fcee40f49b1f4e2411837e8a265ef0455d885e4748f1468bcc2f32f298b9dba40ca71bbc7f0872b2ea5ab8b5e6e0bfa20b00d1c227dc2763ec86624fe62cb047cd0aca940aa5a9aa0d6230e7e28ee46122f9b9c071704d15ead7439544f54eaf575f809d24fbb4edf3971bf272687a57e4764f75877af322a6d4837b8440341c07d05e8ec103560637b80c93efe558d8ca27e62e7fc6f3208dcd63cfc84a493495aa67b4df9a3a6e792125653287583075b2d924df9a11eecb177198660994264967ca18327c0465d965ab5c4a921f622b113e2e922f0317e4ac40479688ac3c272014f7e746c9d5e113129bbb5668733c8c101f4ee01052c82891ce397a678c0acfe68ebb0ce589d22b7ba19a8ec9c4ac7849fef7912e9b44c351dbb23f6b41a83cb6ff27ec009266ee1be821ccf77017d48a4b8bda39628203d1ac4e5cea56c275f9a616ca794886d42b47fbf9ac6025f78bc35964776706949275ae006b720de9bc7475e08f2a305e4e0b1716bb597f3f9d799bd392fe0e16d25507204608f588a8e9f4ddf0e0f807142af7781e4a1d96b973cc74b436f4df30d9f56af861394113df206a8dfb24e77af7fd4f2bfeeccc7b5af5def6ddef23d24febcc7984b0806681a2213a83b6b248c8abbe013487bd9a8c4171ef76d47b9361cbcd9296f0f3fa8bdc0e3940a30312fb75989172f5675d75678b5f7f0fc662a3156bdbf9cd7ffa705ef9810f47346a8142ed6522b886d53d4b13d7f7268ec1876ac484318050de1c175f966051c0570511053834eb3b82d23bb53d927ceab256aa73209eef7ee64bd14dfa48aa9e9392d7c3ad308552f77ba6322a65e05d0096d9ca4e75e75f650429e7d0ce20853fb93f807682245b421cc636e4ec447583b7b8ddf47092577da7af224a5dbef8b56c77408517100b14b6b53ba2ade7b9106c49a8d2da123ebb47ef7d2fc6a4aaeb56d0a5a084514acaf5cf9b9a4e4ae0124dad9b6d6e8d65f6d5e2b3a343e90068afa3fdc080fae31ec90b9e97891cec51cf4c67ebb00447289f6fa64bd73b80373dee36515a0846c1ee232aa2936f5b212dc05e71e71d42e31a705ba7f50053b96d64576192581dbddf600d2f44d2a26337da1c5c79bf85507df72a30fdcf01e0cbbac4130ae6430f6a9f90031d4543112560ec28b270ef90a3a4dab7e6e06659655444a412038727edb9802851a80733420373487eb34a51610ab5ffe17970511cf878f35b09724a03f618176fe78691a754fb6c17ce8d60ddcfcbfc1889c01f6a8aa322145958318eefe9fb9c16a701edb730c1d11f8caa5afe95a2b00eab11d2a6c3b17ac340f452d66748b44c2f204025f686ef262c9bfa382a8fb628ed6ffb7d56c539e3291aa3adaf3bc5152ed081c02abd65df9aa5f7f05067a1119b371eac46024c87cd8db12da45654b1ab01e24cdb0f1c18bbaf6a2bdd2409cb79ae744387723ea0874a91e35acb93d619531e428a2f1a46cdfabb170c9a1bc9e641f0ea084885710bb24a23bc328fa321338d317c523f9e773154b6d251092fcb9f5ba486bb4d2265e6dcaabf2b5d47b0c3589f9f912b73e4aad46f9fb89fe06562d11b7b05ccff4d1a6fbf8c32cc0a80106b1a3e48cc08c0670676bba78f08796cde8118f986103e46bcc80f5984b3e7e1c8be57d1cca5a8cd1e8dc0e3c922b63c07e883428937505c7c0dc5bb7f385d72a0712f99fd2f63618998103776f1e80e43f65eefbc2755ad61b44ed4935213815a19203adf151419ce265614500f75f5099c615e72345ba5513686ad1ee5a2f35aaa6fba666e91cc22f734b3a0efb39e48f559a22b2c388cf867f5fd28b4a73369aa62bb2dd5495a16a3d41c32d3665ee963137857b9ef879f9fbaa6b3585c4827a3b3eb910c2858ec893b27b37b56090d71d927e0b19cd994b8ddbd8bbc4fb233876aa0d59838f3cdf27a4b43c721dcd2fa489e6ef392b278deb5d84f93ae73fb3086be73b0f2115a7515b94d74663aef3763978700627d4898e7d2a6ae936114f159dab6b2cc6434b1e243690301822c9bb0fd63fc70bb88f5b18d72365c01168d48f27e7115d210ca19b51113031bed544b67aba5ab169a0fe37f8cf821730369ac7b7c9095c3871049df6ca9b1ee97d5ebc4e8119f9d19f796819bc7d6989bdcc851352ebf6fea8c16b44bef0677402eb376ca2d51246f1c53fdf948dd38c9b3d8598241bd77c0fa5c63df63d0db720fdd7fa63b3162dfb19b7c95c739f0ebbd9ff44a3c0d4deef425c910b795da153497a04506176869722ad89a8534d85af1bf708ac0d978f61267e1a10fd3e4bde66bda2772278784440907b1743acaedf61faa90ec45a2ff6d0a365f0cec4e103565ffee3a373e3ce2a14e4db810512d2d4b182ed3dc09a44d8eba85e580637e5e9a5733f414e7e81f2a369bfc808bbff0e85299916a320651ae58d7a57c736ed619aab18270fdd2ae0de7bdf1e19adf451d380c3033a6593c7c1512aff00f51cbb9f14a3695b016711d9910d450704342715b71f5a15a695e793eb58539b77a47469a91e7dab61f5c8ba3e6530e9a7918de7524e7d2a59f014b960806ad532d52d6f883b82f4e67d58d55a27f15107667affa7fc49965e8840285f1227a721498ad7a543e162c1977f76a69507619b027d49c56acae2874ff2ad483fbc44ec1f2d138f91f0f266ce628d1ee2c7a229bb31233c5c04635fdff5b7989539ddf5189eff813a067b61d4608d8b43415c9a787d392245eb98e90287ed6833e73709434d7f0c0c40c447fd2a879893dd72af6cacac3b2f4d145e847aff3a8836204222237a26004f59df2fac8b339c3ba692e0f06212a2e7e040a207c18608fe485464a717dc9e43a13189c30a053496d00582c8c01632b7e3e5cff8cc5da72655e7efc1a981968db7ff3e4a2e8858240395cb1e12e3702a7d51040bc6a70b5eac7069f6cc4e8c62f076f10db290e00e37184a42d33a5f6ca9a0aa360294fa0876b9ff63ae575e3234ab5ef6cdcec7bc3e88ac86cbd56e7eb4be6ee5f6d720e7f1af24bcd009c102da3a436c5b529d1ce58acf69813d48ef5801b0e7b9581cf323bf032a0dd3e1d67dad4ef40e4eb8f8bd0911f65e365aa6dbb18bfcd9eae64dd7234002c8a7a749ab57251c4bd3382a67197cdb480b535ea46742d9f4487826956d30e4c399480465b9e866f2cde6e80701dd5b7f548b696b3f7af6390b665bab66ca3edeb555e1627116f171f2135c682d", - "proofRequest": "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", + "proof": "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", + "proofRequest": "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", "psbt": "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", "randomizers": [ { "actionIndex": 0, - "alpha": "8850e92dd08f1ae7f04877a95f295e13bee31468898894ea1bdddf55c403c232", - "rk": "f3469824455da85b6f7f7de6ac2405d2914acfe5e171a0e0f6e45214e1a655b2" + "alpha": "a9af79633a8f85750e01d4ca3ce3ebbb074d736cc40238441afcf27fdd074a19", + "rk": "fb9f187ab8a40164099e383f563be8e6aebc90e877265c24198b50e3d2680836" } ], + "refresh": { + "anchor": "9a784c9e5b9c5f3163b0d6723a50fedb1f5f8d172dae0bcaeb64e05f2319443f", + "witnesses": [ + { + "actionIndex": 0, + "authPath": [ + "e703000000000000000000000000000000000000000000000000000000000000", + "cb4c336f095e14606787ca35145715c5acbc8970fd4e3d6a0450bc344bcfbd19", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000" + ], + "cmx": "38fe5156c36c78da72290b6d81ccade9932a4a83500aa8962f04a6fd593bd30c", + "position": 0 + } + ] + }, "request": { "anchor": "277302f645a4c6b7ea56fc199ba39f31721d42d2dd08813bddb57bcfeb5e2c2d", "outputs": [], @@ -71,11 +115,11 @@ "value": "99990000" } }, - "sighash": "95bd173cc04199df3e82ecfa6cb423738c92a24f83f21655a5b209cd443c5443", + "sighash": "7f7e0a0313e3f39bd6e15577d07f8e291a40c57b87c5b4cd7e381d840843f194", "signatures": [ { "actionIndex": 0, - "signature": "fe506e354589ed4036c2b82d7ed73b64568db57ad031a3ca4f4110980aa1f1a3c183d98483de005ee5ec6d9415bc4aee9c990d6305bdb8fe5679f9897c75160c" + "signature": "8c38288041561defcfe0f5e6121fa71abb67d79139e19afcf7f49d4e02c7da1fd36c75ea82602b4adefec67afa4e3eafcdccfc3f92b220b7a1840d5e91ffca3c" } ], "spendActionIndices": [0], diff --git a/packages/wasm-utxo/test/fixtures/zcash/ironwood_spend_transfer.json b/packages/wasm-utxo/test/fixtures/zcash/ironwood_spend_transfer.json index 8413a8026c0..74cc08195e5 100644 --- a/packages/wasm-utxo/test/fixtures/zcash/ironwood_spend_transfer.json +++ b/packages/wasm-utxo/test/fixtures/zcash/ironwood_spend_transfer.json @@ -1,7 +1,7 @@ { "ak": "6ebb833c1d2f8433080abceabe47906097f90678d603f577d0486c9111737b07", "blockHeight": 4134000, - "expectedTxid": "b8798172f78840a67a1670d8160843efbd9f00ca5e517f16dd699c5168a90b16", + "expectedTxid": "f33d4c97d89d3c5a67d07731aa120fe6719c46287dd65b6bc809769ec317ea80", "name": "transfer", "network": "zcashTest", "outCiphertexts": [ @@ -15,21 +15,104 @@ } ], "outputActionIndices": [1, 0], - "proof": "06beba2a6c628f9b5946b6a253e64264ffb0f010e0eeec4a8950bf1b0d9fd604494fbe481e1e1def8d1e018ec5cba45e9342394a203af44256e4e1e01a55242cce1ed5cac3dd9d67b1f3569e640e544f76ce2c7fab2661c4a5c51dcfce03d827faa1d1759480fe4283088578c400c94ae86eafb0b1e470118d13d46d037fa109d89c403753de8a1b34c5360ecd910ab62266ecd80e39cb19c5933b5518b50b053f952883be4b15b93e8fb3b25ce30ca34158a37a27e5020f6aa28a47e299170d9f6f284ed0efda0e23b163191ba1717705b9146191fabb05c436f372dde7f109c916ee19169915f81eaf2295267cac02dafb433b08a644a66779427d194f5a885d7703eca58e6ef8fd82fa24de74f45da6079c64834987b1407f7dfb63fdbe3a08cd106c753863909b4e16ee084874a1c229de64f85f6f679b7fd9cb705e7dbdbeec02d1221ba294ae7b22bf18100468ce82a2826130eea4b36173b16615590823cb39bccdd8b92d6de8fb463af52dd5a1416fca7d130e31d1516290ccaf4b0dc55749e3c47e0b070d5a9135c682901ca6e647b94b3de5ef9b095cae9c6f822dfdb0b1518ad728da4f079f1fcbadd35c4f7f2ed53d2bea747d23055fb6127fbefaaeb78eaea0cf9376608d19cecaf70fdd09246cc8a6c7370c1b750c1c9a9206d1033c0e4631fd2efadac76392df6b020423439995b79d8f1ca808896d86e12d4e886a9ad8db9618f29e41b67f4fd13b2c1762a1869a35c1e45a25d9c545e1b1b7b92f7d2de533c2cb2a72e0c747254e408fc01f2d764df965b7fbb6339f5037dfd47e2a09d9cdcae5782d8c9fb6708eff4c17bf9554f743e8006558cfa6521faf20679bfdeb9c711a026f09c2ec7ffb6ad28a6df8c0028c894f493c53833e18e1897079f145a0f5accf71dee404d9a7ea5acce7c046abfa5956107acaa284928ebb898d08912b87f36cd9ade5ed814fb8302f6cc3f256cd9ed6b8236d279fb911b521f5e11dc4db1ad7943e19af1d97af9d8141848ba0093630f1f78487779472ffa2d3191903fe45ca8479fd9f480efcf6b5e91dc771155cf194d298a5a00d3e8a68630c6763181bfca044ec20ad2ad772bab797cbf70e5906e363a854fd9fe9a60a4a2949ef2e60173c3edd9fcd0a9ae6d70565abae269026ac8c59e8a9bb5205a0cb7565bc7a002f714feb2af99e7cc80a3046f42dca21cf9e2878a3eca863df34f5963ecdd00cbc9b87a70654b0c967869e8aaaf114806e2c3a602fffa19cc6423a6bb3fea40d90443796d27090959a277bf5750946db426c6cab967da5139d28ed9800ed3207ef1a73e324bf48f4a6c2e23c5178285d781abd6aa55b068031ae5b9e79470bb70d8ab1d0eeeccd7b8145202be310e1852fd28f4eb36e12c0c19de1b3b51c033be530223440dc00167c1d75c284fa029d6f3bcc6c77c4b3890063dc1efa270e63dbd97f2b4a18f0e4a48e7ad5d15b52698b273101def42a77ec27873de8d161e9659ab5731f70dac8bbef2d522bd7e2a78d77618152d786176d499abb82887ce64ab57f3042688a4c80abc75a33952399b62a2264e52ca771b440c8ecda0a214a8385a6f7c58e77f5b794bdf3f448bf97c02acd3699fe313d01afc8f4cedb55dadec7f6bac62a67cdb5efd1fb56e8f8e96bc144367eef2a5cc925c98871496df08b84069495dca0898b3af0d7c25bff161f4f38fc5fba07ed6bf290852494dbcb31c4b9f517ea9d3afd360940dda8eb8316ed81048edfa69e4bd51fab27f60c941a3b21aa69dfde491c9b5b17b86ec1f55b52b10b02d09426d0ab3592f39c5a24e95859a076a77f706c4dfd18391a96ae3751c7376d0dae62615dd3b49a908dcfb99d330021b93ac77a48a904acbaca538e6e636c7aaeb8e2fa57aca0b96b0556f09bb0aa26d8728063b44e1c8ed68540c0b3ac0e68f408b27ea9f9e262850a48baee8e8f41159f58010768bdad9706074690f748dfbab1fd66332046021af2a717d8001c0075df71d11574b05fb59f9b27b6688d97c713ac0c5cf0c8c92095bcba72ea2fca9a8776fb62426946a3a71d5a56604f251631a0d6035fd831b02d99695e0c0be645582615c6cc89260702485860ddab0f90b1e83a3289492a69133379cb5fb882d4212706d40dede42f962c5f0e8f7ef3a7a328f5b32f65a13889c804b34f4e411fe95bd5bf9bbf035e0744160bad76d091b97ec52b10cd8eeb0bbc1ab4135fc720940cee43c9ba2b50e0405646da7b57e4b9777b7be6cf1972c3c6aee51d64fd212cb9a6c5207d4f1a5a96e25c5c9f9bc20ebf5ac53805551bd208dd4f02ac707f031c9799672295786270e46b41cbda7429bf2db3b6890d891c1d75a9a9de2fe86bceda0c1dd9c1b8e9ad25deed70af4f30a7c4db3137b6d35711595395757f917024536c7e79f8253be005dad18e10363027bd4d74e78c5266301b45dbe3b695bf0024d6b8f452916e5a43fb6ea2b79d2933681e73ed0fa2ef59c1ea5e20f8a883065972ee81eeb4448f317dda3343d009d12bdadcd0456333488d8f9be13e25d7d098ea37dd11733b7885b6e49fa4482ec1ecdb5a44ff5e65e91bbb63b4be0890f88d8972df2765684393b7cad2fdc0294c74bf9847bc2a4273ede4c09fd839d82753fe18316b994c63390e4ce36fbf0eb0d812b9ec18126cf4bcb6ae0249efd3da86fa9bed21b299fa97bd69fd20f518d53c405e4a03f0da4ebf466a0fbc08cb7294c98f6e3980dcbfe9c9403f34881f156474e3962e88ae8f8333b19e19ec262832693257db01ed3e160c2140bf8b237aee07c18f23a7340e3fd517a6f4a9ab7d6c727383a2445ef1b28db480353f32d2f09b2bd79e43e8819ee0fcac5c8415074f97b15cdad6611a15db6739719621b2e7fa86a34c79a92dca08342037509cd76ab983795076f8df1d60950e8f05219253fa4f172128cc372333a6aefdaa27bd444c1d180d6cbd8f9fed3fb35cc02aa2d071d0fb59605708c31f844918497555de652d4d8d1663c49d96ef2e9cc12d2abc2b0cafd278c2fc478c3bd8ec3c2862bf6ddda6ee8452e15fe025669c1836f53edb6c8888d55bf0c5c6bf090695a687b6c5f7d03e0babb61c54811103a30826ae7a71917e59bcce1ddca1d74e4eca677c530069cf34ad398de1504d96a731f74a01e1cc287e050c7f4e4c595599d97d19a0a25328b5601c52a3e3ef5342091610f52a339290c5eddd277aba68511260700d4d0f1c310c739e4bdddaaf7c3a5108fe8781521a43e39b7cfb82f148970597f2e667ef0f159301292f6caf5136d32a185161930fe40309dea10ad10deeb79a9eb25f9407c3e1ac0c26eb86da3ddad6aaeff48e8bb2963b75b9dbe9333d9e1b6dd6e704364672b6705596b490250a4cd8a409032c56330c3d9f067906cca7b2cce2ac16f293794b0c690030c6158ff7f8c771d4b6ee2dd7b97519518dd4938f5059cbc6d3753bd307dbd4a2861f1298191e50d563a874796c2c23cf36c0d90ffd63c8903fdf41a02cf17e147f1c651590e0e81816cfd601b08af319dfcfb7e721b5a8fd25bee0bff072a8972c045a50658654557e680aae11c155e1ffeda94c2e991544fd6a3c927fc877d8470cd6d5e3ee76c6b3b58f6cd25aac5324070a65f2bab2b052ad97fd3201e6d004337e1e39589fa1ec0f1dbee4735a4139c1284b85ca55ba68ac4b2583810b39552ae3e88123b3540e09e1ab4f89cf606193786dc0399ee4a4158acb8c9afa05711e65a57a7d380ecf98f6dbd8c64b910891f1b4bbf8d4e619cedd5299ac7a66cf06741c6217c5294087a6952f3afbd20349df5fb81476a3b802d0ca1ff0941a1305b4f4dc66dd0e5f3942e9998cdbc0ac36df2faea1016773192f29f88412a6c806486d9ccf83ce01e50afd02a4acab94c3cdcb6e19f8e2f8350b9d872268d7de14bc5806ee9c1ecb5fbc478728a8599f68c8ac1df66f2cfcd2e3ee9df747b4702f88644db8b5cb7eba5605a6659c70a68b8e6391c9ae797b78ca325a6930f50d0f14823ce0e0198bc05d38c4af693ee6261c7633d9a8da794a4e3978f5577118181442c0d5498cb8a69136aef369d1d958133a76bcdb19dadbc86da653d0f00d3bf5126f360285155390421f65d6b1da0b63a190652f4a800bc3086196cf003627efba8f979acd43ab79f728931b9ab86c66c460dcf1f174f570b829db2a2e392ebf28c7dae829366b32fe6f32408a038579fd8125fd99cad4d29475f45f225d242d4c3cd81a95b54d510a9013462502805b3dbd0832fdb2ce0f4e9a1106d1731f5062535bb660fcb4022d7586d30fe43c359e3fb4a3458f08d08e72193aa5a10d2d525b264b948e300f64921fd681e973165f64a968e0ca28d92f36290093f1174661b35600ce1f2d22cae6ee0e7784f93a84fa094f272b7d3283bccf7b7b99313842523f66f7933fe8578d7553cab6d0761e767cc5b3ef996c1adfd9ee46600643613f16bc87d1ca9a465b8d633f2b002701d46764dff1c829a409dce28fe727a8565e69941895a22ca19ae01e718ebe38b1fa9402d6dc6108368eab812c41207790bad795c15b587911907fed16b3f3dac36484ba35755e49ce50063164952dd2dafb12a380d7203f396e9d4793eb352e9837f050d5bfb7ce4794de68b76b2bf264f13b662ebec82f1c3baf834cc02f703bf17f4e9c4ec32fb61abe1328073a0db5a68d0a533ef05e4c9b3c8277fe9ebe8f9b3a342871a21f8918a9540fbe2ceeb09cb830754944398bfcf6b14ed0c8a6b2b74e68826559b6ade3496327a638fce28ce8e54ffb6ff9b4e415181d102abbb0ecc4d3e69052e809aa08c65c9b22b4bb01a22961d6fa0a28fb9677ab2d17ca2528d84d3d190b036bbfa548414115561a25ca2049e325c919e8e452fd68a57cd3a7ca1129a631cadc431f4c0cc4392aff9f43a03c8b65473ee860bcc88b3846956eaa490d68818e06920bf9eea705e0d4f5a3b6e1bae628864e26a852eb459a034aebef72ef2a5a7c45bbc24aba28950a2652e02d2c0952d5004bbb579d764f07d7f841243d255c0fec0a7c96a8255f4e15c2f0b225ac9fab4a003238f8bae701b8692f2f8a402856bb27a83efb0c6eefb414349fcfc60b6a402d94ef0589fff89c5cb9147ef0ddc4c06c1fcbc022808cc322657240f748d245ca1a20ee11c39c993499bc7af91e4582e3efb0d7296716aa217ef8d7b7b8f56ad9b75c9d6ce6bbacd44fdea57cb03e9aa99dc8562f58d478b98d1a8389afe2fb00686c5a1ccb88d4158d73ac81238e8fafd5762c2db2895d206eddab9035da8223a98448896fb3d13362029a4a98c3da7fbcaa683fea781d5484f1fc24ca2be32d7a679f1b11e46923e6c1c31bbbc21ecd5c8e082be4a866cb3242de3178066fd1b69a3adcc5b6b59f0f975a2a0811473ad4c7fd06542a092841252c95d3924bb152b38c59abcaaf4c018eaa81dbef9bd7e24b132ed67602d623810ef1fd46e728908b094af3a17c04a8fd156d021b7cfae3c6a8264949439090500ce7abe1c5bb2bda8c85a383f994f8c37284bb5b6c0ea0029c2c611826aeb809f1723c0aa2e88e9fc348f3723b003ef7f7a530dec30a0e666a15acb0ac458aaf3297781a402180013cbd3741c73f110219a6837237c56359573657757022308499df58fa9be9700e48895a7a62b3df89a9f194eada3181604e0eb2586efcb675aa501234c03ebd949ffa8e77984a45328a5e7f30c46ebeb98d0a63e268ec64ef79e934f313e76c1e370a694815f4f832ddc33d1f73ab1b5c971ac5a05c5e5c10fdffcf763bede61657b61633b1169696b511caa8e6ecdb8e8300cc4186278fa9558fc28de613d834fbb4a11edb5f772d8fc11e54900e8c773c1fca0424860682cd88878ce814b8f821153e0f3f43378a7e6abae00aa536f056107cd5ed44af8e55f3cc44791d2e4465a07068737c57b96781a9ab6c6f0dd0402e69cabd8a06de6a8445870316b82a6230395b6eac2af3cae71303e74c26a43f2334585a374e80421c708db391a22555f7b03943192d0e65eabe8e87767a1307328c187fb2ef7a5a8930a569d6db5863b68ba2a2279ac77e403ebce5bedcbc7d1b0cf672ab7e7b0e19d7d73b157b172b156d0e7ad71c479dd06153bf92144b3a31a447fa3c53b8b0d33ea436da2211be05c7663bced6c85b40859b3e4d5a2039070a41ef9bbac1343f464f35d802df3b75f2093708f9d833a0ff2a8f39c2e03a0e41dc4900831ec9540d1fbdbeff675b6ffb6e97c89371eebdef228c2542f1fb03e0bf89e1c5b99ed7b2462c4585763039094faaa1aba1caa3cf7d92ae4b90361be685aea5c3c035115a988772880398c7fe81b2a133a6f4dc293e54115ddbd627a508fa8aa17aca30ee5295ba8871bf1fdc580caa6d779620109a654f9f7ded0803dfb922f7849caa907f25024ecaca7e0c890ce8a4af43eb0a0727da6b9502208f6f35e95f8fc92539cc061b1880b46661314b84ead53b75c30a75138ef3bf3bd4e0efcf8296a09d5d9f05760471d44ff982538173b4a07d28aa64121a12691b28bed339f73836f46a2b1488e7938dec6299aaef8f72cec7ddeacfcc69790b081f615076e164979dd71d845a40746dfe61c964db997b0857e7e1db76d7d7601486b840866c550a7091113913e090b6aff1f7ae42ebd9eb3574307c01a1a87412180f3ad3a06b8e34114d4b581b18a67fbf579e963a80dd0d9e1cf6c74705b5333a6e0eb042c778202c8fd0fd6b5a8c311e8ffa01f9b6d9f07a9bb2823bf6cd194a10cecde832405a933328fb05f9ee783af69271fdc184cd5e259eb502824823a4335f8142e8be685ef062d16c34eb29f779ee222bcf00719dd89e439ce34c0a2c1e58208c42ae921941c488a2c133f695e94dd55b180a4d9170a90442828d2f417058bdbe8eb7e47f17071eafa2a0c2cf012427cf5e5d62827d86e83858891e5ac53006453c8ade60bffa75273a92312f09fab20cd010a342f5abdc5fdcda1bd9c998e430be17ac2990220757fe2e96fe4adcaa62c7e46744b55ee5bd6ef22f53f6b3c11410c3d8e9624dca3d4cca4209dbd0b9af3dc55731f405217067e8274228c9bfb64f3509401929236bad85262e18c1abdfca6fe6255c0954c27c503aea2b425ecff1a721e54663d56274f17c9fa4de7d90e1168a9e4ff7544d8ba911ab4a168363e576ee0ddcc9a1f74671651e595783ca6c6baf720b7e2823ec210093d0e1eb6ea9d7d57d72f75df6d0e96a4692111088be48b80b01680da3515a077a5e2281a9ba60d263a10f82b89a82b1e7309e4b161e9d6b9600de34710bd2096dbad4fdaa774b2759114d61de5fc1b5f79669cc8ab6ac47106fa81b855633013eaa04c7534ea3037533117c1f8dc62b69043a0009e3e66ae383cb058a4d4a1d9cb049b837c1b44be5d907b2faf446a11df53859bd3081ad5ac9be01d1985620d619916d460a109b8079d242f02779d22ca74d4b92614e111a5f36522765e415878d22a62a063904e2bf1191bb85d5ba55e209d153c17da5dcb2b8755f74141ea4f628d060f814910d4e36452cb39572a02a069c53c51bf343b25eb142f400357ecce6460ac9389d2291e46feed354ae24812572d93b4039f29a4fe3c8799b3107247687a3c6e3a552aa6b7a236d21cf3db1d9d4fcdcefc5ba98ac4fda0959008fa6c49cd3e110c971c1c79d1c4e9e33a943546d817b96b342beeab428a9363c13a94602cfc58435ff30b2aa81c3ddcc4642102280507f3f143977353b3e9213f209b35ca932a4c1cd0b02d5ae0d9513a4c5de65efbd70d14d1d0bfc596a6009797169cff250e17bc4556a3621a5ec5e281f578d3810e9e67ad02352dfd45822440afb6acd75d023c193bf215fbc034f4d5aab5ef2924ff5a7047efe33bbe1273682750d88c669330661eb98ee55dd08d9c9e80e11aa48c5cf89180ad8fa813c1c2bc4b8df7d28261e00f5aab3f8aa77323c0fb26f258a531f93f991295d910690bb658648c59b1bad26b57a8ce620584c0b3a99b4ebdb37ff1d919ee1929a019b11aff1f782a6081fcc4689ae592ef6f1c0b08835802a12fc34f4aaebd58e29690e396275bfa511088408642a5e5ee2ddba2c371d69888d4e04f0c5d7531717d8751770c54421c16a042fed300a68d3b9c87d708da0e35027830fde41f1f503209c860c234e5cb33145bcae6813ff9f596bf98587430fc1c489397c7d3b851a535c5c51412f4133e834f68734bf76ed70613b3385687c8dea3157a9810bac2136e37eba5ced820c9b62cfc3c5f12dd68cfb74fb106f61b1cfa4d67917c5582820353ec0a34c87b6fb0c29ebef564e31f15bbfd7ae9eee6a67039e09b20e571f58ee4abfdcd7fb34bef79d7df8d82d981b60587511b87173ec6053ecbc5bbf34c2b9939a97f90a9f17309f221f540843fb875a10cd2507e74f5648e4c119733591bc45fa59f7526a7d591f27f3e5737b74f382568a5f69ec8f5c99aae5cfa207a3361aa29620692ee02bda75e39de9cd0b0ce97c3fe01d67853a9d4384620a0126555e886cb853541ab49521004b21575930d151ae8afa159b8adca942fb3f106d08a24cc158b4a3cfbf37dcbdde3d7d89363655b086777a30057fa8c152d60415c07f3058661647c4f4a38b6a2f70c909a6f50f101f9e6568074b8776c8092ed2823d9155973a536a419dbff5c30c5230cfce965fdc50159e1f96e450a3b3328f73c3e8b46c4c551f3cffafc25f0fca518b099a8dd8dd512379d54dcebce009d1cb607f9ccfb45a4cc9e1dbbff4c9088eb34efb974076b7902759f3a14ae11d324d981ed99f48d9d0cee945a5f9493b44a2f94c7b159350bbb1566213cc292e27fcb3c22488906fd240b2ba042f2dd7e4b93ea29f160af9e5acbcde62ed0a1940bd7bf909fd239389f123e7b7c31f559c5f1fb425d314fa5299ba149d58e911d80672699a24891bd9e8b3621b0cf25ab11c217524d63e71cb7f2eba5a84ab3303b668bac05d66fdaedf9b09f32107b3bc5fac854bd1e595b08b3157315ae50df85867dc6d976f7531f48f4a08713f338f46cd7e9eb7d9a13487efe6763f3e021b8ac317225ccea189b6e337935ccb231c67a7ae73b9131a78486480057e8f26563135c1be39d9fde90e0b5e2fe6ac29b1cb623ecf06136566622f1a4c48e22d6ceee8f46fbb3c86b9faee78b1f7355ea676fbc6b98db75334720b85906c9f8a3e12907e1e989407005105e1873ebb5a10f8d195b25fcbfb5f7c3128c85ca636b57f0d1297f2649d0679b71fb8508323af1a32aeaf1bddb95448e979d5e93f9e49fe22be6dc95dd23b3b4f703bbfeae2a8f0054b4b3ca5d062c556c8ea50411e78851e29bb7bbb925bcd290a1dc60d6cf57040586a1eb0f7624c286cb5e490add0ddbd35302b2c4bce07015578be17a699374a7fc3da21d65bfc0979fce95e06999f21633251b30a989614cdaaeda5fa486f4373898536c3db6930457b04a1014df99afddea176dfff029681853ea8515b3ca4a6da7c13e9804da2f43c27b2a95b1978ec66fd6fb72747791863fe1c1e51b0f958f2cf9cd363691d14afe974a66e3f6717d91b82452d952f690b5c2a256532ce23759f49d8482af56c5cd2161d8e2b71d5fed2496f9c9545ff4e2d9ba641f26fe8031133215e1bfaeafcad030de8f263ba128e29012c03d0cf54680e4df14803d43ece7bd42c117a4fa6de0c2bc266a619c7795b783ba00e1f6d168ed3bad7e6b62a9e9707dc22f2bcc7e2feba84b93ace7873473f5073e6a8d2e13ac8f88e137276454ac540c466f4dc5faa3aa3779308d3a66f532270b008330734f19f13bdb0d8be7ab37599b895361a14a47ca70a3e60f0f220571888f9ad684360ceb5036ea37d4e91512217c9d3d04cbfe963763cf251e2c8db55863d5caabc8b52ca4fccc202b832ffec6a0d6f5bc6a71256b1ac59e8f00a56a74b966d5f2806323d5290ef8d2e2a270d36f0863e1e869155edaf3911a582c7af41a2413a04ae28b708f931588f604e0e431fa5ebb33419469c186278bb6065620a3642469ea6c7af1b2d533d5fb8515f074703e629ab5fea059c46c4f828a03bd87e75c5c1c74b580a9383560d293fce95bc2a5be137b41eea0e0f6944504eac12730267d44121ed475da7d4321406067a365d4ad5bd689613a8f32d82b7856cba0424011548f7e15c23f5802c408ed99f665a0cf60789a73980f96dd7b9da25acf1cfb678ec993600051fe4eb133000eeb5f9e0852a", - "proofRequest": "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", + "proof": "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", + "proofRequest": "02070102904e00972f2298bcd1f4a6e9736eb1ececac519917967e5bb8fbca80de395a6e7dc511000002b3adb77e7e9cb97aefc80ac7bfa4d175b797b7a8f1717a3930c0c6bc42408fb901afa7403387c236561d4cf309aa562ee4e0c16a6604745ed09974db8a3946672136784e21bf4ffd676c1906835206c5f6e399141a0905802a9b7a18486cf0b53994ee60820d9ae8b832f5bc9fd10bf413fd6cf772d24b1957c7d6a36f3e34842b01406c060a0c688935357a7a4af2f270bc3909d74f712dde7690781c76e9c23138a57b62c8e90ff5830cba0306d56f84af30a47ace675899e0cdb37e9ba5ce971b3a012b37f1c1f4c922ecb98f3cf2dbe6f12f65a73fc93316a1c0ad4a23a8a3b9b4eadbb7687b6e82161d031698bf0180e8922601c9000000000000000000000000000000000000000000000000000000000000000135353535353535353535353535353535353535353535353535353535353535350001012038fe5156c36c78da72290b6d81ccade9932a4a83500aa8962f04a6fd593bd30ccb4c336f095e14606787ca35145715c5acbc8970fd4e3d6a0450bc344bcfbd19020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000014edc2221e4de20913661a1a82a93271d311854a2655df08c219000ead017d41f000103636d782033190bdef16c2df1b0f6d41903142f52660fde345f45b9c94d87e61a9f788516b3509d4b6f458ab08e2ddb24ba9bb188f43d4492167b727ca6322383de1d26060bfc1743d4556a9702277d2b3989446fff656b61830d1504f4f5ceafb0f0370dc404b5b066d80f695f611db079e1db68b2de1cf3148b18bc89bb00516c833ab30dff821e7e1af1eb5f1ce6741fbf3079761666540e025ccbb4f339352890a3b7f0858b3c4e3b3bf71e4591f77fb7731ca58a10ac880bf7acc776896c52160022be8fc72212b19ea7fe3ed1535b88ebb8e906f05564c66406c5f5c28257686a936ae54370f194772894a59dadd37283fd848b69b6b26ecb22a6b6c1f6d0c49bd782bb9ff467478643e73983af90d4620de3e2fc8447f3e251c42e3770d6ed9b57d51deac2810e648a5016a6ead566e49c1828a43167ce041b3a2719022336a947d1fa3eda81dfa75b3b8d753d031bbe04f929d7080d8f549830f3b616abea43d342b4f017528c68aef95278f18eda744cae46bb53553d0089e4030cea6158aebd1e31b6e7145f7b79fa704d7f556e0e1f6a9588208c376ed9ee8a193e79316f98977a2971b0dc0b6b175c6d567647bf9770703d6bee6714777f9542e8e31cac4b5c1b384a6af5b511291e606d7e8699e6114a2d953bcb5a4526e2b5942a108f9d10de854d33dbdbb87dc57fee8aae6f2362da808d004d1af99bef5177a9f3f9f3502c4764eba80deb3147a13c922d213003b388c49810aa7cc44f100f227161f6c76276d43e4ec861a1c2296e964df533c5821025e782e5484204eef0cc3dbfa36a58ba2ea8076e283af2d4adbaa7a5037f18ed796cb0d3412567a48b7ce201bdc475a543c9826d8a1bb25b666eef03d0c1fe822ace54b9e6d2a2dcad920e621685bb31280fff93f3fea83a674dc3d555d62a163ae4e908b1bd4f1459b1628812a95395bc9bf55021bf03ff6d04f84ed3f2ea3713f09dac4db712643e0b929315fc49711e79f880ec92fc3b002941cc0e10afc7f55f512a3d8041db69d5f7aaee6d5a8db962b7decff349190cb2dddac1e17f9598ab5f5f012bb22b122d2d03d30be6665844ac2fa20e5f177cef86a49ec93c195e6597af49d3b01b958617fce8170ce0a701f8edf42a014828e01738b0a8d784860040b6908a76ca6f17581c1788462a9195a48cc1e3ac0000000f864af500bca593d9b13fca0080029af59fb41a10987433c9996f208611b830015850d6cefdf244c13d203eef21973ea6f2e43411d8199e81447b91d89d43760c621c8910e2a41c7959bd4f2e685a9a917b94fb0ed734ba906c1af5ad75abfe0cc1857f55b48efd7b6ee7ac7763607029bb21f5b91f4e47198dae7bb797cf4a970140bb713ef894609d1b2fc95e8397ed98f8b6a9af38045566e08005852fce9ade2dde74358f69bef8c526cea8144af0d8cf7358b3d35af11c97be728330054be901012b4559029c0b5dbf941c5ad181a5fe8f45b34630f29d0c8dd8dc1cc3573386f416cb324133156d723df5e62d0180c2d72f01c8000000000000000000000000000000000000000000000000000000000000000134343434343434343434343434343434343434343434343434343434343434340001002033190bdef16c2df1b0f6d41903142f52660fde345f45b9c94d87e61a9f788516cb4c336f095e14606787ca35145715c5acbc8970fd4e3d6a0450bc344bcfbd1902000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001884a7f8344d9d118bff3d16a0b10717e0b24cb2927c78294198d950df674343d000103636d782038fe5156c36c78da72290b6d81ccade9932a4a83500aa8962f04a6fd593bd30c28ddec0af49be6052349934b32afa84b18d8031cc035e7550a120a4954016e3d43f7e27fb426b524fd48757e03768bfe237361641ab602101cd457d95799e492c404bb7e1484e4860594894a05906c1b17ff1e758d22d5a3ebdc96690703db34b977fef5255236ffb468c5036fbac83b15e4c0fe85152192a1b383be5c809b2c348c48488186e49264e3a0e89801d9dd943adb9ec36cacf795c1529ba164d5260224634e8744146ab9e49bb60d0222f17bddfa8aad8df1ac1ba608acc1f5247d4e33c28c17c1dcbd76d6e5101911da5dc7ae75ebfbc47ee71cbf440f156843d845deb788e4cc9d1913964f4cd4fc6a0a2c9e242a49d66d7bb6b387cea5ccb3727fca1aa6dd79153df930cf54f5513582d5c28fb9b312fd6ac6ea790679bedc2ecdf6b28970cff57ca59e18fe3ee397c686d184a42d8e0188a356d9791a99921b332ade2e6cbfb5fc838407d8727e6ab66acd83b9288d0f86744d008aac094cf2b98a0d2226c5c4938850f71dd960b356cd412a0189b2361ae4fc51980d9e4c930aa935addf265560d0a99d300b86a2219beef3938ab04466b9e26e9eba5946b4142721fb97f6b9fbdcc520700b85811464db19daa6c97e6c4b87a4664195d9a6e8a9b1fb0e420b817e324a4d05887e093705428c554b90caf3e45c1b8c1ac475c0c3ffb39667fa63d6fb6374e0310a1e30255295d6c492bb260042c520b6fbdeec4d6faec13bb23cfe7b521b59b829c0342db81c2f07cc5a2bf115baea84a60459af44d40cca78a3cad130fbe5468e8e9bb1a1b5a5787c3bf3fd07707260e174f57c41f2a8936578248313b5e29f632ba5345c5cc0c02ad281b179a9132dd4912a64b4c3464da95b4026a820295597842b0e5e0c597d4429d9c39062ddfbdc7fc46a7fef681b5074cb7768c899b2991a0659bd775eb2bf45954e98856cc3659f9ce39abe8dd329f67a088141c44451dd599692d9fda74ccada5a47fd66f49cb74122e756de6600a08c99810a747848b1d9cd1fea91c7a6012b38b8c9ef7b9ad7d18319bff63ee4eee248c43176fbb19364bb81c8b5e65789f900bc05ec219b4e6c1979ae01f8edf42a0139a31c3e6ad71544f767a20334a7ace90376584b10ed8328d939a6f4c825cc25000000", "psbt": "cHNidP8BAAoGAAAAAAAAAAAATwEENYfPAAAAAAAAAAAADc9jwMWNYM0GWziPosNLh2uG/USCk+8NhqbABwfaZCUDFW4A24vc89rOW5DSUQ7j82gDhvxly7JWH8lwJAxcyf8EqUdqE08BBDWHzwAAAAAAAAAAAM2N8qihtPBntWmwWUIIwjgCHYywyM/O+WliUezqqzKqAyfGDQ65IUDKVV7ze0qgH7SLn9r59RTqAX8rdm7lSOEeBJIvPPRPAQQ1h88AAAAAAAAAAAC57LNjX+X32Sx3ZSo2BYv39a20M6AO74KIFIgniIp1NQN50jr9fw3TfDyVRV6OWhkoN5RC1PuPd3c6TSQUburi0wS7lwMeCPwFQklUR08ABFsWpTcP/AxCSVRHTy9aRUMvVjYABFsWpTcP/AxCSVRHTy9aRUMvVjYB/cgQAgcBApBOACdzAvZFpMa36lb8GZujnzFyHULS3QiBO921e8/rXiwtAAACs623fn6cuXrvyArHv6TRdbeXt6jxcXo5MMDGvEJAj7kBr6dAM4fCNlYdTPMJqlYu5ODBamYEdF7QmXTbijlGZyE2eE4hv0/9Z2wZBoNSBsX245kUGgkFgCqbehhIbPC1Ocn2VUj2JoMCCBeWpwVjFB0W9TVp2uTp6dRj+r5XEiGOAAErN/HB9Mki7LmPPPLb5vEvZac/yTMWocCtSiOoo7m06tu3aHtughYdAxaYvwGA6JImAckAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1NTU1AAEBIDj+UVbDbHjacikLbYHMremTKkqDUAqoli8Epv1ZO9MMAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDY214IDMZC97xbC3xsPbUGQMUL1JmD940X0W5yU2H5hqfeIUWs1CdS29FirCOLdskupuxiPQ9RJIWe3J8pjIjg94dJgYL/BdD1FVqlwInfSs5iURv/2VrYYMNFQT09c6vsPA3DcQEtbBm2A9pX2EdsHnh22iy3hzzFIsYvIm7AFFsgzqzDf+CHn4a8etfHOZ0H78weXYWZlQOAlzLtPM5NSiQo7fwhYs8Tjs79x5Fkfd/t3McpYoQrIgL96zHdolsUhYAIr6PxyISsZ6n/j7RU1uI67jpBvBVZMZkBsX1woJXaGqTauVDcPGUdyiUpZ2t03KD/YSLabaybssiprbB9tDEm9eCu5/0Z0eGQ+c5g6+Q1GIN4+L8hEfz4lHELjdw1u2bV9Ud6sKBDmSKUBam6tVm5JwYKKQxZ84EGzonGQIjNqlH0fo+2oHfp1s7jXU9Axu+BPkp1wgNj1SYMPO2FqvqQ9NCtPAXUoxorvlSePGO2nRMrka7U1U9AInkAwzqYViuvR4xtucUX3t5+nBNf1VuDh9qlYggjDdu2e6KGT55MW+Yl3opcbDcC2sXXG1Wdke/l3BwPWvuZxR3f5VC6OMcrEtcGzhKavW1ESkeYG1+hpnmEUotlTvLWkUm4rWUKhCPnRDehU0z29u4fcV/7oqubyNi2oCNAE0a+ZvvUXep8/nzUCxHZOuoDesxR6E8ki0hMAOziMSYEKp8xE8QDyJxYfbHYnbUPk7IYaHCKW6WTfUzxYIQJeeC5UhCBO7wzD2/o2pYui6oB24oOvLUrbqnpQN/GO15bLDTQSVnpIt84gG9xHWlQ8mCbYobsltmbu8D0MH+girOVLnm0qLcrZIOYhaFuzEoD/+T8/6oOmdNw9VV1ioWOuTpCLG9TxRZsWKIEqlTlbyb9VBOmaBBxt9C5WVootTGO1ELiqzVRUfrQMSd/5zxwK2opukPjONGLGH5ozQboBWRKSm50J2S1pd7aEckZFICPLmcuUPH0UfDSP5HI8M7fhFe3gErsisSLS0D0wvmZlhErC+iDl8XfO+GpJ7JPBleZZevSdOwG5WGF/zoFwzgpwH47fQqAUgo4Bc4sKjXhIYAQLaQinbKbxdYHBeIRiqRlaSMweOsAAAAD4ZK9QC8pZPZsT/KAIACmvWftBoQmHQzyZlvIIYRuDABWFDWzv3yRME9ID7vIZc+pvLkNBHYGZ6BRHuR2J1DdgxiHIkQ4qQceVm9Ty5oWpqRe5T7Dtc0upBsGvWtdav+DMn2VUj2JoMCCBeWpwVjFB0W9TVp2uTp6dRj+r5XEiGOAAErRVkCnAtdv5QcWtGBpf6PRbNGMPKdDI3Y3BzDVzOG9BbLMkEzFW1yPfXmLQGAwtcvAcgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0NDQ0AAEAIDMZC97xbC3xsPbUGQMUL1JmD940X0W5yU2H5hqfeIUWAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEDY214IDj+UVbDbHjacikLbYHMremTKkqDUAqoli8Epv1ZO9MMKN3sCvSb5gUjSZNLMq+oSxjYAxzANedVChIKSVQBbj1D9+J/tCa1JP1IdX4Ddov+I3NhZBq2AhAc1FfZV5nkksQEu34UhOSGBZSJSgWQbBsX/x51jSLVo+vclmkHA9s0uXf+9SVSNv+0aMUDb7rIOxXkwP6FFSGSobODvlyAmyw0jEhIgYbkkmTjoOiYAdndlDrbnsNsrPeVwVKboWTVJgIkY06HRBRqueSbtg0CIvF73fqKrY3xrBumCKzB9SR9TjPCjBfB3L121uUQGRHaXceudev7xH7nHL9EDxVoQ9hF3reI5MydGROWT0zU/GoKLJ4kKknWbXu2s4fOpcyzcn/KGqbdeRU9+TDPVPVRNYLVwo+5sxL9asbqeQZ5vtwuzfayiXDP9Xylnhj+PuOXxobRhKQtjgGIo1bZeRqZkhszKt4ubL+1/IOEB9hyfmq2as2DuSiND4Z0TQCKrAlM8rmKDSImxcSTiFD3Hdlgs1bNQSoBibI2GuT8UZgNnkyTCqk1rd8mVWDQqZ0wC4aiIZvu85OKsERmueJunrpZRrQUJyH7l/a5+9zFIHALhYEUZNsZ2qbJfmxLh6RmQZXZpuipsfsOQguBfjJKTQWIfgk3BUKMVUuQyvPkXBuMGsR1wMP/s5Zn+mPW+2N04DEKHjAlUpXWxJK7JgBCxSC2+97sTW+uwTuyPP57UhtZuCnANC24HC8HzFor8RW66oSmBFmvRNQMynijytEw++VGjo6bsaG1pXh8O/P9B3ByYOF09XxB8qiTZXgkgxO14p9jK6U0XFzAwCrSgbF5qRMt1JEqZLTDRk2pW0AmqCApVZeEKw5eDFl9RCnZw5Bi3fvcf8Rqf+9oG1Ahdr9r7S9FAU6bS38ZWTCXK7QUge9OxFc8SUpudP1sp6BQrFjIGQpjKe5+zqcV07iZmS02pNX4Zm9BIzzVmdhJP0fIu/YW/3oVSDmaW6m0DAErOLjJ73ua19GDGb/2PuTu4kjEMXb7sZNku4HIteZXifkAvAXsIZtObBl5rgH47fQqATmjHD5q1xVE92eiAzSnrOkDdlhLEO2DKNk5pvTIJcwlAAAAD/wMQklUR08vWkVDL1Y2AgSYtoTYD/wMQklUR08vWkVDL1Y2AwQAAAAAD/wMQklUR08vWkVDL1Y2CQEAAA==", "randomizers": [ { "actionIndex": 1, - "alpha": "bbc54e0f2fcf43feed0a535886f82e3bc7d99ad7a07268b0d1199ef4279b9931", - "rk": "7f53338dba978315293b7907496aa7872b472a6f01b5001af6a752b9b17975a2" + "alpha": "884a7f8344d9d118bff3d16a0b10717e0b24cb2927c78294198d950df674343d", + "rk": "c1857f55b48efd7b6ee7ac7763607029bb21f5b91f4e47198dae7bb797cf4a97" }, { "actionIndex": 0, - "alpha": "d00375e8766803493c9ce953e0ab68b545e169223fe697c19adde56e0c86173e", - "rk": "47edce3385360af8a3985609cebfeab72265b6334f75e725b95e6d13b0a4a836" + "alpha": "4edc2221e4de20913661a1a82a93271d311854a2655df08c219000ead017d41f", + "rk": "94ee60820d9ae8b832f5bc9fd10bf413fd6cf772d24b1957c7d6a36f3e34842b" } ], + "refresh": { + "anchor": "972f2298bcd1f4a6e9736eb1ececac519917967e5bb8fbca80de395a6e7dc511", + "witnesses": [ + { + "actionIndex": 1, + "authPath": [ + "33190bdef16c2df1b0f6d41903142f52660fde345f45b9c94d87e61a9f788516", + "cb4c336f095e14606787ca35145715c5acbc8970fd4e3d6a0450bc344bcfbd19", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000" + ], + "cmx": "38fe5156c36c78da72290b6d81ccade9932a4a83500aa8962f04a6fd593bd30c", + "position": 0 + }, + { + "actionIndex": 0, + "authPath": [ + "38fe5156c36c78da72290b6d81ccade9932a4a83500aa8962f04a6fd593bd30c", + "cb4c336f095e14606787ca35145715c5acbc8970fd4e3d6a0450bc344bcfbd19", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000", + "0200000000000000000000000000000000000000000000000000000000000000" + ], + "cmx": "33190bdef16c2df1b0f6d41903142f52660fde345f45b9c94d87e61a9f788516", + "position": 1 + } + ] + }, "request": { "anchor": "277302f645a4c6b7ea56fc199ba39f31721d42d2dd08813bddb57bcfeb5e2c2d", "outputs": [ @@ -140,15 +223,15 @@ ], "transparentOutput": null }, - "sighash": "160ba968519c69dd167f515eca009fbdef430816d870167aa64088f7728179b8", + "sighash": "80ea17c39e7609c86b5bd67d28469c71e60f12aa3177d0675a3c9dd8974c3df3", "signatures": [ { "actionIndex": 1, - "signature": "a93920735ebeff8b694d6d62a26542ae182c8b11fa1038e4b6f8365c7b28c3ab6c37d1fcf809834b83bd4306593f64b7242ce4c879ff9b05564a4c1a69510523" + "signature": "bb713ef894609d1b2fc95e8397ed98f8b6a9af38045566e08005852fce9ade2dde74358f69bef8c526cea8144af0d8cf7358b3d35af11c97be728330054be901" }, { "actionIndex": 0, - "signature": "15a1685ae0c1d414ba3728e0ddada6b2b2e96bffe7578b2c50d3c6c9c578c901b7058428a8ed7aa1430bb3eee54759f4582e1a3ba98ad58414e9aa8c25a69739" + "signature": "6c060a0c688935357a7a4af2f270bc3909d74f712dde7690781c76e9c23138a57b62c8e90ff5830cba0306d56f84af30a47ace675899e0cdb37e9ba5ce971b3a" } ], "spendActionIndices": [1, 0],