diff --git a/docs/execution-plan.md b/docs/execution-plan.md index 82c8741..edd0c01 100644 --- a/docs/execution-plan.md +++ b/docs/execution-plan.md @@ -82,7 +82,7 @@ descriptions, and commit messages* - [x] **Unit 6: macros.** Landed 2026-08-16 (PR 52) as `defmacro` with `qq` and `unquote`, classic Chialisp semantics stated in `docs/lang/macros.md`. Decisions by Evan, 2026-08-16: macros only, includes split to their own unit below (skeleton change under ground rule 6). `if` and `list` stay compiler forms, so macros cannot shadow built-ins. Expansion is depth-capped and cost-budgeted, a recorded deviation from Chialisp's unbounded expansion. No `function` or `com` reflection form, the laziness expressiveness gap recorded in the language doc. No refactor rode along, the shared emission-primitives cleanup stays a candidate for a standalone PR. Expansion runs as a source pre-pass before reachability, macro bodies compile at declaration against earlier macros only, and read-back diverges from clvm_tools by one hop only (decision by Evan, 2026-08-16, steelmanned both ways, then narrowed twice as four review rounds showed every wider evidence scheme unsound on post-reader bytes): names the caller writes in a call's own arguments error when unresolved, REPL def spellings are barred resolution-side, and capture plus stale template spellings stay as Chialisp has them, documented sharp edges. The three new reserved words are a deliberate source and symbol-file compatibility break for earlier programs that used them as names, pinned by a loader test. Compiled representatives pinned in `vectors/vm/macro-programs.json`. Kept after the 2026-08-16 public-record review (decision by Evan): the fixed special forms and capped expansion avoid the macro-built-language failure mode on that record, and re-evaluation stays open at unit 7. Reversed by unit 6c the same day. - [x] **Unit 6b: includes and the compile-time forms.** Split from unit 6 (decision by Evan, 2026-08-16): an include mechanism needs its own recorded decision against the self-containment rule, a program compiling identically pasted into the REPL. Scope expanded and resequenced ahead of unit 7 (decision by Evan, 2026-08-16, on a two-corpus census of tibetswap and chia-gaming): source-level include of shared constants and functions, computed compile-time constants, and inline functions. Every production puzzle file in both corpora imports shared definitions, and tibetswap defines nine of every ten functions inline. The census corrected the earlier deferral's premise: chia-gaming never abandoned source-level import, its compiled-sibling hash plumbing lives in its build layer outside the language, and that import stays deferred with `bitlisp-compile -T` covering the need manually in v0. `let` stays out, two uses across both corpora, both in tests. `assign` stays held on unit 7 evidence with a pre-registered trigger: benchmark-puzzle helpers that exist only to name intermediate values. Landed 2026-08-16 as `include`, computed `defconstant`, and `defun-inline`, stated in `docs/lang/language.md`. Decisions by Evan, 2026-08-16, via the approved unit plan: the self-containment rule is amended to the form plus its include files resolved through the same explicit search path everywhere, a repeat include dedupes by resolved file and a cycle errors where the classic reference dies on the collision or recurses without bound, `defconstant` evaluates its value on the reference VM under the default budget (a pinned break with unit 4's verbatim semantics, the modern defconst behavior under the classic keyword), and `defun-inline` keeps call-by-name laziness while closing classic's probe-verified sharp edges: arity checked, quoted content untouched, shadowing impossible, expansion depth-capped. Compiled representatives joined `compiled-programs.json`. - [x] **Unit 6c: the macro reversal.** Landed 2026-08-16 as the removal of `defmacro`, `qq`, and `unquote` and the addition of `assert`, `and`, and `or` as fixed compiler forms with classic utility_macros semantics, reversing unit 6 (decision by Evan, 2026-08-16, both sides steelmanned under ground rule 3). The evidence: three usage surveys (Chia's canonical 91-puzzle corpus, the corpora vendored in references/, and chia-gaming) found no novel macro in any deployed puzzle, short-circuit assert, and, and or the entire production vocabulary, and chia-gaming's production referee choosing built-in destructuring over the structural macro sitting unbuilt beside it. The reserved-word set change breaks compatibility in both directions, pinned by the loader test. Compiled representatives joined `vectors/vm/compiled-programs.json`, and `macro-programs.json` left with the feature. -- [ ] **Unit 7: the four benchmark puzzles, written in the language, as the acceptance artifact:** payment pool, async offer, vault, singleton wrapper. This phase makes them exist and run, Phase 4 measures them. One PR per puzzle where size warrants. Style constraint (decision by Evan, 2026-08-16, simplified by unit 6c, widened by unit 6b's resequencing): the puzzles are plain functions, the fixed forms, and the unit 6b surfaces, there being no macro system, and the authoring experience feeds the typed v1 gate's ledger note on whether unit 6c's cut ever binds. +- [ ] **Unit 7: the four benchmark puzzles, written in the language, as the acceptance artifact:** vault, payment pool, async offer, singleton wrapper. This phase makes them exist and run, Phase 4 measures them. One PR per puzzle where size warrants. Style constraint (decision by Evan, 2026-08-16, simplified by unit 6c, widened by unit 6b's resequencing): the puzzles are plain functions, the fixed forms, and the unit 6b surfaces, there being no macro system, and the authoring experience feeds the typed v1 gate's ledger note on whether unit 6c's cut ever binds. Vault first, resequenced ahead of the pool (decision by Evan, 2026-08-16): core semantics match BIP-345, one PR, plus the keyless leader/follower consolidation path over the message ledger with its theft vectors, the evaluation doc's section 3.2 benchmark. Recovery posture is a curried per-instance choice, keyless or keyed (decision by Evan, 2026-08-16). The vault's dispatch helpers exist only to name a reconstructed root once, the pre-registered assign trigger firing, evidence for the unit 7 ledger note. **Standing constraints:** diff --git a/docs/glossary.md b/docs/glossary.md index 732f696..fb9c0f9 100644 --- a/docs/glossary.md +++ b/docs/glossary.md @@ -62,3 +62,12 @@ A term enters this table in the same PR that introduces it. | curry, uncurry | compare filling the placeholder keys of a script template before deriving its address | curry, uncurry (clvm_tools, chia_rs) | fixing values into a program to make a new committed program and reading them back out, the shape and the strict uncurry contract in docs/lang/curry.md, landed 2026-08-16 | | include | no script equivalent, script has no authoring language | include (clvm_tools stage 2), import (clvm_tools_rs) | the declaration-file splice form, one declaration list per file resolved through the -I search path, files deduplicated and cycles rejected where classic errors or recurses (docs/lang/language.md deviations), landed 2026-08-16 | | defun-inline | no script equivalent, script has no authoring language | defun-inline (Chialisp) | the inline function declaration, call-by-name splicing at each call site with arity checked and quoted content untouched where classic substitutes blindly (docs/lang/language.md deviations), landed 2026-08-16 | +| mod hash | compare the script inside a P2WSH or tapleaf commitment, identified by its hash | MOD_HASH, the curried-in hash of a puzzle's own uncurried source | the tree hash of an uncurried program, curried into instances so a program can recompute its own curried identity (docs/puzzles/vault.md), glossed 2026-08-16 with the vault | +| vault | BIP-345 vault, OP_VAULT plus OP_VAULT_RECOVER | the clawback and custody puzzles are the nearest relatives | the first benchmark puzzle, delayed sends with an always-available recovery path (docs/puzzles/vault.md), landed 2026-08-16 | +| trigger spend | the OP_VAULT trigger transaction | no direct equivalent | the authorized vault spend committing a withdrawal target chosen at spend time and creating the triggered coin | +| triggered coin | the OP_VAULT trigger output carrying the substituted leaf | no direct equivalent | the delayed state between trigger and withdrawal, the triggered program curried with the target hash | +| withdrawal | the OP_VAULT withdrawal transaction under CSV plus CTV | no direct equivalent | the triggered coin's matured spend into exactly the committed output set, ASSERT_SEQUENCE_HEIGHT plus SEAL_OUTPUTS | +| revault | the OP_VAULT revault output | no direct equivalent | the trigger's remainder claim re-encumbering value under the byte-exact original vault scriptPubKey | +| recovery scriptPubKey | the OP_VAULT_RECOVER recovery path, pinned by hash in the BIP | compare the clawback destination | the fixed destination every recovery pays, curried as literal bytes here (docs/puzzles/vault.md divergences) | +| consolidation leader | no script equivalent | no direct equivalent | the one input of a keyless consolidation that lists the follower amounts, receives their messages, and claims the merged output (docs/puzzles/vault.md) | +| consolidation follower | no script equivalent | no direct equivalent | a keyless consolidation input sending one message that commits its own scriptPubKey and amount to the ledger the leader must balance | diff --git a/docs/puzzles/vault.md b/docs/puzzles/vault.md new file mode 100644 index 0000000..9f76e76 --- /dev/null +++ b/docs/puzzles/vault.md @@ -0,0 +1,356 @@ +# The vault benchmark puzzle + +The first of the four Phase 3 benchmark puzzles: coins held so that +sends pass through a public delay with an always-available recovery +path, plus a keyless consolidation path that lets anyone merge the +vault's coins back into one. The core semantics reproduce BIP-345 +(OP_VAULT and OP_VAULT_RECOVER) with the condition vocabulary +instead of new opcodes. This is tooling and vectors only: nothing +here changes `spec/` or the consensus implementation. + +Sources live in `puzzles/vault/`, shared helpers in `puzzles/lib/`. +Both programs compile with the two include directories on the +search path: + +``` +bitlisp-compile puzzles/vault/vault.bl -I puzzles/lib -I puzzles/vault +bitlisp-compile puzzles/vault/triggered.bl -I puzzles/lib -I puzzles/vault +``` + +## Instance identity + +A vault instance is the vault program curried with its seven fixed +values. Its coin's scriptPubKey is the taproot output of a fixed +internal key tweaked with the curried program's tree hash as the +merkle root, the derivation CREATE_OUTPUT_TAPROOT and +ASSERT_MY_TAPROOT perform in the validator. The internal key is the +BIP341 nothing-up-my-sleeve point, so no key-path spend exists and +the program is the whole spending policy. + +No VM operator performs the taproot tweak, so a program cannot +derive its own 34-byte scriptPubKey. What it can do is recompute +its own curried tree hash: the curried shape +`(a (q . F) (c (q . v1) ... 1))` is fixed, so the hash follows from +the uncurried program's tree hash and the tree hashes of the fixed +values. The helpers in `puzzles/lib/curry-hash.blib` compute +exactly the digest `bitlisp-curry -T` prints. Every path emits +`ASSERT_MY_TAPROOT` over the reconstructed root, binding the +program run to the coin it claims to govern: one instance's +program can never spend another instance's coin, and a program +installed against a coin at any other scriptPubKey fails its own +assert. + +That binding is exactly program-to-coin and nothing stronger. The +assert recomputes the root from the same curried values the coin's +scriptPubKey was derived from, so it cannot detect that those +values differ from the author's intent: a coin funded from a curry +with transposed or wrong values is live and governed by that wrong +curry. Verifying a curry before funding it is the wallet's job, +and `bitlisp-uncurry` plus the `-T` flag exist for it. + +What the programs do check, on every path of both states, is that +each fixed value sits inside its domain: the authorization key is +32 bytes, the recovery key is nil or 32 bytes, the recovery +scriptPubKey is 1 to 10000 bytes, the delay is 0 to 65535 and +minimally encoded, and the triggered state's target hash is 32 +bytes. Without these guards a value outside its domain would break +a single path at spend time while the others kept working, a +quietly lost recovery path being the worst case, and the recovery +scriptPubKey is exactly the value whose failure is that worst +case: nil is the legitimate spelling for the adjacent recovery +key, and an instance curried with a nil recovery scriptPubKey +would trigger, revault, and consolidate perfectly while the panic +button alone was dead. The minimality clause exists because a +padded delay encoding reads as the same number in these guards but +is rejected by the sequence assert it feeds, which would brick +withdrawal alone. With the guards a malformed instance fails on +its first spend of any kind, before it has a history. + +This identity convention is a recorded stand-in: the Phase 4 +commitment scheme decides how programs are really committed under +the new tapleaf version, and it may replace the bare curried tree +hash with a tagged leaf construction. The convention is confined +to the `curry-hash.blib` call sites. + +## The two programs + +`vault.bl` is the resting state. Curried values, in order: + +| value | width | meaning | +| --- | --- | --- | +| `VAULT_MOD_HASH` | 32 | tree hash of the uncurried vault program | +| `TRIG_MOD_HASH` | 32 | tree hash of the uncurried triggered program | +| `AUTH_KEY` | 32 | x-only key authorizing triggers | +| `INTERNAL_KEY` | 32 | the taproot internal key, the BIP341 NUMS point | +| `RECOVERY_SPK` | script | the recovery destination, literal scriptPubKey bytes | +| `RECOVERY_KEY` | 0 or 32 | nil for keyless recovery, an x-only key to require a recovery signature | +| `DELAY` | int | the withdrawal delay in blocks, 0 to 65535 | + +`triggered.bl` is the delayed state a trigger creates. Curried +values: `TRIG_MOD_HASH`, `INTERNAL_KEY`, `RECOVERY_SPK`, +`RECOVERY_KEY`, `DELAY`, `TARGET_HASH`. The first five carry over +from the vault unchanged, and `TARGET_HASH` is chosen at trigger +time. + +Both take the solution `(PATH . ARGS)`. + +``` + trigger (AUTH_KEY signs target) + +-------+ ------------------------------------> +-----------+ + | vault | revault remainder | triggered | + | | <------------------------------------ | | + +-------+ +-----------+ + | ^ \ / | + | | \ recovery (anyone, or RECOVERY_KEY) / | withdrawal + | | v v | (DELAY blocks, + | | +------------- RECOVERY_SPK ----------+ | exact TARGET + | | v outputs) + | +--- consolidation (anyone, leader + followers, outputs named + +------- merges coins back into one vault coin) by TARGET_HASH +``` + +## Vault paths + +**Path 1, trigger.** ARGS is +`(TARGET TRIG_AMT REVAULT_AMT MY_AMT SIG)`. The program rejects a +`TARGET` that is not 32 bytes, a non-positive `TRIG_AMT`, a +negative `REVAULT_AMT`, and `MY_AMT > TRIG_AMT + REVAULT_AMT`, the +BIP-345 value rule over the coin's own pinned amount. The amount +guards hold even against a misbehaving signer: no signed solution +can mint an oversized triggered coin through a negative revault or +a worthless zero-value one. Emitted conditions: + +1. `ASSERT_MY_TAPROOT INTERNAL_KEY ` +2. `ASSERT_MY_AMOUNT MY_AMT` +3. `ASSERT_SIG_MY_OUTPOINT AUTH_KEY SIG` where the + message is the tree hash of `(1 TARGET TRIG_AMT REVAULT_AMT)`, + the leading 1 the trigger's signing-domain tag. The digest binds + the consumed outpoint, so an authorization cannot be replayed + onto a sibling coin of the same instance, and it binds the + target and both amounts, so a captured signature authorizes + exactly one trigger shape. The tag keeps trigger and recovery + authorizations in disjoint domains even for an operator who + curries one key into both roles, instead of resting on the two + message lists' shapes happening to differ. +4. `CREATE_OUTPUT_TAPROOT INTERNAL_KEY TRIG_AMT`, + the triggered root computed over the carried-over values plus + `TARGET`. +5. When `REVAULT_AMT > 0`, `CREATE_OUTPUT_TAPROOT INTERNAL_KEY + REVAULT_AMT`, re-encumbering the remainder under + the byte-exact original scriptPubKey. + +**Path 2, recovery.** ARGS is `(MY_AMT RECOVER_AMT)` keyless, with +a trailing signature when `RECOVERY_KEY` is set. The program +rejects `MY_AMT > RECOVER_AMT`. Emitted conditions: the taproot +assert, `ASSERT_MY_AMOUNT MY_AMT`, and +`CREATE_OUTPUT RECOVERY_SPK RECOVER_AMT`, plus +`ASSERT_SIG_MY_OUTPOINT RECOVERY_KEY SIG` in the keyed posture, the leading 2 the +recovery signing-domain tag. A recovery moves at least +the coin's full value to the fixed recovery destination and +nowhere else. Keyless recovery lets any watcher sweep a coin under +attack without holding a key, at the cost of value-preserving +griefing. The keyed posture closes the griefing and costs key +management. The choice is per instance. + +**Path 3, consolidation follower.** ARGS is `(MY_SPK)`. Emitted +conditions: the taproot assert, `ASSERT_MY_SCRIPTPUBKEY MY_SPK`, +and `SEND_MESSAGE 26 () MY_SPK`. The scriptPubKey arrives in the +solution because no operator derives it, and the assert proves it +is the coin's own. Mode 26 puts the sender half at commitment 3, +the sending input's own scriptPubKey and amount filled by the +validator from real prevout data, and the receiver half at +commitment 2, addressing the shared scriptPubKey. + +**Path 4, consolidation leader.** ARGS is +`(MY_SPK MY_AMT OUT_AMT FOLLOWER_AMOUNTS)`. The program rejects an +empty follower list and `MY_AMT + sum(FOLLOWER_AMOUNTS) > OUT_AMT`. +Emitted conditions: the taproot assert, +`ASSERT_MY_SCRIPTPUBKEY MY_SPK`, `ASSERT_MY_AMOUNT MY_AMT`, one +`RECEIVE_MESSAGE 26 () MY_SPK ` per listed follower +amount, and `CREATE_OUTPUT MY_SPK OUT_AMT`. + +An unknown path raises. + +## Triggered paths + +**Path 1, withdrawal.** ARGS is `()`. Emitted conditions: the +taproot assert over the triggered root, +`ASSERT_SEQUENCE_HEIGHT DELAY`, and `SEAL_OUTPUTS TARGET_HASH`. +The sequence assert makes the coin `DELAY` blocks old before it +moves. The seal fixes every output slot of the spending +transaction to the committed set and nothing else, so the +withdrawal pays exactly the outputs `TARGET_HASH` names while +anyone may add a fee input to a stuck withdrawal. The seal operand +is curried, committed in the scriptPubKey, so the unsigned-seal +footgun of solution-supplied seals does not apply. The open input +side cuts the other way too: two triggered coins carrying the same +target hash satisfy one output set together and the second coin's +value burns to fees, the recorded divergence below, so a wallet +never reuses a target. + +**Path 2, recovery.** Identical to the vault's recovery path with +the triggered root in the taproot assert, available at any time +before a withdrawal confirms, before or after the delay matures. + +## BIP-345 correspondence + +| BIP-345 | here | +| --- | --- | +| vault taptree, trigger leaf plus recovery leaf | the vault program's path dispatch | +| OP_VAULT leaf-update: trigger output carries the taptree with the leaf substituted | the trigger claims a `CREATE_OUTPUT_TAPROOT` whose merkle root is the triggered program curried with `TARGET_HASH` | +| leaf-update script, CSV plus CTV | the triggered program's withdrawal path, `ASSERT_SEQUENCE_HEIGHT` plus `SEAL_OUTPUTS` | +| CTV hash chosen at trigger time in witness data | `TARGET` in the trigger solution, signed by `AUTH_KEY` | +| revault output at the input's own scriptPubKey | the `REVAULT_AMT` claim at the byte-exact vault scriptPubKey | +| trigger amount rule, deferred checks | the in-program value guard plus exact output claims under validation rule 1 | +| OP_VAULT_RECOVER, recovery scriptPubKey pinned by hash | the recovery path, `RECOVERY_SPK` curried as literal bytes | +| unauthorized or authorized recovery | `RECOVERY_KEY` nil or set, per instance | +| recovery output value at least the input value | the `MY_AMT <= RECOVER_AMT` guard over the pinned own amount | + +Recorded divergences from BIP-345: + +- `RECOVERY_SPK` is curried as literal bytes where the BIP pins a + tagged hash of it. Curried data is already committed data, and + `CREATE_OUTPUT` needs the literal bytes, so the hash indirection + buys nothing here. +- Batched triggers merging several vault inputs into one summed + trigger output are declined scope. Validation rule 1 matches + claims to output slots by exact content and counts them, it + never sums, so per-input triggers compose in one transaction + with one triggered output each, and the summing instrument in + this vocabulary is the consolidation message ledger below. +- `SEAL_OUTPUTS` drops the input-side commitment BIP-345 inherits + from CTV's template hash, and that loss has a consequence, not + just a flexibility gain. The gain: fee inputs attach freely to a + stuck withdrawal. The consequence: the withdrawal path is + keyless, and the seal explicitly leaves which inputs exist + unconstrained, so two matured triggered coins carrying the same + target hash can be spent in one transaction where the single + committed output set satisfies both seals and the second coin's + entire value becomes fee. Anyone may build that transaction, and + a miner profits from building it. CTV's input-count commitment + is exactly the known half-spend protection, and this construction + does not have it. Wallets must therefore never produce two + triggered coins with the same target hash: make every target + unique, by perturbing an output amount, adding a per-trigger salt + output, or simply never re-triggering an unspent target. The + merge-and-burn transaction is pinned as the vector + `same_target_withdrawals_merge_second_burns`, expected valid, + because the validator accepts it and the defense is the wallet + rule. A seal variant that also commits the input count would + close this at the vocabulary level and is flagged for a spec + decision outside this unit. +- The BIP's fee posture otherwise survives: no vault path can pay + vault value out as fees on its own, and fee inputs attach freely + because the seal and the claims constrain outputs, not inputs. + The same-target merge above is the recorded exception. + +## The consolidation construction + +Consolidation answers the benchmark case recorded in the +evaluation document: an input authorized only if some output pays +the input's own scriptPubKey at least the summed value of every +input sharing that scriptPubKey, with the validator doing linear +work. + +The spender, who needs no key, picks one coin as leader. Every +other coin spends its follower path and sends one message +addressed to the shared scriptPubKey, the sender half carrying its +own scriptPubKey and amount from prevout data the validator fills. +The leader lists the follower amounts in its solution, receives +one matching message per listed amount, and claims one output +paying the shared scriptPubKey at least its own amount plus the +listed sum. + +The message ledger makes the sum honest. Message records balance +only when k identical sends meet exactly k identical receives, so: + +- An omitted follower leaves an unmatched send. Its coin cannot be + silently absorbed. +- A phantom or misstated listed amount creates an unmatched + receive. The sum cannot be inflated or deflated against the + coins actually present. +- Two followers of equal amount produce one record at weight two, + and the leader must list the amount twice. +- A hostile input at a foreign scriptPubKey cannot forge a + follower record, because the sender half is filled from its real + prevout data, and cannot intercept the followers as a fake + leader, because its receive records carry its own scriptPubKey + in the receiver half while the followers addressed the vault's. +- A negative or non-minimal listed amount dies at condition + parsing, before the ledger runs. +- Two independently balanced consolidations at the same + scriptPubKey compose in one transaction. + +The leader path rejects an empty follower list, so every +consolidation merges at least two coins, and no keyless path can +split a coin's value, a revault needing the trigger signature. Any +conflicting consolidation an adversary substitutes therefore still +merges the coins it consumes. That is deliberately not a claim +that the coin count at the scriptPubKey only falls: validation +rule 1 leaves unclaimed output slots unconstrained, so a +transaction can carry additional funded outputs at the vault's +scriptPubKey. Creating such a coin costs its full value, and +anyone can dust any scriptPubKey with an ordinary payment at any +time, so this adds nothing to the consolidation attack surface. +What remains to an adversary is value-preserving griefing, +spending their own fees to delay a pending merge or to choose +which coins merge, the same griefing posture as keyless recovery, +and a vault that objects chooses the keyed recovery posture and +accepts the key management. + +One reading note against the benchmark as the evaluation document +records it: the recorded predicate sums every input at the shared +scriptPubKey, while this construction enforces it per group, the +leader plus its listed followers, and independently balanced +groups compose in one transaction. The single-output global form +is the one-group case. Per group is the only reading compatible +with the validation layer's composition guarantee, under which two +valid spend sets must stay valid when combined, so the +construction takes it deliberately. + +The theft cases above are pinned in +`vectors/validation/vault-consolidation.json`, one vector per +attack shape, the negative and non-minimal listed amounts and the +two-leaders double-claim included. + +## Fees + +The transaction model requires outputs not to exceed inputs, and +every value rule here is a floor on an output claim, so each +example transaction carries an ordinary fee input beside the vault +coins. Withdrawal transactions additionally accept fee inputs +added by anyone after the fact, because `SEAL_OUTPUTS` leaves the +input side open. + +## Worked instance + +The mod hashes, pinned in `python/tests/test_vault_puzzles.py`: + +``` +$ bitlisp-compile -T puzzles/vault/vault.bl -I puzzles/lib -I puzzles/vault +15884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294f +$ bitlisp-compile -T puzzles/vault/triggered.bl -I puzzles/lib -I puzzles/vault +214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1b +``` + +An instance's merkle root is the curried tree hash, printable +without running anything: + +``` +$ bitlisp-compile puzzles/vault/vault.bl -I puzzles/lib -I puzzles/vault \ + | bitlisp-curry -a 0x -a 0x \ + -a 0x -a 0x -a 0x \ + -a 0x -a 144 -T +``` + +The compiled representatives, one per spend path with the +in-program guard failures and the malformed instances, are pinned +in `vectors/vm/vault-programs.json`, and the condition-level +lifecycle in `vectors/validation/vault-core.json`. The test suite +recompiles both programs, byte-compares every pinned program +against a fresh compile and curry, and recomputes every conditions +field in both validation vector files, program-derived lists from +compiled source and the hand-built hostile variants from their +documented constructions, with set equality in both directions. +Source and corpus move together or not at all. diff --git a/puzzles/lib/curry-hash.blib b/puzzles/lib/curry-hash.blib new file mode 100644 index 0000000..61791e7 --- /dev/null +++ b/puzzles/lib/curry-hash.blib @@ -0,0 +1,34 @@ +; Tree-hash reconstruction of a curried program's identity. +; +; A curried program is (a (q . F) (c (q . v1) (c (q . v2) ... 1))), +; and its tree hash is what a program curried with these helpers can +; recompute about itself: the hash of an atom is sha256 of 0x01 then +; its bytes, the hash of a pair is sha256 of 0x02 then both child +; hashes, exactly what the sha256tree operator computes. The fixed +; atoms of the curried shape are apply (2), quote and the trailing +; environment path (both 1), and cons (4), so their hashes are +; compile-time constants. +( + (defconstant APPLY_HASH (sha256 1 2)) + (defconstant ONE_HASH (sha256 1 1)) + (defconstant CONS_HASH (sha256 1 4)) + (defconstant NIL_HASH (sha256 1 ())) + + ; The hash of the value chain (c (q . v) ), ending at the + ; bare path 1 that passes the received environment through. Each + ; VALUE_HASHES entry is the tree hash of one fixed value, first + ; value first. + (defun env-chain-hash (VALUE_HASHES) + (if VALUE_HASHES + (sha256 2 CONS_HASH + (sha256 2 (sha256 2 ONE_HASH (f VALUE_HASHES)) + (sha256 2 (env-chain-hash (r VALUE_HASHES)) NIL_HASH))) + ONE_HASH)) + + ; The tree hash of the whole curried program, from the uncurried + ; program's tree hash and the fixed values' tree hashes. + (defun curried-tree-hash (MOD_HASH VALUE_HASHES) + (sha256 2 APPLY_HASH + (sha256 2 (sha256 2 ONE_HASH MOD_HASH) + (sha256 2 (env-chain-hash VALUE_HASHES) NIL_HASH)))) +) diff --git a/puzzles/vault/triggered.bl b/puzzles/vault/triggered.bl new file mode 100644 index 0000000..eff911a --- /dev/null +++ b/puzzles/vault/triggered.bl @@ -0,0 +1,56 @@ +; The triggered program: the delayed state between trigger and +; withdrawal. +; +; A triggered instance is this program curried with its six fixed +; values, TARGET_HASH among them, and its coin's scriptPubKey is the +; taproot output of INTERNAL_KEY tweaked with the curried program's +; tree hash, the same identity convention as the vault. The vault's +; trigger path creates this coin, so TARGET_HASH is committed the +; moment the trigger confirms. The solution is (PATH . ARGS). +; +; Paths: +; 1 withdrawal after DELAY blocks of coin age, and only into +; the exact output set TARGET_HASH names +; 2 recovery value moves to RECOVERY_SPK at any time before +; a withdrawal confirms, keyless when +; RECOVERY_KEY is nil +(program (TRIG_MOD_HASH INTERNAL_KEY RECOVERY_SPK RECOVERY_KEY DELAY + TARGET_HASH PATH . ARGS) + (include "vault-shared.blib") + + (defconstant WITHDRAW_PATH 1) + (defconstant RECOVER_PATH 2) + + ; The withdrawal needs no solution data: the sequence assert makes + ; the coin DELAY blocks old before it moves, and the seal fixes + ; every output slot to the committed set while leaving the input + ; side open, so anyone may add a fee input to a stuck withdrawal + ; without invalidating it. + (defun-inline withdraw-conditions (IK TROOT DELAY TARGET) + (list + (list ASSERT_MY_TAPROOT IK TROOT) + (list ASSERT_SEQUENCE_HEIGHT DELAY) + (list SEAL_OUTPUTS TARGET))) + + ; Exists to name TROOT once for both branches. + (defun dispatch (IK RSPK RKEY DELAY TARGET TROOT PATH ARGS) + (if (= PATH WITHDRAW_PATH) + (withdraw-conditions IK TROOT DELAY TARGET) + (if (= PATH RECOVER_PATH) + (recovery-conditions IK TROOT RSPK RKEY ARGS) + (x)))) + + ; The same first-spend well-formedness check as the vault, for a + ; triggered instance curried directly rather than through a + ; well-formed vault's trigger, minimal delay encoding included. + (assert (or (not RECOVERY_KEY) (= (strlen RECOVERY_KEY) 32)) + (> (strlen RECOVERY_SPK) 0) + (not (> (strlen RECOVERY_SPK) 10000)) + (not (> 0 DELAY)) + (not (> DELAY 65535)) + (= DELAY (+ DELAY 0)) + (= (strlen TARGET_HASH) 32) + (dispatch INTERNAL_KEY RECOVERY_SPK RECOVERY_KEY DELAY TARGET_HASH + (triggered-root TRIG_MOD_HASH INTERNAL_KEY RECOVERY_SPK + RECOVERY_KEY DELAY TARGET_HASH) + PATH ARGS))) diff --git a/puzzles/vault/vault-shared.blib b/puzzles/vault/vault-shared.blib new file mode 100644 index 0000000..de95a72 --- /dev/null +++ b/puzzles/vault/vault-shared.blib @@ -0,0 +1,44 @@ +; Declarations shared by the vault program and the triggered program. +; +; Both programs identify a coin the same way: the coin's scriptPubKey +; is the taproot output of a fixed internal key tweaked with the tree +; hash of the governing curried program, the derivation +; CREATE_OUTPUT_TAPROOT and ASSERT_MY_TAPROOT perform in the +; validator. +( + (include "curry-hash.blib") + + ; Every signed message list opens with one of these tags, so the + ; trigger and recovery authorizations live in disjoint digest + ; domains even for an operator who curries the same key into both + ; roles, instead of resting on the two lists' shapes differing. + (defconstant TRIGGER_SIG_TAG 1) + (defconstant RECOVERY_SIG_TAG 2) + + ; The curried tree hash of the triggered program over its six fixed + ; values, the merkle root of a triggered coin. The vault program + ; computes it to create a triggered coin, and the triggered program + ; computes it over its own curried values to recognize itself. + (defun triggered-root (TMH IK RSPK RKEY DELAY TARGET) + (curried-tree-hash TMH + (list (sha256tree TMH) (sha256tree IK) (sha256tree RSPK) + (sha256tree RKEY) (sha256tree DELAY) (sha256tree TARGET)))) + + ; The recovery spend, shared by both states. It pays the fixed + ; recovery scriptPubKey at least the coin's own pinned amount, so a + ; recovery moves value only to the recovery destination. RKEY nil + ; makes the path keyless. A 32-byte RKEY demands a signature over + ; the outpoint-bound digest of both amounts, so a keyed recovery + ; cannot be replayed onto another coin or rewritten to different + ; amounts. + (defun recovery-conditions (IK ROOT RSPK RKEY (MY_AMT RECOVER_AMT . EXTRA)) + (assert (not (> MY_AMT RECOVER_AMT)) + (c (list ASSERT_MY_TAPROOT IK ROOT) + (c (list ASSERT_MY_AMOUNT MY_AMT) + (c (list CREATE_OUTPUT RSPK RECOVER_AMT) + (if RKEY + (list (list ASSERT_SIG_MY_OUTPOINT RKEY + (sha256tree (list RECOVERY_SIG_TAG MY_AMT RECOVER_AMT)) + (f EXTRA))) + ())))))) +) diff --git a/puzzles/vault/vault.bl b/puzzles/vault/vault.bl new file mode 100644 index 0000000..bc5325d --- /dev/null +++ b/puzzles/vault/vault.bl @@ -0,0 +1,141 @@ +; The vault program: the resting state of a vaulted coin. +; +; A vault instance is this program curried with its seven fixed +; values, and its coin's scriptPubKey is the taproot output of +; INTERNAL_KEY tweaked with the curried program's tree hash. Every +; path recomputes that hash and asserts it against the coin being +; spent, which rejects running one instance's program against +; another instance's coin. It cannot check that the curried values +; are the ones the author intended: a coin funded from a wrong +; curry is governed by that wrong curry. The solution is +; (PATH . ARGS). +; +; Paths: +; 1 trigger AUTH_KEY signs the withdrawal target chosen at +; spend time, value moves to a triggered coin, +; any remainder revaults to this same instance +; 2 recovery value moves to RECOVERY_SPK, keyless when +; RECOVERY_KEY is nil +; 3 follower joins a consolidation led by another input +; 4 leader merges this coin with at least one follower +; back into a single coin of this same instance +; +; Consolidation is keyless: the follower's message names its own +; scriptPubKey and amount from real prevout data, the leader must +; receive exactly one such message per follower it sums, and the +; message ledger balances only when the leader's list matches the +; followers present, so the merged output can never pay less than +; every merged coin's value. +(program (VAULT_MOD_HASH TRIG_MOD_HASH AUTH_KEY INTERNAL_KEY + RECOVERY_SPK RECOVERY_KEY DELAY PATH . ARGS) + (include "curry-hash.blib") + (include "vault-shared.blib") + + (defconstant TRIGGER_PATH 1) + (defconstant RECOVER_PATH 2) + (defconstant FOLLOW_PATH 3) + (defconstant LEAD_PATH 4) + + ; Sender half 3 commits the sending input's own scriptPubKey and + ; amount, receiver half 2 addresses a scriptPubKey argument. + (defconstant CONSOLIDATE_MODE (+ (* 8 3) 2)) + (defconstant CONSOLIDATE_PAYLOAD ()) + + ; This instance's own curried tree hash, the merkle root its + ; coin's scriptPubKey commits to. + (defun vault-root (VMH TMH AK IK RSPK RKEY DELAY) + (curried-tree-hash VMH + (list (sha256tree VMH) (sha256tree TMH) (sha256tree AK) + (sha256tree IK) (sha256tree RSPK) (sha256tree RKEY) + (sha256tree DELAY)))) + + ; The trigger commits TRIG_AMT to a triggered coin carrying TARGET + ; and revaults any remainder to this same instance. The signature + ; digest binds the consumed outpoint, so an authorization cannot be + ; replayed onto another coin of this instance, and its message + ; hashes the target and both amounts, so none of them can be + ; rewritten under a captured signature. The amount guards hold + ; even against a misbehaving signer: the trigger amount is + ; positive, the revault amount is never negative, and a malformed + ; target would mint a coin whose withdrawal seal can never parse. + (defun trigger-path (TMH AK IK RSPK RKEY DELAY VROOT + (TARGET TRIG_AMT REVAULT_AMT MY_AMT SIG)) + (assert (= (strlen TARGET) 32) + (> TRIG_AMT 0) + (not (> 0 REVAULT_AMT)) + (not (> MY_AMT (+ TRIG_AMT REVAULT_AMT))) + (c (list ASSERT_MY_TAPROOT IK VROOT) + (c (list ASSERT_MY_AMOUNT MY_AMT) + (c (list ASSERT_SIG_MY_OUTPOINT AK + (sha256tree (list TRIGGER_SIG_TAG TARGET TRIG_AMT REVAULT_AMT)) + SIG) + (c (list CREATE_OUTPUT_TAPROOT IK + (triggered-root TMH IK RSPK RKEY DELAY TARGET) TRIG_AMT) + (if (> REVAULT_AMT 0) + (list (list CREATE_OUTPUT_TAPROOT IK VROOT REVAULT_AMT)) + ()))))))) + + ; No operator derives the 34-byte taproot scriptPubKey, so the + ; shared scriptPubKey arrives in the solution and is proven equal + ; to the coin's own before it addresses or receives anything. + (defun follow-path (VROOT IK (MY_SPK)) + (list + (list ASSERT_MY_TAPROOT IK VROOT) + (list ASSERT_MY_SCRIPTPUBKEY MY_SPK) + (list SEND_MESSAGE CONSOLIDATE_MODE CONSOLIDATE_PAYLOAD MY_SPK))) + + (defun sum-amounts (AMOUNTS) + (if AMOUNTS (+ (f AMOUNTS) (sum-amounts (r AMOUNTS))) 0)) + + (defun receive-conditions (SPK AMOUNTS TAIL) + (if AMOUNTS + (c (list RECEIVE_MESSAGE CONSOLIDATE_MODE CONSOLIDATE_PAYLOAD + SPK (f AMOUNTS)) + (receive-conditions SPK (r AMOUNTS) TAIL)) + TAIL)) + + ; A leader without followers is rejected, so every consolidation + ; merges at least two coins: a conflicting consolidation an + ; adversary substitutes still merges the coins it consumes, and + ; no keyless path can split a coin's value. + (defun lead-path (VROOT IK (MY_SPK MY_AMT OUT_AMT FOLLOWER_AMOUNTS)) + (assert FOLLOWER_AMOUNTS + (not (> (+ MY_AMT (sum-amounts FOLLOWER_AMOUNTS)) OUT_AMT)) + (c (list ASSERT_MY_TAPROOT IK VROOT) + (c (list ASSERT_MY_SCRIPTPUBKEY MY_SPK) + (c (list ASSERT_MY_AMOUNT MY_AMT) + (receive-conditions MY_SPK FOLLOWER_AMOUNTS + (list (list CREATE_OUTPUT MY_SPK OUT_AMT)))))))) + + ; Exists to name VROOT once for every branch. + (defun dispatch (TMH AK IK RSPK RKEY DELAY VROOT PATH ARGS) + (if (= PATH TRIGGER_PATH) + (trigger-path TMH AK IK RSPK RKEY DELAY VROOT ARGS) + (if (= PATH RECOVER_PATH) + (recovery-conditions IK VROOT RSPK RKEY ARGS) + (if (= PATH FOLLOW_PATH) + (follow-path VROOT IK ARGS) + (if (= PATH LEAD_PATH) + (lead-path VROOT IK ARGS) + (x)))))) + + ; A malformed fixed value would break one path at spend time + ; while the others keep working, a quietly lost recovery being + ; the worst case, so every path checks the value widths, the + ; recovery script bounds, and the delay domain first and a + ; malformed instance fails on its first spend of any kind. The + ; delay must also be minimally encoded: a padded encoding reads + ; as the same number here but the sequence assert it feeds + ; rejects it, which would brick withdrawal alone. + (assert (= (strlen AUTH_KEY) 32) + (or (not RECOVERY_KEY) (= (strlen RECOVERY_KEY) 32)) + (> (strlen RECOVERY_SPK) 0) + (not (> (strlen RECOVERY_SPK) 10000)) + (not (> 0 DELAY)) + (not (> DELAY 65535)) + (= DELAY (+ DELAY 0)) + (dispatch TRIG_MOD_HASH AUTH_KEY INTERNAL_KEY RECOVERY_SPK + RECOVERY_KEY DELAY + (vault-root VAULT_MOD_HASH TRIG_MOD_HASH AUTH_KEY INTERNAL_KEY + RECOVERY_SPK RECOVERY_KEY DELAY) + PATH ARGS))) diff --git a/python/tests/test_vault_puzzles.py b/python/tests/test_vault_puzzles.py new file mode 100644 index 0000000..0b8acfa --- /dev/null +++ b/python/tests/test_vault_puzzles.py @@ -0,0 +1,733 @@ +"""Compile-and-run coverage for the vault benchmark puzzles. + +The two programs compile from source here, so these tests hold the +source-to-bytes link: the mod tree hashes are pinned as literals, the +in-program curried-hash reconstruction is checked against the curry +tooling's own hash, every spend path runs through the single-spend +runner against model transactions, every failure mode asserts its +exact error code live, and the pinned vector files are recomputed +from source so puzzle source and corpus cannot drift apart silently. +Signatures come from the vendored Bitcoin Core framework signer with +fixed aux bytes, so every derived value is deterministic. +""" + +import hashlib +import json +import sys +from pathlib import Path + +import pytest + +REPO_ROOT = Path(__file__).resolve().parents[2] +sys.path.insert(0, str(REPO_ROOT / "python")) +sys.path.insert(0, str(REPO_ROOT / "tools" / "oracle" / "bitcoincore")) + +from bitlisp import ( # noqa: E402 + BitLispError, + Transaction, + TxInput, + TxOutput, + run, + secp256k1, + serialize, +) +from bitlisp.conditions import parse_conditions # noqa: E402 +from bitlisp.sexp import int_to_atom, iter_proper_list # noqa: E402 +from bitlisp_tools import assemble # noqa: E402 +from bitlisp_tools.compiler import compile_program, tree_hash # noqa: E402 +from bitlisp_tools.curry import curry, uncurry # noqa: E402 +from bitlisp_tools.runner import run_spend # noqa: E402 +from test_framework.key import compute_xonly_pubkey, sign_schnorr # noqa: E402 + +PUZZLES = REPO_ROOT / "puzzles" +INCLUDES = (PUZZLES / "lib", PUZZLES / "vault") +BUDGET = 11_000_000_000 +SEQ_FINAL = 0xFFFFFFFF + +# The BIP341 nothing-up-my-sleeve point: no key-path spend exists. +NUMS = bytes.fromhex("50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0") +AUTH_SK = (0xA0 << 248 | 7).to_bytes(32, "big") +AUTH_PK = compute_xonly_pubkey(AUTH_SK)[0] +RKEY_SK = (0xB0 << 248 | 9).to_bytes(32, "big") +RKEY_PK = compute_xonly_pubkey(RKEY_SK)[0] +RECOVERY_SPK = bytes.fromhex("0014") + b"\x99" * 20 +FEE_SPK = bytes.fromhex("0014") + b"\x11" * 20 +DELAY = 144 +AUX = b"\x00" * 32 + +# Drift guards: recompiling the sources must reproduce these hashes, +# so any source change is a deliberate re-pin of both literals and +# the vector files. +VAULT_MOD_HASH = bytes.fromhex( + "15884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294f" +) +TRIG_MOD_HASH = bytes.fromhex( + "214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1b" +) + +VAULT_NODE, _ = compile_program((PUZZLES / "vault" / "vault.bl").read_text(), INCLUDES) +TRIG_NODE, _ = compile_program( + (PUZZLES / "vault" / "triggered.bl").read_text(), INCLUDES +) + + +def instance(node, values): + """A curried instance, its merkle root, and its scriptPubKey.""" + inst = curry(node, values) + root = tree_hash(inst) + return inst, root, b"\x51\x20" + secp256k1.taproot_output_key(NUMS, root) + + +def vault_values(recovery_key): + return [ + VAULT_MOD_HASH, + TRIG_MOD_HASH, + AUTH_PK, + NUMS, + RECOVERY_SPK, + recovery_key, + int_to_atom(DELAY), + ] + + +def trig_values(recovery_key, target): + return [ + TRIG_MOD_HASH, + NUMS, + RECOVERY_SPK, + recovery_key, + int_to_atom(DELAY), + target, + ] + + +VAULT, VROOT, VSPK = instance(VAULT_NODE, vault_values(b"")) +KVAULT, KVROOT, KVSPK = instance(VAULT_NODE, vault_values(RKEY_PK)) +TARGET = b"\x77" * 32 +TRIG, TROOT, TSPK = instance(TRIG_NODE, trig_values(b"", TARGET)) + +TXID = b"\xaa" * 32 +FEE_TXID = b"\xbb" * 32 + + +def sig_my_outpoint(sk, txid, index, message_node): + tag = hashlib.sha256(b"BitLisp/sig/my_outpoint").digest() + outpoint = txid + index.to_bytes(4, "little") + digest = hashlib.sha256(tag + tag + outpoint + tree_hash(message_node)).digest() + return sign_schnorr(sk, digest, AUX) + + +def trigger_solution(sk, txid, index, target, trig_amt, revault_amt, my_amt): + msg = assemble(f"(1 0x{target.hex()} {trig_amt} {revault_amt})") + sig = sig_my_outpoint(sk, txid, index, msg) + return assemble( + f"(1 0x{target.hex()} {trig_amt} {revault_amt} {my_amt} 0x{sig.hex()})" + ) + + +def fee_input(amount=20_000): + return TxInput(FEE_TXID, 0, FEE_SPK, amount, sequence=SEQ_FINAL) + + +def spend_error(program, solution, tx, input_index=0): + with pytest.raises(BitLispError) as info: + run_spend(program, solution, tx, input_index) + return info.value.code + + +def conditions_of(program, solution_text): + _, result = run(program, assemble(solution_text), BUDGET) + _, conds = parse_conditions(result, None) + return conds + + +def test_mod_hashes_pinned(): + assert tree_hash(VAULT_NODE) == VAULT_MOD_HASH + assert tree_hash(TRIG_NODE) == TRIG_MOD_HASH + + +def _h_atom(data): + return hashlib.sha256(b"\x01" + data).digest() + + +def _h_pair(left, right): + return hashlib.sha256(b"\x02" + left + right).digest() + + +def spec_curried_root(mod_hash, values): + """The curried instance's tree hash from the spec's two hash + rules alone, independent of tree_hash and of the puzzle helpers: + the curried shape is (a (q . F) (c (q . v1) ... 1)) with apply + the atom 2, quote and the chain terminator the atom 1, and cons + the atom 4. All curried values here are atoms.""" + chain = _h_atom(b"\x01") + for value in reversed(values): + quoted = _h_pair(_h_atom(b"\x01"), _h_atom(value)) + chain = _h_pair(_h_atom(b"\x04"), _h_pair(quoted, _h_pair(chain, _h_atom(b"")))) + program = _h_pair(_h_atom(b"\x01"), mod_hash) + return _h_pair(_h_atom(b"\x02"), _h_pair(program, _h_pair(chain, _h_atom(b"")))) + + +def test_curried_identity_matches_tooling(): + # Three independent computations of each instance's identity + # must agree: the tooling's tree_hash over the curried node, the + # spec-rule reimplementation above, and the program's own + # reconstruction read off the taproot assert it emits. uncurry + # must also read back the inner program and the fixed values. + for node, inst, root, values in ( + (VAULT_NODE, VAULT, VROOT, vault_values(b"")), + (TRIG_NODE, TRIG, TROOT, trig_values(b"", TARGET)), + ): + mod_hash = values[0] + assert spec_curried_root(mod_hash, values) == root + inner, read_back = uncurry(inst) + assert inner == node + assert read_back == values + conds = conditions_of(VAULT, f"(3 0x{VSPK.hex()})") + assert conds[0].merkle_root == VROOT + assert conds[0].script_pubkey == VSPK + + +def test_trigger_spend_with_revault(): + solution = trigger_solution(AUTH_SK, TXID, 0, TARGET, 40_000, 20_000, 60_000) + tx = Transaction( + version=2, + locktime=0, + inputs=( + TxInput(TXID, 0, VSPK, 60_000, sequence=SEQ_FINAL), + fee_input(), + ), + outputs=(TxOutput(TSPK, 40_000), TxOutput(VSPK, 20_000)), + ) + _, conds = run_spend(VAULT, solution, tx) + # The revault claim re-encumbers under the byte-exact vault + # scriptPubKey. + assert conds[-1].script_pubkey == VSPK + + +def test_trigger_value_shortfall_raises(): + solution = trigger_solution(AUTH_SK, TXID, 0, TARGET, 30_000, 0, 60_000) + with pytest.raises(BitLispError) as info: + run(VAULT, solution, BUDGET) + assert info.value.code == "user_raise" + + +def path_raises(program, solution): + if isinstance(solution, str): + solution = assemble(solution) + with pytest.raises(BitLispError) as info: + run(program, solution, BUDGET) + return info.value.code + + +def test_trigger_amount_guards(): + # A misbehaving signer still cannot mint an oversized triggered + # coin through a negative revault amount or a worthless one + # through a zero trigger amount, and a malformed target is + # rejected before it becomes an unwithdrawable coin. + for trig_amt, revault_amt in ((60_001, -1), (0, 60_000)): + solution = trigger_solution( + AUTH_SK, TXID, 0, TARGET, trig_amt, revault_amt, 60_000 + ) + assert path_raises(VAULT, solution) == "user_raise" + short_target = trigger_solution(AUTH_SK, TXID, 0, b"\x77" * 31, 60_000, 0, 60_000) + assert path_raises(VAULT, short_target) == "user_raise" + + +def test_malformed_instance_fails_every_path(): + # A fixed value outside its domain would break one path at spend + # time while the others kept working, so every path rejects the + # instance up front, on whichever spend is tried first. + bad_instances = ( + instance(VAULT_NODE, vault_values(b"\x02" + RKEY_PK))[0], + instance( + VAULT_NODE, + [ + VAULT_MOD_HASH, + TRIG_MOD_HASH, + b"\x02" + AUTH_PK, + NUMS, + RECOVERY_SPK, + b"", + int_to_atom(DELAY), + ], + )[0], + ) + solutions = ( + f"(3 0x{VSPK.hex()})", + "(2 60000 60000)", + f"(4 0x{VSPK.hex()} 60000 120000 (60000))", + ) + for bad in bad_instances: + for solution in solutions: + assert path_raises(bad, solution) == "user_raise" + overlong_delay = instance( + VAULT_NODE, + [ + VAULT_MOD_HASH, + TRIG_MOD_HASH, + AUTH_PK, + NUMS, + RECOVERY_SPK, + b"", + int_to_atom(65_536), + ], + )[0] + assert path_raises(overlong_delay, f"(3 0x{VSPK.hex()})") == "user_raise" + nil_recovery_spk = instance( + VAULT_NODE, + [ + VAULT_MOD_HASH, + TRIG_MOD_HASH, + AUTH_PK, + NUMS, + b"", + b"", + int_to_atom(DELAY), + ], + )[0] + for solution in solutions: + assert path_raises(nil_recovery_spk, solution) == "user_raise" + padded_delay = instance( + VAULT_NODE, + [ + VAULT_MOD_HASH, + TRIG_MOD_HASH, + AUTH_PK, + NUMS, + RECOVERY_SPK, + b"", + b"\x00\x00\x90", + ], + )[0] + assert path_raises(padded_delay, f"(3 0x{VSPK.hex()})") == "user_raise" + bad_triggered = instance( + TRIG_NODE, + [ + TRIG_MOD_HASH, + NUMS, + RECOVERY_SPK, + b"\x02" + RKEY_PK, + int_to_atom(DELAY), + TARGET, + ], + )[0] + assert path_raises(bad_triggered, "(1)") == "user_raise" + + +def test_trigger_signature_binds_target(): + # An attacker redirects the trigger to a different target and + # supplies the matching output, so the output claim passes and + # only the signature's message binding stops the redirect. + solution = trigger_solution(AUTH_SK, TXID, 0, TARGET, 60_000, 0, 60_000) + other_target = b"\x66" * 32 + _, _, other_tspk = instance(TRIG_NODE, trig_values(b"", other_target)) + items = list(iter_proper_list(solution)) + redirected = assemble( + f"(1 0x{other_target.hex()} 60000 0 60000 0x{items[5].hex()})" + ) + tx = Transaction( + version=2, + locktime=0, + inputs=( + TxInput(TXID, 0, VSPK, 60_000, sequence=SEQ_FINAL), + fee_input(), + ), + outputs=(TxOutput(other_tspk, 60_000),), + ) + assert spend_error(VAULT, redirected, tx) == "unsatisfied_sig_assert" + + +def test_trigger_signature_binds_outpoint(): + # The same authorization replayed onto a sibling coin of the + # same instance fails: the digest binds the consumed outpoint. + solution = trigger_solution(AUTH_SK, TXID, 0, TARGET, 60_000, 0, 60_000) + tx = Transaction( + version=2, + locktime=0, + inputs=( + TxInput(b"\xcd" * 32, 0, VSPK, 60_000, sequence=SEQ_FINAL), + fee_input(), + ), + outputs=(TxOutput(TSPK, 60_000),), + ) + assert spend_error(VAULT, solution, tx) == "unsatisfied_sig_assert" + + +def test_full_lifecycle(): + # Vault coin -> trigger -> matured withdrawal, outpoints taken + # from each real transaction's txid. + vault_tx = Transaction( + version=2, + locktime=0, + inputs=(fee_input(200_000),), + outputs=(TxOutput(VSPK, 100_000),), + ) + vault_outpoint = (vault_tx.txid, 0) + + withdrawal_out = TxOutput(bytes.fromhex("0014") + b"\x22" * 20, 99_000) + probe = Transaction( + version=2, + locktime=0, + inputs=(fee_input(200_000),), + outputs=(withdrawal_out,), + ) + real_target = probe.outputs_hash + trig_inst, _, trig_spk = instance(TRIG_NODE, trig_values(b"", real_target)) + + solution = trigger_solution( + AUTH_SK, vault_outpoint[0], 0, real_target, 100_000, 0, 100_000 + ) + trigger_tx = Transaction( + version=2, + locktime=0, + inputs=( + TxInput(*vault_outpoint, VSPK, 100_000, sequence=SEQ_FINAL), + fee_input(), + ), + outputs=(TxOutput(trig_spk, 100_000),), + ) + run_spend(VAULT, solution, trigger_tx) + + def withdrawal(sequence): + return Transaction( + version=2, + locktime=0, + inputs=(TxInput(trigger_tx.txid, 0, trig_spk, 100_000, sequence=sequence),), + outputs=(withdrawal_out,), + ) + + run_spend(trig_inst, assemble("(1)"), withdrawal(DELAY)) + assert ( + spend_error(trig_inst, assemble("(1)"), withdrawal(DELAY - 1)) + == "unsatisfied_sequence_assert" + ) + + # The seal leaves the input side open, so a fee input can be + # added, but any grafted output invalidates the withdrawal. + matured = withdrawal(DELAY) + with_fee = Transaction( + version=2, + locktime=0, + inputs=matured.inputs + (fee_input(),), + outputs=matured.outputs, + ) + run_spend(trig_inst, assemble("(1)"), with_fee) + grafted = Transaction( + version=2, + locktime=0, + inputs=with_fee.inputs, + outputs=matured.outputs + (TxOutput(FEE_SPK, 10_000),), + ) + assert spend_error(trig_inst, assemble("(1)"), grafted) == "unsatisfied_seal_assert" + + # Recovery works from both states at any time. + recovery_from_vault = Transaction( + version=2, + locktime=0, + inputs=( + TxInput(*vault_outpoint, VSPK, 100_000, sequence=SEQ_FINAL), + fee_input(), + ), + outputs=(TxOutput(RECOVERY_SPK, 100_000),), + ) + run_spend(VAULT, assemble("(2 100000 100000)"), recovery_from_vault) + recovery_from_triggered = Transaction( + version=2, + locktime=0, + inputs=( + TxInput(trigger_tx.txid, 0, trig_spk, 100_000, sequence=SEQ_FINAL), + fee_input(), + ), + outputs=(TxOutput(RECOVERY_SPK, 100_000),), + ) + run_spend(trig_inst, assemble("(2 100000 100000)"), recovery_from_triggered) + + +def keyed_recovery_solution(txid, my_amt, recover_amt, sig=None): + if sig is None: + msg = assemble(f"(2 {my_amt} {recover_amt})") + sig = sig_my_outpoint(RKEY_SK, txid, 0, msg) + return assemble(f"(2 {my_amt} {recover_amt} 0x{sig.hex()})") + + +def keyed_recovery_tx(): + return Transaction( + version=2, + locktime=0, + inputs=( + TxInput(TXID, 0, KVSPK, 60_000, sequence=SEQ_FINAL), + fee_input(), + ), + outputs=(TxOutput(RECOVERY_SPK, 60_000),), + ) + + +def test_keyed_recovery(): + run_spend( + KVAULT, keyed_recovery_solution(TXID, 60_000, 60_000), keyed_recovery_tx() + ) + # A wrong key's signature fails, and a solution missing the + # signature dies in the VM reaching for it. + wrong = sig_my_outpoint(AUTH_SK, TXID, 0, assemble("(2 60000 60000)")) + assert ( + spend_error( + KVAULT, + keyed_recovery_solution(TXID, 60_000, 60_000, sig=wrong), + keyed_recovery_tx(), + ) + == "unsatisfied_sig_assert" + ) + with pytest.raises(BitLispError) as info: + run(KVAULT, assemble("(2 60000 60000)"), BUDGET) + assert info.value.code == "arg_not_pair" + + +def test_recovery_cannot_underpay(): + with pytest.raises(BitLispError) as info: + run(VAULT, assemble("(2 60000 59999)"), BUDGET) + assert info.value.code == "user_raise" + underfunded = Transaction( + version=2, + locktime=0, + inputs=( + TxInput(TXID, 0, VSPK, 60_000, sequence=SEQ_FINAL), + fee_input(), + ), + outputs=(TxOutput(RECOVERY_SPK, 59_999),), + ) + assert ( + spend_error(VAULT, assemble("(2 60000 60000)"), underfunded) + == "unsatisfied_output_claim" + ) + + +def follower_conditions(): + return conditions_of(VAULT, f"(3 0x{VSPK.hex()})") + + +def consolidation_tx(listed, out_amt, followers=(50_000, 30_000)): + listed_text = " ".join(str(a) for a in listed) + solution = assemble(f"(4 0x{VSPK.hex()} 60000 {out_amt} ({listed_text}))") + inputs = [TxInput(b"\xd0" * 32, 0, VSPK, 60_000, sequence=SEQ_FINAL)] + for i, amount in enumerate(followers): + inputs.append( + TxInput( + bytes([0xD1 + i]) * 32, + 0, + VSPK, + amount, + sequence=SEQ_FINAL, + conditions=follower_conditions(), + ) + ) + inputs.append(fee_input(50_000)) + tx = Transaction( + version=2, + locktime=0, + inputs=tuple(inputs), + outputs=(TxOutput(VSPK, out_amt),), + ) + return solution, tx + + +def test_consolidation_three_coins(): + solution, tx = consolidation_tx((50_000, 30_000), 140_000) + run_spend(VAULT, solution, tx) + + +def test_consolidation_omitted_follower(): + solution, tx = consolidation_tx((50_000,), 110_000) + assert spend_error(VAULT, solution, tx) == "unbalanced_message" + + +def test_consolidation_rejects_empty_follower_list(): + # A leader alone is not a consolidation: every consolidation + # merges at least two coins, so conflicting consolidations still + # shrink the coin set at this scriptPubKey. + with pytest.raises(BitLispError) as info: + run(VAULT, assemble(f"(4 0x{VSPK.hex()} 60000 60000 ())"), BUDGET) + assert info.value.code == "user_raise" + + +def test_consolidation_rejects_negative_listed_amount(): + # A negative listed amount would deflate the in-program sum, so + # the specifier's amount domain must close the hole at parse + # time before the ledger runs. + solution, tx = consolidation_tx((50_000, -1), 110_000) + assert spend_error(VAULT, solution, tx) == "bad_condition_arg" + + +def test_consolidation_output_cannot_underpay(): + with pytest.raises(BitLispError) as info: + run(VAULT, assemble(f"(4 0x{VSPK.hex()} 60000 139999 (50000 30000))"), BUDGET) + assert info.value.code == "user_raise" + + +def test_same_target_withdrawals_merge_and_burn(): + # Two matured triggered coins carrying the same target satisfy + # one committed output set together, and the second coin's value + # goes entirely to fees: the recorded consequence of SEAL_OUTPUTS + # leaving the input side open, which is why wallets must make + # every target unique. + wd_out = TxOutput(bytes.fromhex("0014") + b"\x22" * 20, 39_000) + real_target = hashlib.sha256(wd_out.wire).digest() + trig_inst, _, trig_spk = instance(TRIG_NODE, trig_values(b"", real_target)) + other = TxInput( + b"\xce" * 32, + 0, + trig_spk, + 40_000, + sequence=DELAY, + conditions=conditions_of(trig_inst, "(1)"), + ) + merged = Transaction( + version=2, + locktime=0, + inputs=( + TxInput(b"\xcc" * 32, 1, trig_spk, 40_000, sequence=DELAY), + other, + ), + outputs=(wd_out,), + ) + run_spend(trig_inst, assemble("(1)"), merged) + + +def test_unknown_path_raises(): + with pytest.raises(BitLispError) as info: + run(VAULT, assemble("(9)"), BUDGET) + assert info.value.code == "user_raise" + + +def load_vector(name): + path = REPO_ROOT / "vectors" / name + return {case["name"]: case for case in json.loads(path.read_text())["cases"]} + + +def test_vm_vectors_match_source(): + # Every pinned program is byte-identical to a fresh compile and + # curry of the sources, so the corpus cannot drift from them. + cases = load_vector("vm/vault-programs.json") + malformed_rkey = instance(VAULT_NODE, vault_values(b"\x02" + RKEY_PK))[0] + overlong_delay = instance( + VAULT_NODE, + [ + VAULT_MOD_HASH, + TRIG_MOD_HASH, + AUTH_PK, + NUMS, + RECOVERY_SPK, + b"", + int_to_atom(65_536), + ], + )[0] + nil_recovery_spk = instance( + VAULT_NODE, + [VAULT_MOD_HASH, TRIG_MOD_HASH, AUTH_PK, NUMS, b"", b"", int_to_atom(DELAY)], + )[0] + padded_delay = instance( + VAULT_NODE, + [ + VAULT_MOD_HASH, + TRIG_MOD_HASH, + AUTH_PK, + NUMS, + RECOVERY_SPK, + b"", + b"\x00\x00\x90", + ], + )[0] + by_program = { + "vault_trigger_no_revault": VAULT, + "vault_trigger_with_revault": VAULT, + "vault_recover_keyless": VAULT, + "vault_recover_keyed": KVAULT, + "vault_follow": VAULT, + "vault_lead_two_followers": VAULT, + "triggered_withdraw": TRIG, + "triggered_recover": TRIG, + "vault_trigger_value_shortfall": VAULT, + "vault_trigger_negative_revault": VAULT, + "vault_trigger_zero_amount": VAULT, + "vault_malformed_recovery_key_unspendable": malformed_rkey, + "vault_overlong_delay_unspendable": overlong_delay, + "vault_nil_recovery_spk_unspendable": nil_recovery_spk, + "vault_padded_delay_unspendable": padded_delay, + "vault_lead_no_followers": VAULT, + "vault_unknown_path": VAULT, + } + assert set(cases) == set(by_program) + for name, node in by_program.items(): + assert cases[name]["program"] == serialize(node).hex(), name + + +def emitted_hex(program, solution): + if isinstance(solution, str): + solution = assemble(solution) + return serialize(run(program, solution, BUDGET)[1]).hex() + + +def lead_hex(listed, out_amt): + listed_text = " ".join(str(a) for a in listed) + return emitted_hex(VAULT, f"(4 0x{VSPK.hex()} 60000 {out_amt} ({listed_text}))") + + +def test_validation_vectors_match_source(): + # The complete closure: every conditions field in both validation + # vector files is recomputed here, from compiled source for the + # program-derived lists and from its documented construction for + # the hand-built hostile and encoding variants. Set equality in + # both directions, so a drifted payload fails and so does a + # vector case this table does not account for. + trig_nr = emitted_hex( + VAULT, trigger_solution(AUTH_SK, TXID, 0, TARGET, 60_000, 0, 60_000) + ) + nr_sig = sig_my_outpoint( + AUTH_SK, TXID, 0, assemble(f"(1 0x{TARGET.hex()} 60000 0)") + ) + flipped = bytes([nr_sig[0] ^ 0x01]) + nr_sig[1:] + wd_out = TxOutput(bytes.fromhex("0014") + b"\x22" * 20, 39_000) + real_target = hashlib.sha256(wd_out.wire).digest() + trig_w = instance(TRIG_NODE, trig_values(b"", real_target))[0] + one_follower_lead = lead_hex((50_000,), 110_000) + assert one_follower_lead.count("8300c350") == 1 + expected = { + trig_nr, + trig_nr.replace(nr_sig.hex(), flipped.hex()), + emitted_hex( + VAULT, + trigger_solution(AUTH_SK, TXID, 0, TARGET, 40_000, 20_000, 60_000), + ), + emitted_hex( + VAULT, + f"(1 0x{'66' * 32} 60000 0 60000 0x{nr_sig.hex()})", + ), + emitted_hex(trig_w, "(1)"), + emitted_hex(VAULT, "(2 60000 60000)"), + emitted_hex(KVAULT, keyed_recovery_solution(TXID, 60_000, 60_000)), + emitted_hex(TRIG, "(2 40000 40000)"), + emitted_hex(VAULT, f"(3 0x{VSPK.hex()})"), + lead_hex((50_000, 30_000), 140_000), + lead_hex((50_000, 50_000), 160_000), + lead_hex((50_000,), 110_000), + lead_hex((30_000,), 90_000), + lead_hex((40_000, 30_000), 130_000), + lead_hex((60_000, 30_000), 150_000), + emitted_hex(VAULT, f"(4 0x{VSPK.hex()} 60000 110000 (50000 -1))"), + one_follower_lead.replace("8300c350", "840000c350"), + serialize( + assemble( + f"((0x43 26 () 0x{VSPK.hex()} 50000)" + f" (0x43 26 () 0x{VSPK.hex()} 30000)" + f" (0x01 0x{'5120' + '42' * 32} 85000))" + ) + ).hex(), + serialize(assemble(f"((0x42 26 () 0x{VSPK.hex()}))")).hex(), + } + observed = set() + for name in ("validation/vault-core.json", "validation/vault-consolidation.json"): + for case in load_vector(name).values(): + for entry in case["tx"]["inputs"]: + if "conditions" in entry: + observed.add(entry["conditions"]) + assert observed == expected diff --git a/vectors/validation/vault-consolidation.json b/vectors/validation/vault-consolidation.json new file mode 100644 index 0000000..b8e6da8 --- /dev/null +++ b/vectors/validation/vault-consolidation.json @@ -0,0 +1,735 @@ +{ + "schema": "bitlisp-vector-v0", + "suite": "validation", + "spec": "VALIDATION.md rules 1 and 3: the vault consolidation message ledger, its composition cases, and its theft cases", + "cases": [ + { + "name": "consolidate_two_followers_valid", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300c35080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff82753080ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff830222e08080" + }, + { + "txid": "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 30000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 140000 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "consolidate_equal_amount_followers_valid", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300c35080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300c35080ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff830271008080" + }, + { + "txid": "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 160000 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "omitted_follower", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300c35080ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8301adb08080" + }, + { + "txid": "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 30000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 110000 + } + ] + }, + "expect": { + "error": "unbalanced_message" + } + }, + { + "name": "phantom_follower", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300c35080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff82753080ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff830222e08080" + }, + { + "txid": "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 140000 + } + ] + }, + "expect": { + "error": "unbalanced_message" + } + }, + { + "name": "understated_amount", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff83009c4080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff82753080ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8301fbd08080" + }, + { + "txid": "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 30000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 130000 + } + ] + }, + "expect": { + "error": "unbalanced_message" + } + }, + { + "name": "overstated_amount", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff82753080ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff830249f08080" + }, + { + "txid": "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 30000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 150000 + } + ] + }, + "expect": { + "error": "unbalanced_message" + } + }, + { + "name": "equal_followers_single_receive", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300c35080ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8301adb08080" + }, + { + "txid": "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 110000 + } + ] + }, + "expect": { + "error": "unbalanced_message" + } + }, + { + "name": "hostile_leader_foreign_spk", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0", + "index": 0, + "script_pubkey": "51204242424242424242424242424242424242424242424242424242424242424242", + "amount": 90000, + "sequence": 4294967295, + "conditions": "ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300c35080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff82753080ffff01ffa251204242424242424242424242424242424242424242424242424242424242424242ff83014c088080" + }, + { + "txid": "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 30000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + } + ], + "outputs": [ + { + "script_pubkey": "51204242424242424242424242424242424242424242424242424242424242424242", + "amount": 85000 + } + ] + }, + "expect": { + "error": "unbalanced_message" + } + }, + { + "name": "hostile_extra_sender", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300c35080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff82753080ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff830222e08080" + }, + { + "txid": "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 30000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1f1", + "index": 0, + "script_pubkey": "51204242424242424242424242424242424242424242424242424242424242424242", + "amount": 10000, + "sequence": 4294967295, + "conditions": "ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 140000 + } + ] + }, + "expect": { + "error": "unbalanced_message" + } + }, + { + "name": "two_disjoint_groups_one_tx_valid", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300c35080ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8301adb08080" + }, + { + "txid": "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff82753080ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff83015f908080" + }, + { + "txid": "d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 30000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 110000 + }, + { + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 90000 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "leader_output_missing", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300c35080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff82753080ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff830222e08080" + }, + { + "txid": "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 30000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 140000 + } + ] + }, + "expect": { + "error": "unsatisfied_output_claim" + } + }, + { + "name": "leader_output_underpaid_slot", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300c35080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff82753080ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff830222e08080" + }, + { + "txid": "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2d2", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 30000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 139999 + } + ] + }, + "expect": { + "error": "unsatisfied_output_claim" + } + }, + { + "name": "leader_lists_negative_amount", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300c35080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff81ff80ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8301adb08080" + }, + { + "txid": "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 110000 + } + ] + }, + "expect": { + "error": "bad_condition_arg" + } + }, + { + "name": "leader_lists_nonminimal_amount", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff840000c35080ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8301adb08080" + }, + { + "txid": "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 110000 + } + ] + }, + "expect": { + "error": "bad_condition_arg" + } + }, + { + "name": "two_leaders_claim_one_follower", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0d0", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300c35080ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8301adb08080" + }, + { + "txid": "d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3d3", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300c35080ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8301adb08080" + }, + { + "txid": "d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1d1", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 60000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 110000 + }, + { + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 110000 + } + ] + }, + "expect": { + "error": "unbalanced_message" + } + } + ] +} diff --git a/vectors/validation/vault-core.json b/vectors/validation/vault-core.json new file mode 100644 index 0000000..67666de --- /dev/null +++ b/vectors/validation/vault-core.json @@ -0,0 +1,767 @@ +{ + "schema": "bitlisp-vector-v0", + "suite": "validation", + "spec": "VALIDATION.md rules 1, 2, and 8 over CONDITIONS.md entries CREATE_OUTPUT, CREATE_OUTPUT_TAPROOT, ASSERT_MY_TAPROOT, ASSERT_MY_AMOUNT, ASSERT_MY_SCRIPTPUBKEY, ASSERT_SIG_MY_OUTPOINT, ASSERT_SEQUENCE_HEIGHT, and SEAL_OUTPUTS: the vault lifecycle", + "cases": [ + { + "name": "trigger_valid", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff17ffa09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffa074a1dac82d62d64aafa24a7640eddc5dd65bbf3c18f2564e4bd611e478e4d8b1ffc04001ccff6c0e017b85b084141ec54504efd546ca591a569baa91871f6d20163493db6c39bd906cbf2a3fe1be56a8865a38775c47c92779608862f86b2361b4e43580ffff02ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa060d74fa544aedc2bb5a72fb689cff3614a7c71411cc58dc786b568d3068c3dccff8300ea608080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "512063435d4363e56fa694c4da7ed70c92ce880fe305a3312079d13b0ac54d924814", + "amount": 60000 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "trigger_with_revault_valid", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff17ffa09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffa0e5da0e08c8d6a9cf5d5db18b5c09bf6a09ef1ff6f245c813d452ff967db7f7fdffc040d7bf2f33b9c58f943958e52dfd6bb9d7bab284f11a2e5c8a3a1b8c6628d888e882b516d3b5a22efe4406505ff4fe239760d2d4ae60143fc3453c285a67a4820980ffff02ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa060d74fa544aedc2bb5a72fb689cff3614a7c71411cc58dc786b568d3068c3dccff83009c4080ffff02ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d7ff824e208080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "512063435d4363e56fa694c4da7ed70c92ce880fe305a3312079d13b0ac54d924814", + "amount": 40000 + }, + { + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 20000 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "trigger_bad_sig", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff17ffa09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffa074a1dac82d62d64aafa24a7640eddc5dd65bbf3c18f2564e4bd611e478e4d8b1ffc04000ccff6c0e017b85b084141ec54504efd546ca591a569baa91871f6d20163493db6c39bd906cbf2a3fe1be56a8865a38775c47c92779608862f86b2361b4e43580ffff02ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa060d74fa544aedc2bb5a72fb689cff3614a7c71411cc58dc786b568d3068c3dccff8300ea608080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "512063435d4363e56fa694c4da7ed70c92ce880fe305a3312079d13b0ac54d924814", + "amount": 60000 + } + ] + }, + "expect": { + "error": "unsatisfied_sig_assert" + } + }, + { + "name": "trigger_sig_replayed_other_outpoint", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff17ffa09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffa074a1dac82d62d64aafa24a7640eddc5dd65bbf3c18f2564e4bd611e478e4d8b1ffc04001ccff6c0e017b85b084141ec54504efd546ca591a569baa91871f6d20163493db6c39bd906cbf2a3fe1be56a8865a38775c47c92779608862f86b2361b4e43580ffff02ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa060d74fa544aedc2bb5a72fb689cff3614a7c71411cc58dc786b568d3068c3dccff8300ea608080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "512063435d4363e56fa694c4da7ed70c92ce880fe305a3312079d13b0ac54d924814", + "amount": 60000 + } + ] + }, + "expect": { + "error": "unsatisfied_sig_assert" + } + }, + { + "name": "trigger_redirected_target", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff17ffa09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffa074a1dac82d62d64aafa24a7640eddc5dd65bbf3c18f2564e4bd611e478e4d8b1ffc04001ccff6c0e017b85b084141ec54504efd546ca591a569baa91871f6d20163493db6c39bd906cbf2a3fe1be56a8865a38775c47c92779608862f86b2361b4e43580ffff02ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa060d74fa544aedc2bb5a72fb689cff3614a7c71411cc58dc786b568d3068c3dccff8300ea608080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "51206c327a17243e4be609de4a06ac9be62b58062c5e268376a9037c9080d141c6c9", + "amount": 60000 + } + ] + }, + "expect": { + "error": "unsatisfied_output_claim" + } + }, + { + "name": "trigger_amount_misstated", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 50000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff17ffa09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffa074a1dac82d62d64aafa24a7640eddc5dd65bbf3c18f2564e4bd611e478e4d8b1ffc04001ccff6c0e017b85b084141ec54504efd546ca591a569baa91871f6d20163493db6c39bd906cbf2a3fe1be56a8865a38775c47c92779608862f86b2361b4e43580ffff02ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa060d74fa544aedc2bb5a72fb689cff3614a7c71411cc58dc786b568d3068c3dccff8300ea608080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "512063435d4363e56fa694c4da7ed70c92ce880fe305a3312079d13b0ac54d924814", + "amount": 60000 + } + ] + }, + "expect": { + "error": "unsatisfied_amount_assert" + } + }, + { + "name": "trigger_stale_sig_redirected_target", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff17ffa09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffa08de0b316da8a2693edcf24caf7fe38da52d807226360304216de26f411de9132ffc04001ccff6c0e017b85b084141ec54504efd546ca591a569baa91871f6d20163493db6c39bd906cbf2a3fe1be56a8865a38775c47c92779608862f86b2361b4e43580ffff02ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0a0ad59feab606c09d12cb436a4e0dbc25c139fb2bffedcf2defaddb2380c7e31ff8300ea608080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "51206c327a17243e4be609de4a06ac9be62b58062c5e268376a9037c9080d141c6c9", + "amount": 60000 + } + ] + }, + "expect": { + "error": "unsatisfied_sig_assert" + } + }, + { + "name": "withdraw_valid", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", + "index": 1, + "script_pubkey": "5120954d91ca398cf810e949c8fce3c727532f5c71e1fa4605d0c42e8c223a810d51", + "amount": 40000, + "sequence": 144, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0452dec2bf69a035745d1c57ddfaa66a3024e6a415abc970a01bc76ec94a6bc9980ffff22ff82009080ffff61ffa06584085b8098e1eb59f962912f5471d034345aeb060b3814bdcf5f29d6a78f608080" + } + ], + "outputs": [ + { + "script_pubkey": "00142222222222222222222222222222222222222222", + "amount": 39000 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "withdraw_before_delay", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", + "index": 1, + "script_pubkey": "5120954d91ca398cf810e949c8fce3c727532f5c71e1fa4605d0c42e8c223a810d51", + "amount": 40000, + "sequence": 143, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0452dec2bf69a035745d1c57ddfaa66a3024e6a415abc970a01bc76ec94a6bc9980ffff22ff82009080ffff61ffa06584085b8098e1eb59f962912f5471d034345aeb060b3814bdcf5f29d6a78f608080" + } + ], + "outputs": [ + { + "script_pubkey": "00142222222222222222222222222222222222222222", + "amount": 39000 + } + ] + }, + "expect": { + "error": "unsatisfied_sequence_assert" + } + }, + { + "name": "withdraw_version_1", + "tx": { + "version": 1, + "locktime": 0, + "inputs": [ + { + "txid": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", + "index": 1, + "script_pubkey": "5120954d91ca398cf810e949c8fce3c727532f5c71e1fa4605d0c42e8c223a810d51", + "amount": 40000, + "sequence": 144, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0452dec2bf69a035745d1c57ddfaa66a3024e6a415abc970a01bc76ec94a6bc9980ffff22ff82009080ffff61ffa06584085b8098e1eb59f962912f5471d034345aeb060b3814bdcf5f29d6a78f608080" + } + ], + "outputs": [ + { + "script_pubkey": "00142222222222222222222222222222222222222222", + "amount": 39000 + } + ] + }, + "expect": { + "error": "unsatisfied_sequence_assert" + } + }, + { + "name": "withdraw_wrong_outputs", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", + "index": 1, + "script_pubkey": "5120954d91ca398cf810e949c8fce3c727532f5c71e1fa4605d0c42e8c223a810d51", + "amount": 40000, + "sequence": 144, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0452dec2bf69a035745d1c57ddfaa66a3024e6a415abc970a01bc76ec94a6bc9980ffff22ff82009080ffff61ffa06584085b8098e1eb59f962912f5471d034345aeb060b3814bdcf5f29d6a78f608080" + } + ], + "outputs": [ + { + "script_pubkey": "00142222222222222222222222222222222222222222", + "amount": 38000 + } + ] + }, + "expect": { + "error": "unsatisfied_seal_assert" + } + }, + { + "name": "withdraw_extra_output_grafted", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", + "index": 1, + "script_pubkey": "5120954d91ca398cf810e949c8fce3c727532f5c71e1fa4605d0c42e8c223a810d51", + "amount": 40000, + "sequence": 144, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0452dec2bf69a035745d1c57ddfaa66a3024e6a415abc970a01bc76ec94a6bc9980ffff22ff82009080ffff61ffa06584085b8098e1eb59f962912f5471d034345aeb060b3814bdcf5f29d6a78f608080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "00142222222222222222222222222222222222222222", + "amount": 39000 + }, + { + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 10000 + } + ] + }, + "expect": { + "error": "unsatisfied_seal_assert" + } + }, + { + "name": "same_target_withdrawals_merge_second_burns", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", + "index": 1, + "script_pubkey": "5120954d91ca398cf810e949c8fce3c727532f5c71e1fa4605d0c42e8c223a810d51", + "amount": 40000, + "sequence": 144, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0452dec2bf69a035745d1c57ddfaa66a3024e6a415abc970a01bc76ec94a6bc9980ffff22ff82009080ffff61ffa06584085b8098e1eb59f962912f5471d034345aeb060b3814bdcf5f29d6a78f608080" + }, + { + "txid": "cececececececececececececececececececececececececececececececece", + "index": 0, + "script_pubkey": "5120954d91ca398cf810e949c8fce3c727532f5c71e1fa4605d0c42e8c223a810d51", + "amount": 40000, + "sequence": 144, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0452dec2bf69a035745d1c57ddfaa66a3024e6a415abc970a01bc76ec94a6bc9980ffff22ff82009080ffff61ffa06584085b8098e1eb59f962912f5471d034345aeb060b3814bdcf5f29d6a78f608080" + } + ], + "outputs": [ + { + "script_pubkey": "00142222222222222222222222222222222222222222", + "amount": 39000 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "withdraw_added_fee_input_valid", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", + "index": 1, + "script_pubkey": "5120954d91ca398cf810e949c8fce3c727532f5c71e1fa4605d0c42e8c223a810d51", + "amount": 40000, + "sequence": 144, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0452dec2bf69a035745d1c57ddfaa66a3024e6a415abc970a01bc76ec94a6bc9980ffff22ff82009080ffff61ffa06584085b8098e1eb59f962912f5471d034345aeb060b3814bdcf5f29d6a78f608080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "00142222222222222222222222222222222222222222", + "amount": 39000 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "recover_from_vault_keyless_valid", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff01ff9600149999999999999999999999999999999999999999ff8300ea608080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "00149999999999999999999999999999999999999999", + "amount": 60000 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "recover_from_vault_keyed_valid", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "index": 0, + "script_pubkey": "5120a735f4b2294c1cdd5ab61c3316f3f2d3a6c99e6eca84f583cbf30be5b8282648", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa093297d3ee280167745f601e2f3a72446f724415eba0b696af4df84d0e4ee618a80ffff33ff8300ea6080ffff01ff9600149999999999999999999999999999999999999999ff8300ea6080ffff17ffa0860200f3ca1e283b931d88e4a14e504e3710eb7cccacc8705ff9496ed5153616ffa0a89e7a8db863d5d2a0fe88aa9463f5a6b4fac900d79792f9f31b8dbcda9052a9ffc040907d1322273b20300d6fcab2b608d816b6aac8beb6eac9cea9c0e09159e6da08cf432e14099a2db27bad733bec34012ff29b6cae16185a43046b0ef0534a1bce8080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "00149999999999999999999999999999999999999999", + "amount": 60000 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "recover_keyed_replayed_other_outpoint", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd", + "index": 0, + "script_pubkey": "5120a735f4b2294c1cdd5ab61c3316f3f2d3a6c99e6eca84f583cbf30be5b8282648", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa093297d3ee280167745f601e2f3a72446f724415eba0b696af4df84d0e4ee618a80ffff33ff8300ea6080ffff01ff9600149999999999999999999999999999999999999999ff8300ea6080ffff17ffa0860200f3ca1e283b931d88e4a14e504e3710eb7cccacc8705ff9496ed5153616ffa0a89e7a8db863d5d2a0fe88aa9463f5a6b4fac900d79792f9f31b8dbcda9052a9ffc040907d1322273b20300d6fcab2b608d816b6aac8beb6eac9cea9c0e09159e6da08cf432e14099a2db27bad733bec34012ff29b6cae16185a43046b0ef0534a1bce8080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "00149999999999999999999999999999999999999999", + "amount": 60000 + } + ] + }, + "expect": { + "error": "unsatisfied_sig_assert" + } + }, + { + "name": "recover_from_triggered_valid", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", + "index": 1, + "script_pubkey": "512063435d4363e56fa694c4da7ed70c92ce880fe305a3312079d13b0ac54d924814", + "amount": 40000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa060d74fa544aedc2bb5a72fb689cff3614a7c71411cc58dc786b568d3068c3dcc80ffff33ff83009c4080ffff01ff9600149999999999999999999999999999999999999999ff83009c408080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "00149999999999999999999999999999999999999999", + "amount": 40000 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "recover_wrong_script", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff01ff9600149999999999999999999999999999999999999999ff8300ea608080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 60000 + } + ] + }, + "expect": { + "error": "unsatisfied_output_claim" + } + }, + { + "name": "recover_underfunded_slot", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff01ff9600149999999999999999999999999999999999999999ff8300ea608080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "00149999999999999999999999999999999999999999", + "amount": 59999 + } + ] + }, + "expect": { + "error": "unsatisfied_output_claim" + } + }, + { + "name": "batched_recovery_two_inputs_two_slots", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff01ff9600149999999999999999999999999999999999999999ff8300ea608080" + }, + { + "txid": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff01ff9600149999999999999999999999999999999999999999ff8300ea608080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "00149999999999999999999999999999999999999999", + "amount": 60000 + }, + { + "script_pubkey": "00149999999999999999999999999999999999999999", + "amount": 60000 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "batched_recovery_merged_slot", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff01ff9600149999999999999999999999999999999999999999ff8300ea608080" + }, + { + "txid": "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee", + "index": 0, + "script_pubkey": "5120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff01ff9600149999999999999999999999999999999999999999ff8300ea608080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "00149999999999999999999999999999999999999999", + "amount": 120000 + } + ] + }, + "expect": { + "error": "unsatisfied_output_claim" + } + }, + { + "name": "program_on_wrong_coin", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", + "index": 0, + "script_pubkey": "5120a735f4b2294c1cdd5ab61c3316f3f2d3a6c99e6eca84f583cbf30be5b8282648", + "amount": 60000, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff01ff9600149999999999999999999999999999999999999999ff8300ea608080" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 20000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "00149999999999999999999999999999999999999999", + "amount": 60000 + } + ] + }, + "expect": { + "error": "unsatisfied_scriptpubkey_assert" + } + } + ] +} diff --git a/vectors/vm/vault-programs.json b/vectors/vm/vault-programs.json new file mode 100644 index 0000000..2755ae8 --- /dev/null +++ b/vectors/vm/vault-programs.json @@ -0,0 +1,151 @@ +{ + "schema": "bitlisp-vector-v0", + "suite": "vm", + "spec": "VM.md sections 3 and 4: the vault and triggered benchmark programs, compiled and curried, one representative per spend path with the in-program guard failures", + "cases": [ + { + "name": "vault_trigger_no_revault", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff1780ffff012080ffff01ff02ffff03ffff02ffff03ffff20ff8200bf80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff5f80ff8080ffff01ff02ffff03ffff20ffff15ffff0dff5f80ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff82017f8080ffff01ff02ffff03ffff20ffff15ff82017fffff018300ffff8080ffff01ff02ffff03ffff09ff82017fffff10ff82017fff808080ffff01ff02ff3effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ffff02ff3cffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fff80808080808080808080ffff04ff8202ffffff04ff8203ffff808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff10ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff10ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ffff04ffff3fff82017f80ff8080808080808080ff8080808080ffffff02ffff03ffff09ffff0dff8204ff80ffff012080ffff01ff02ffff03ffff15ff820affff8080ffff01ff02ffff03ffff20ffff15ff80ff8216ff8080ffff01ff02ffff03ffff20ffff15ff822effffff10ff820affff8216ff808080ffff01ff04ffff04ffff0137ffff04ff17ffff04ff82017fff80808080ffff04ffff04ffff0133ffff04ff822effff808080ffff04ffff04ffff0117ffff04ff0bffff04ffff3fffff04ffff0101ffff04ff8204ffffff04ff820affffff04ff8216ffff808080808080ffff04ff825effff8080808080ffff04ffff04ffff0102ffff04ff17ffff04ffff02ff14ffff04ff02ffff04ff05ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff8204ffff808080808080808080ffff04ff820affff8080808080ffff02ffff03ffff15ff8216ffff8080ffff01ff04ffff04ffff0102ffff04ff17ffff04ff82017fffff04ff8216ffff8080808080ff8080ffff018080ff018080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0142ffff04ffff011affff04ffff0180ffff04ff27ff8080808080ff80808080ff02ffff03ff05ffff01ff10ffff05ff0580ffff02ff3affff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ffff02ffff03ff0bffff01ff04ffff04ffff0143ffff04ffff011affff04ffff0180ffff04ff05ffff04ffff05ff0b80ff808080808080ffff02ff16ffff04ff02ffff04ff05ffff04ffff06ff0b80ffff04ff17ff80808080808080ffff011780ff0180ffff02ffff03ff820177ffff01ff02ffff03ffff20ffff15ffff10ff57ffff02ff3affff04ff02ffff04ff820177ff8080808080ff8200b78080ffff01ff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0133ffff04ff57ff808080ffff02ff16ffff04ff02ffff04ff27ffff04ff820177ffff04ffff04ffff04ffff0101ffff04ff27ffff04ff8200b7ff80808080ff8080ff808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ffff03ffff09ff8202ffffff010180ffff01ff02ff12ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8205ffff8080808080808080808080ffff01ff02ffff03ffff09ff8202ffffff010280ffff01ff02ff2cffff04ff02ffff04ff17ffff04ff82017fffff04ff2fffff04ff5fffff04ff8205ffff8080808080808080ffff01ff02ffff03ffff09ff8202ffffff010380ffff01ff02ff2affff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff02ffff03ffff09ff8202ffffff010480ffff01ff02ff2effff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff088080ff018080ff018080ff018080ff0180ff018080ffff04ffff01a015884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294fffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff019600149999999999999999999999999999999999999999ffff04ffff0180ffff04ffff01820090ff018080808080808080", + "env": "ff01ffa07777777777777777777777777777777777777777777777777777777777777777ff8300ea60ff80ff8300ea60ffc04001ccff6c0e017b85b084141ec54504efd546ca591a569baa91871f6d20163493db6c39bd906cbf2a3fe1be56a8865a38775c47c92779608862f86b2361b4e43580", + "expect": { + "result": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff17ffa09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffa074a1dac82d62d64aafa24a7640eddc5dd65bbf3c18f2564e4bd611e478e4d8b1ffc04001ccff6c0e017b85b084141ec54504efd546ca591a569baa91871f6d20163493db6c39bd906cbf2a3fe1be56a8865a38775c47c92779608862f86b2361b4e43580ffff02ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa060d74fa544aedc2bb5a72fb689cff3614a7c71411cc58dc786b568d3068c3dccff8300ea608080", + "cost": 103731 + } + }, + { + "name": "vault_trigger_with_revault", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff1780ffff012080ffff01ff02ffff03ffff02ffff03ffff20ff8200bf80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff5f80ff8080ffff01ff02ffff03ffff20ffff15ffff0dff5f80ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff82017f8080ffff01ff02ffff03ffff20ffff15ff82017fffff018300ffff8080ffff01ff02ffff03ffff09ff82017fffff10ff82017fff808080ffff01ff02ff3effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ffff02ff3cffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fff80808080808080808080ffff04ff8202ffffff04ff8203ffff808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff10ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff10ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ffff04ffff3fff82017f80ff8080808080808080ff8080808080ffffff02ffff03ffff09ffff0dff8204ff80ffff012080ffff01ff02ffff03ffff15ff820affff8080ffff01ff02ffff03ffff20ffff15ff80ff8216ff8080ffff01ff02ffff03ffff20ffff15ff822effffff10ff820affff8216ff808080ffff01ff04ffff04ffff0137ffff04ff17ffff04ff82017fff80808080ffff04ffff04ffff0133ffff04ff822effff808080ffff04ffff04ffff0117ffff04ff0bffff04ffff3fffff04ffff0101ffff04ff8204ffffff04ff820affffff04ff8216ffff808080808080ffff04ff825effff8080808080ffff04ffff04ffff0102ffff04ff17ffff04ffff02ff14ffff04ff02ffff04ff05ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff8204ffff808080808080808080ffff04ff820affff8080808080ffff02ffff03ffff15ff8216ffff8080ffff01ff04ffff04ffff0102ffff04ff17ffff04ff82017fffff04ff8216ffff8080808080ff8080ffff018080ff018080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0142ffff04ffff011affff04ffff0180ffff04ff27ff8080808080ff80808080ff02ffff03ff05ffff01ff10ffff05ff0580ffff02ff3affff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ffff02ffff03ff0bffff01ff04ffff04ffff0143ffff04ffff011affff04ffff0180ffff04ff05ffff04ffff05ff0b80ff808080808080ffff02ff16ffff04ff02ffff04ff05ffff04ffff06ff0b80ffff04ff17ff80808080808080ffff011780ff0180ffff02ffff03ff820177ffff01ff02ffff03ffff20ffff15ffff10ff57ffff02ff3affff04ff02ffff04ff820177ff8080808080ff8200b78080ffff01ff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0133ffff04ff57ff808080ffff02ff16ffff04ff02ffff04ff27ffff04ff820177ffff04ffff04ffff04ffff0101ffff04ff27ffff04ff8200b7ff80808080ff8080ff808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ffff03ffff09ff8202ffffff010180ffff01ff02ff12ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8205ffff8080808080808080808080ffff01ff02ffff03ffff09ff8202ffffff010280ffff01ff02ff2cffff04ff02ffff04ff17ffff04ff82017fffff04ff2fffff04ff5fffff04ff8205ffff8080808080808080ffff01ff02ffff03ffff09ff8202ffffff010380ffff01ff02ff2affff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff02ffff03ffff09ff8202ffffff010480ffff01ff02ff2effff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff088080ff018080ff018080ff018080ff0180ff018080ffff04ffff01a015884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294fffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff019600149999999999999999999999999999999999999999ffff04ffff0180ffff04ffff01820090ff018080808080808080", + "env": "ff01ffa07777777777777777777777777777777777777777777777777777777777777777ff83009c40ff824e20ff8300ea60ffc040d7bf2f33b9c58f943958e52dfd6bb9d7bab284f11a2e5c8a3a1b8c6628d888e882b516d3b5a22efe4406505ff4fe239760d2d4ae60143fc3453c285a67a4820980", + "expect": { + "result": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff17ffa09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffa0e5da0e08c8d6a9cf5d5db18b5c09bf6a09ef1ff6f245c813d452ff967db7f7fdffc040d7bf2f33b9c58f943958e52dfd6bb9d7bab284f11a2e5c8a3a1b8c6628d888e882b516d3b5a22efe4406505ff4fe239760d2d4ae60143fc3453c285a67a4820980ffff02ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa060d74fa544aedc2bb5a72fb689cff3614a7c71411cc58dc786b568d3068c3dccff83009c4080ffff02ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d7ff824e208080", + "cost": 104296 + } + }, + { + "name": "vault_recover_keyless", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff1780ffff012080ffff01ff02ffff03ffff02ffff03ffff20ff8200bf80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff5f80ff8080ffff01ff02ffff03ffff20ffff15ffff0dff5f80ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff82017f8080ffff01ff02ffff03ffff20ffff15ff82017fffff018300ffff8080ffff01ff02ffff03ffff09ff82017fffff10ff82017fff808080ffff01ff02ff3effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ffff02ff3cffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fff80808080808080808080ffff04ff8202ffffff04ff8203ffff808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff10ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff10ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ffff04ffff3fff82017f80ff8080808080808080ff8080808080ffffff02ffff03ffff09ffff0dff8204ff80ffff012080ffff01ff02ffff03ffff15ff820affff8080ffff01ff02ffff03ffff20ffff15ff80ff8216ff8080ffff01ff02ffff03ffff20ffff15ff822effffff10ff820affff8216ff808080ffff01ff04ffff04ffff0137ffff04ff17ffff04ff82017fff80808080ffff04ffff04ffff0133ffff04ff822effff808080ffff04ffff04ffff0117ffff04ff0bffff04ffff3fffff04ffff0101ffff04ff8204ffffff04ff820affffff04ff8216ffff808080808080ffff04ff825effff8080808080ffff04ffff04ffff0102ffff04ff17ffff04ffff02ff14ffff04ff02ffff04ff05ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff8204ffff808080808080808080ffff04ff820affff8080808080ffff02ffff03ffff15ff8216ffff8080ffff01ff04ffff04ffff0102ffff04ff17ffff04ff82017fffff04ff8216ffff8080808080ff8080ffff018080ff018080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0142ffff04ffff011affff04ffff0180ffff04ff27ff8080808080ff80808080ff02ffff03ff05ffff01ff10ffff05ff0580ffff02ff3affff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ffff02ffff03ff0bffff01ff04ffff04ffff0143ffff04ffff011affff04ffff0180ffff04ff05ffff04ffff05ff0b80ff808080808080ffff02ff16ffff04ff02ffff04ff05ffff04ffff06ff0b80ffff04ff17ff80808080808080ffff011780ff0180ffff02ffff03ff820177ffff01ff02ffff03ffff20ffff15ffff10ff57ffff02ff3affff04ff02ffff04ff820177ff8080808080ff8200b78080ffff01ff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0133ffff04ff57ff808080ffff02ff16ffff04ff02ffff04ff27ffff04ff820177ffff04ffff04ffff04ffff0101ffff04ff27ffff04ff8200b7ff80808080ff8080ff808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ffff03ffff09ff8202ffffff010180ffff01ff02ff12ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8205ffff8080808080808080808080ffff01ff02ffff03ffff09ff8202ffffff010280ffff01ff02ff2cffff04ff02ffff04ff17ffff04ff82017fffff04ff2fffff04ff5fffff04ff8205ffff8080808080808080ffff01ff02ffff03ffff09ff8202ffffff010380ffff01ff02ff2affff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff02ffff03ffff09ff8202ffffff010480ffff01ff02ff2effff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff088080ff018080ff018080ff018080ff0180ff018080ffff04ffff01a015884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294fffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff019600149999999999999999999999999999999999999999ffff04ffff0180ffff04ffff01820090ff018080808080808080", + "env": "ff02ff8300ea60ff8300ea6080", + "expect": { + "result": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff33ff8300ea6080ffff01ff9600149999999999999999999999999999999999999999ff8300ea608080", + "cost": 57540 + } + }, + { + "name": "vault_recover_keyed", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff1780ffff012080ffff01ff02ffff03ffff02ffff03ffff20ff8200bf80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff5f80ff8080ffff01ff02ffff03ffff20ffff15ffff0dff5f80ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff82017f8080ffff01ff02ffff03ffff20ffff15ff82017fffff018300ffff8080ffff01ff02ffff03ffff09ff82017fffff10ff82017fff808080ffff01ff02ff3effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ffff02ff3cffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fff80808080808080808080ffff04ff8202ffffff04ff8203ffff808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff10ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff10ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ffff04ffff3fff82017f80ff8080808080808080ff8080808080ffffff02ffff03ffff09ffff0dff8204ff80ffff012080ffff01ff02ffff03ffff15ff820affff8080ffff01ff02ffff03ffff20ffff15ff80ff8216ff8080ffff01ff02ffff03ffff20ffff15ff822effffff10ff820affff8216ff808080ffff01ff04ffff04ffff0137ffff04ff17ffff04ff82017fff80808080ffff04ffff04ffff0133ffff04ff822effff808080ffff04ffff04ffff0117ffff04ff0bffff04ffff3fffff04ffff0101ffff04ff8204ffffff04ff820affffff04ff8216ffff808080808080ffff04ff825effff8080808080ffff04ffff04ffff0102ffff04ff17ffff04ffff02ff14ffff04ff02ffff04ff05ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff8204ffff808080808080808080ffff04ff820affff8080808080ffff02ffff03ffff15ff8216ffff8080ffff01ff04ffff04ffff0102ffff04ff17ffff04ff82017fffff04ff8216ffff8080808080ff8080ffff018080ff018080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0142ffff04ffff011affff04ffff0180ffff04ff27ff8080808080ff80808080ff02ffff03ff05ffff01ff10ffff05ff0580ffff02ff3affff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ffff02ffff03ff0bffff01ff04ffff04ffff0143ffff04ffff011affff04ffff0180ffff04ff05ffff04ffff05ff0b80ff808080808080ffff02ff16ffff04ff02ffff04ff05ffff04ffff06ff0b80ffff04ff17ff80808080808080ffff011780ff0180ffff02ffff03ff820177ffff01ff02ffff03ffff20ffff15ffff10ff57ffff02ff3affff04ff02ffff04ff820177ff8080808080ff8200b78080ffff01ff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0133ffff04ff57ff808080ffff02ff16ffff04ff02ffff04ff27ffff04ff820177ffff04ffff04ffff04ffff0101ffff04ff27ffff04ff8200b7ff80808080ff8080ff808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ffff03ffff09ff8202ffffff010180ffff01ff02ff12ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8205ffff8080808080808080808080ffff01ff02ffff03ffff09ff8202ffffff010280ffff01ff02ff2cffff04ff02ffff04ff17ffff04ff82017fffff04ff2fffff04ff5fffff04ff8205ffff8080808080808080ffff01ff02ffff03ffff09ff8202ffffff010380ffff01ff02ff2affff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff02ffff03ffff09ff8202ffffff010480ffff01ff02ff2effff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff088080ff018080ff018080ff018080ff0180ff018080ffff04ffff01a015884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294fffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff019600149999999999999999999999999999999999999999ffff04ffff01a0860200f3ca1e283b931d88e4a14e504e3710eb7cccacc8705ff9496ed5153616ffff04ffff01820090ff018080808080808080", + "env": "ff02ff8300ea60ff8300ea60ffc040907d1322273b20300d6fcab2b608d816b6aac8beb6eac9cea9c0e09159e6da08cf432e14099a2db27bad733bec34012ff29b6cae16185a43046b0ef0534a1bce80", + "expect": { + "result": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa093297d3ee280167745f601e2f3a72446f724415eba0b696af4df84d0e4ee618a80ffff33ff8300ea6080ffff01ff9600149999999999999999999999999999999999999999ff8300ea6080ffff17ffa0860200f3ca1e283b931d88e4a14e504e3710eb7cccacc8705ff9496ed5153616ffa0a89e7a8db863d5d2a0fe88aa9463f5a6b4fac900d79792f9f31b8dbcda9052a9ffc040907d1322273b20300d6fcab2b608d816b6aac8beb6eac9cea9c0e09159e6da08cf432e14099a2db27bad733bec34012ff29b6cae16185a43046b0ef0534a1bce8080", + "cost": 61097 + } + }, + { + "name": "vault_follow", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff1780ffff012080ffff01ff02ffff03ffff02ffff03ffff20ff8200bf80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff5f80ff8080ffff01ff02ffff03ffff20ffff15ffff0dff5f80ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff82017f8080ffff01ff02ffff03ffff20ffff15ff82017fffff018300ffff8080ffff01ff02ffff03ffff09ff82017fffff10ff82017fff808080ffff01ff02ff3effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ffff02ff3cffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fff80808080808080808080ffff04ff8202ffffff04ff8203ffff808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff10ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff10ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ffff04ffff3fff82017f80ff8080808080808080ff8080808080ffffff02ffff03ffff09ffff0dff8204ff80ffff012080ffff01ff02ffff03ffff15ff820affff8080ffff01ff02ffff03ffff20ffff15ff80ff8216ff8080ffff01ff02ffff03ffff20ffff15ff822effffff10ff820affff8216ff808080ffff01ff04ffff04ffff0137ffff04ff17ffff04ff82017fff80808080ffff04ffff04ffff0133ffff04ff822effff808080ffff04ffff04ffff0117ffff04ff0bffff04ffff3fffff04ffff0101ffff04ff8204ffffff04ff820affffff04ff8216ffff808080808080ffff04ff825effff8080808080ffff04ffff04ffff0102ffff04ff17ffff04ffff02ff14ffff04ff02ffff04ff05ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff8204ffff808080808080808080ffff04ff820affff8080808080ffff02ffff03ffff15ff8216ffff8080ffff01ff04ffff04ffff0102ffff04ff17ffff04ff82017fffff04ff8216ffff8080808080ff8080ffff018080ff018080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0142ffff04ffff011affff04ffff0180ffff04ff27ff8080808080ff80808080ff02ffff03ff05ffff01ff10ffff05ff0580ffff02ff3affff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ffff02ffff03ff0bffff01ff04ffff04ffff0143ffff04ffff011affff04ffff0180ffff04ff05ffff04ffff05ff0b80ff808080808080ffff02ff16ffff04ff02ffff04ff05ffff04ffff06ff0b80ffff04ff17ff80808080808080ffff011780ff0180ffff02ffff03ff820177ffff01ff02ffff03ffff20ffff15ffff10ff57ffff02ff3affff04ff02ffff04ff820177ff8080808080ff8200b78080ffff01ff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0133ffff04ff57ff808080ffff02ff16ffff04ff02ffff04ff27ffff04ff820177ffff04ffff04ffff04ffff0101ffff04ff27ffff04ff8200b7ff80808080ff8080ff808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ffff03ffff09ff8202ffffff010180ffff01ff02ff12ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8205ffff8080808080808080808080ffff01ff02ffff03ffff09ff8202ffffff010280ffff01ff02ff2cffff04ff02ffff04ff17ffff04ff82017fffff04ff2fffff04ff5fffff04ff8205ffff8080808080808080ffff01ff02ffff03ffff09ff8202ffffff010380ffff01ff02ff2affff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff02ffff03ffff09ff8202ffffff010480ffff01ff02ff2effff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff088080ff018080ff018080ff018080ff0180ff018080ffff04ffff01a015884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294fffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff019600149999999999999999999999999999999999999999ffff04ffff0180ffff04ffff01820090ff018080808080808080", + "env": "ff03ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580", + "expect": { + "result": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff42ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da58080", + "cost": 56396 + } + }, + { + "name": "vault_lead_two_followers", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff1780ffff012080ffff01ff02ffff03ffff02ffff03ffff20ff8200bf80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff5f80ff8080ffff01ff02ffff03ffff20ffff15ffff0dff5f80ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff82017f8080ffff01ff02ffff03ffff20ffff15ff82017fffff018300ffff8080ffff01ff02ffff03ffff09ff82017fffff10ff82017fff808080ffff01ff02ff3effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ffff02ff3cffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fff80808080808080808080ffff04ff8202ffffff04ff8203ffff808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff10ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff10ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ffff04ffff3fff82017f80ff8080808080808080ff8080808080ffffff02ffff03ffff09ffff0dff8204ff80ffff012080ffff01ff02ffff03ffff15ff820affff8080ffff01ff02ffff03ffff20ffff15ff80ff8216ff8080ffff01ff02ffff03ffff20ffff15ff822effffff10ff820affff8216ff808080ffff01ff04ffff04ffff0137ffff04ff17ffff04ff82017fff80808080ffff04ffff04ffff0133ffff04ff822effff808080ffff04ffff04ffff0117ffff04ff0bffff04ffff3fffff04ffff0101ffff04ff8204ffffff04ff820affffff04ff8216ffff808080808080ffff04ff825effff8080808080ffff04ffff04ffff0102ffff04ff17ffff04ffff02ff14ffff04ff02ffff04ff05ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff8204ffff808080808080808080ffff04ff820affff8080808080ffff02ffff03ffff15ff8216ffff8080ffff01ff04ffff04ffff0102ffff04ff17ffff04ff82017fffff04ff8216ffff8080808080ff8080ffff018080ff018080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0142ffff04ffff011affff04ffff0180ffff04ff27ff8080808080ff80808080ff02ffff03ff05ffff01ff10ffff05ff0580ffff02ff3affff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ffff02ffff03ff0bffff01ff04ffff04ffff0143ffff04ffff011affff04ffff0180ffff04ff05ffff04ffff05ff0b80ff808080808080ffff02ff16ffff04ff02ffff04ff05ffff04ffff06ff0b80ffff04ff17ff80808080808080ffff011780ff0180ffff02ffff03ff820177ffff01ff02ffff03ffff20ffff15ffff10ff57ffff02ff3affff04ff02ffff04ff820177ff8080808080ff8200b78080ffff01ff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0133ffff04ff57ff808080ffff02ff16ffff04ff02ffff04ff27ffff04ff820177ffff04ffff04ffff04ffff0101ffff04ff27ffff04ff8200b7ff80808080ff8080ff808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ffff03ffff09ff8202ffffff010180ffff01ff02ff12ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8205ffff8080808080808080808080ffff01ff02ffff03ffff09ff8202ffffff010280ffff01ff02ff2cffff04ff02ffff04ff17ffff04ff82017fffff04ff2fffff04ff5fffff04ff8205ffff8080808080808080ffff01ff02ffff03ffff09ff8202ffffff010380ffff01ff02ff2affff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff02ffff03ffff09ff8202ffffff010480ffff01ff02ff2effff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff088080ff018080ff018080ff018080ff0180ff018080ffff04ffff01a015884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294fffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff019600149999999999999999999999999999999999999999ffff04ffff0180ffff04ffff01820090ff018080808080808080", + "env": "ff04ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300ea60ff830222e0ffff8300c350ff8275308080", + "expect": { + "result": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa04210930d0c6e343166291cfb213740d2a4cb6f07d556aaafee9e44c32ee2e6d780ffff32ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580ffff33ff8300ea6080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300c35080ffff43ff1aff80ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff82753080ffff01ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff830222e08080", + "cost": 66898 + } + }, + { + "name": "triggered_withdraw", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff02ffff03ffff20ff2f80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff2f80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff1780ff8080ffff01ff02ffff03ffff20ffff15ffff0dff1780ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff5f8080ffff01ff02ffff03ffff20ffff15ff5fffff018300ffff8080ffff01ff02ffff03ffff09ff5fffff10ff5fff808080ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff02ff1effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ffff02ff0affff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfff808080808080808080ffff04ff82017fffff04ff8201ffff8080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff08ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff08ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff0cffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ffff03ffff09ff82017fffff010180ffff01ff04ffff04ffff0137ffff04ff05ffff04ff8200bfff80808080ffff04ffff04ffff0122ffff04ff2fff808080ffff04ffff04ffff0161ffff04ff5fff808080ff80808080ffff01ff02ffff03ffff09ff82017fffff010280ffff01ff02ff16ffff04ff02ffff04ff05ffff04ff8200bfffff04ff0bffff04ff17ffff04ff8202ffff8080808080808080ffff01ff088080ff018080ff0180ff018080ffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff019600149999999999999999999999999999999999999999ffff04ffff0180ffff04ffff01820090ffff04ffff01a07777777777777777777777777777777777777777777777777777777777777777ff0180808080808080", + "env": "ff0180", + "expect": { + "result": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa060d74fa544aedc2bb5a72fb689cff3614a7c71411cc58dc786b568d3068c3dcc80ffff22ff82009080ffff61ffa077777777777777777777777777777777777777777777777777777777777777778080", + "cost": 48868 + } + }, + { + "name": "triggered_recover", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff02ffff03ffff20ff2f80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff2f80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff1780ff8080ffff01ff02ffff03ffff20ffff15ffff0dff1780ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff5f8080ffff01ff02ffff03ffff20ffff15ff5fffff018300ffff8080ffff01ff02ffff03ffff09ff5fffff10ff5fff808080ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff02ff1effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ffff02ff0affff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfff808080808080808080ffff04ff82017fffff04ff8201ffff8080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff08ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff08ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff0cffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ffff03ffff09ff82017fffff010180ffff01ff04ffff04ffff0137ffff04ff05ffff04ff8200bfff80808080ffff04ffff04ffff0122ffff04ff2fff808080ffff04ffff04ffff0161ffff04ff5fff808080ff80808080ffff01ff02ffff03ffff09ff82017fffff010280ffff01ff02ff16ffff04ff02ffff04ff05ffff04ff8200bfffff04ff0bffff04ff17ffff04ff8202ffff8080808080808080ffff01ff088080ff018080ff0180ff018080ffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff019600149999999999999999999999999999999999999999ffff04ffff0180ffff04ffff01820090ffff04ffff01a07777777777777777777777777777777777777777777777777777777777777777ff0180808080808080", + "env": "ff02ff83009c40ff83009c4080", + "expect": { + "result": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa060d74fa544aedc2bb5a72fb689cff3614a7c71411cc58dc786b568d3068c3dcc80ffff33ff83009c4080ffff01ff9600149999999999999999999999999999999999999999ff83009c408080", + "cost": 51623 + } + }, + { + "name": "vault_trigger_value_shortfall", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff1780ffff012080ffff01ff02ffff03ffff02ffff03ffff20ff8200bf80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff5f80ff8080ffff01ff02ffff03ffff20ffff15ffff0dff5f80ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff82017f8080ffff01ff02ffff03ffff20ffff15ff82017fffff018300ffff8080ffff01ff02ffff03ffff09ff82017fffff10ff82017fff808080ffff01ff02ff3effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ffff02ff3cffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fff80808080808080808080ffff04ff8202ffffff04ff8203ffff808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff10ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff10ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ffff04ffff3fff82017f80ff8080808080808080ff8080808080ffffff02ffff03ffff09ffff0dff8204ff80ffff012080ffff01ff02ffff03ffff15ff820affff8080ffff01ff02ffff03ffff20ffff15ff80ff8216ff8080ffff01ff02ffff03ffff20ffff15ff822effffff10ff820affff8216ff808080ffff01ff04ffff04ffff0137ffff04ff17ffff04ff82017fff80808080ffff04ffff04ffff0133ffff04ff822effff808080ffff04ffff04ffff0117ffff04ff0bffff04ffff3fffff04ffff0101ffff04ff8204ffffff04ff820affffff04ff8216ffff808080808080ffff04ff825effff8080808080ffff04ffff04ffff0102ffff04ff17ffff04ffff02ff14ffff04ff02ffff04ff05ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff8204ffff808080808080808080ffff04ff820affff8080808080ffff02ffff03ffff15ff8216ffff8080ffff01ff04ffff04ffff0102ffff04ff17ffff04ff82017fffff04ff8216ffff8080808080ff8080ffff018080ff018080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0142ffff04ffff011affff04ffff0180ffff04ff27ff8080808080ff80808080ff02ffff03ff05ffff01ff10ffff05ff0580ffff02ff3affff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ffff02ffff03ff0bffff01ff04ffff04ffff0143ffff04ffff011affff04ffff0180ffff04ff05ffff04ffff05ff0b80ff808080808080ffff02ff16ffff04ff02ffff04ff05ffff04ffff06ff0b80ffff04ff17ff80808080808080ffff011780ff0180ffff02ffff03ff820177ffff01ff02ffff03ffff20ffff15ffff10ff57ffff02ff3affff04ff02ffff04ff820177ff8080808080ff8200b78080ffff01ff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0133ffff04ff57ff808080ffff02ff16ffff04ff02ffff04ff27ffff04ff820177ffff04ffff04ffff04ffff0101ffff04ff27ffff04ff8200b7ff80808080ff8080ff808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ffff03ffff09ff8202ffffff010180ffff01ff02ff12ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8205ffff8080808080808080808080ffff01ff02ffff03ffff09ff8202ffffff010280ffff01ff02ff2cffff04ff02ffff04ff17ffff04ff82017fffff04ff2fffff04ff5fffff04ff8205ffff8080808080808080ffff01ff02ffff03ffff09ff8202ffffff010380ffff01ff02ff2affff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff02ffff03ffff09ff8202ffffff010480ffff01ff02ff2effff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff088080ff018080ff018080ff018080ff0180ff018080ffff04ffff01a015884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294fffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff019600149999999999999999999999999999999999999999ffff04ffff0180ffff04ffff01820090ff018080808080808080", + "env": "ff01ffa07777777777777777777777777777777777777777777777777777777777777777ff827530ff80ff8300ea60ffc04001ccff6c0e017b85b084141ec54504efd546ca591a569baa91871f6d20163493db6c39bd906cbf2a3fe1be56a8865a38775c47c92779608862f86b2361b4e43580", + "expect": { + "error": "user_raise" + } + }, + { + "name": "vault_trigger_negative_revault", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff1780ffff012080ffff01ff02ffff03ffff02ffff03ffff20ff8200bf80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff5f80ff8080ffff01ff02ffff03ffff20ffff15ffff0dff5f80ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff82017f8080ffff01ff02ffff03ffff20ffff15ff82017fffff018300ffff8080ffff01ff02ffff03ffff09ff82017fffff10ff82017fff808080ffff01ff02ff3effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ffff02ff3cffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fff80808080808080808080ffff04ff8202ffffff04ff8203ffff808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff10ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff10ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ffff04ffff3fff82017f80ff8080808080808080ff8080808080ffffff02ffff03ffff09ffff0dff8204ff80ffff012080ffff01ff02ffff03ffff15ff820affff8080ffff01ff02ffff03ffff20ffff15ff80ff8216ff8080ffff01ff02ffff03ffff20ffff15ff822effffff10ff820affff8216ff808080ffff01ff04ffff04ffff0137ffff04ff17ffff04ff82017fff80808080ffff04ffff04ffff0133ffff04ff822effff808080ffff04ffff04ffff0117ffff04ff0bffff04ffff3fffff04ffff0101ffff04ff8204ffffff04ff820affffff04ff8216ffff808080808080ffff04ff825effff8080808080ffff04ffff04ffff0102ffff04ff17ffff04ffff02ff14ffff04ff02ffff04ff05ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff8204ffff808080808080808080ffff04ff820affff8080808080ffff02ffff03ffff15ff8216ffff8080ffff01ff04ffff04ffff0102ffff04ff17ffff04ff82017fffff04ff8216ffff8080808080ff8080ffff018080ff018080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0142ffff04ffff011affff04ffff0180ffff04ff27ff8080808080ff80808080ff02ffff03ff05ffff01ff10ffff05ff0580ffff02ff3affff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ffff02ffff03ff0bffff01ff04ffff04ffff0143ffff04ffff011affff04ffff0180ffff04ff05ffff04ffff05ff0b80ff808080808080ffff02ff16ffff04ff02ffff04ff05ffff04ffff06ff0b80ffff04ff17ff80808080808080ffff011780ff0180ffff02ffff03ff820177ffff01ff02ffff03ffff20ffff15ffff10ff57ffff02ff3affff04ff02ffff04ff820177ff8080808080ff8200b78080ffff01ff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0133ffff04ff57ff808080ffff02ff16ffff04ff02ffff04ff27ffff04ff820177ffff04ffff04ffff04ffff0101ffff04ff27ffff04ff8200b7ff80808080ff8080ff808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ffff03ffff09ff8202ffffff010180ffff01ff02ff12ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8205ffff8080808080808080808080ffff01ff02ffff03ffff09ff8202ffffff010280ffff01ff02ff2cffff04ff02ffff04ff17ffff04ff82017fffff04ff2fffff04ff5fffff04ff8205ffff8080808080808080ffff01ff02ffff03ffff09ff8202ffffff010380ffff01ff02ff2affff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff02ffff03ffff09ff8202ffffff010480ffff01ff02ff2effff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff088080ff018080ff018080ff018080ff0180ff018080ffff04ffff01a015884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294fffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff019600149999999999999999999999999999999999999999ffff04ffff0180ffff04ffff01820090ff018080808080808080", + "env": "ff01ffa07777777777777777777777777777777777777777777777777777777777777777ff8300ea61ff81ffff8300ea60ffc04001ccff6c0e017b85b084141ec54504efd546ca591a569baa91871f6d20163493db6c39bd906cbf2a3fe1be56a8865a38775c47c92779608862f86b2361b4e43580", + "expect": { + "error": "user_raise" + } + }, + { + "name": "vault_trigger_zero_amount", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff1780ffff012080ffff01ff02ffff03ffff02ffff03ffff20ff8200bf80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff5f80ff8080ffff01ff02ffff03ffff20ffff15ffff0dff5f80ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff82017f8080ffff01ff02ffff03ffff20ffff15ff82017fffff018300ffff8080ffff01ff02ffff03ffff09ff82017fffff10ff82017fff808080ffff01ff02ff3effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ffff02ff3cffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fff80808080808080808080ffff04ff8202ffffff04ff8203ffff808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff10ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff10ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ffff04ffff3fff82017f80ff8080808080808080ff8080808080ffffff02ffff03ffff09ffff0dff8204ff80ffff012080ffff01ff02ffff03ffff15ff820affff8080ffff01ff02ffff03ffff20ffff15ff80ff8216ff8080ffff01ff02ffff03ffff20ffff15ff822effffff10ff820affff8216ff808080ffff01ff04ffff04ffff0137ffff04ff17ffff04ff82017fff80808080ffff04ffff04ffff0133ffff04ff822effff808080ffff04ffff04ffff0117ffff04ff0bffff04ffff3fffff04ffff0101ffff04ff8204ffffff04ff820affffff04ff8216ffff808080808080ffff04ff825effff8080808080ffff04ffff04ffff0102ffff04ff17ffff04ffff02ff14ffff04ff02ffff04ff05ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff8204ffff808080808080808080ffff04ff820affff8080808080ffff02ffff03ffff15ff8216ffff8080ffff01ff04ffff04ffff0102ffff04ff17ffff04ff82017fffff04ff8216ffff8080808080ff8080ffff018080ff018080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0142ffff04ffff011affff04ffff0180ffff04ff27ff8080808080ff80808080ff02ffff03ff05ffff01ff10ffff05ff0580ffff02ff3affff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ffff02ffff03ff0bffff01ff04ffff04ffff0143ffff04ffff011affff04ffff0180ffff04ff05ffff04ffff05ff0b80ff808080808080ffff02ff16ffff04ff02ffff04ff05ffff04ffff06ff0b80ffff04ff17ff80808080808080ffff011780ff0180ffff02ffff03ff820177ffff01ff02ffff03ffff20ffff15ffff10ff57ffff02ff3affff04ff02ffff04ff820177ff8080808080ff8200b78080ffff01ff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0133ffff04ff57ff808080ffff02ff16ffff04ff02ffff04ff27ffff04ff820177ffff04ffff04ffff04ffff0101ffff04ff27ffff04ff8200b7ff80808080ff8080ff808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ffff03ffff09ff8202ffffff010180ffff01ff02ff12ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8205ffff8080808080808080808080ffff01ff02ffff03ffff09ff8202ffffff010280ffff01ff02ff2cffff04ff02ffff04ff17ffff04ff82017fffff04ff2fffff04ff5fffff04ff8205ffff8080808080808080ffff01ff02ffff03ffff09ff8202ffffff010380ffff01ff02ff2affff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff02ffff03ffff09ff8202ffffff010480ffff01ff02ff2effff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff088080ff018080ff018080ff018080ff0180ff018080ffff04ffff01a015884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294fffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff019600149999999999999999999999999999999999999999ffff04ffff0180ffff04ffff01820090ff018080808080808080", + "env": "ff01ffa07777777777777777777777777777777777777777777777777777777777777777ff80ff8300ea60ff8300ea60ffc04001ccff6c0e017b85b084141ec54504efd546ca591a569baa91871f6d20163493db6c39bd906cbf2a3fe1be56a8865a38775c47c92779608862f86b2361b4e43580", + "expect": { + "error": "user_raise" + } + }, + { + "name": "vault_malformed_recovery_key_unspendable", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff1780ffff012080ffff01ff02ffff03ffff02ffff03ffff20ff8200bf80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff5f80ff8080ffff01ff02ffff03ffff20ffff15ffff0dff5f80ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff82017f8080ffff01ff02ffff03ffff20ffff15ff82017fffff018300ffff8080ffff01ff02ffff03ffff09ff82017fffff10ff82017fff808080ffff01ff02ff3effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ffff02ff3cffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fff80808080808080808080ffff04ff8202ffffff04ff8203ffff808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff10ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff10ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ffff04ffff3fff82017f80ff8080808080808080ff8080808080ffffff02ffff03ffff09ffff0dff8204ff80ffff012080ffff01ff02ffff03ffff15ff820affff8080ffff01ff02ffff03ffff20ffff15ff80ff8216ff8080ffff01ff02ffff03ffff20ffff15ff822effffff10ff820affff8216ff808080ffff01ff04ffff04ffff0137ffff04ff17ffff04ff82017fff80808080ffff04ffff04ffff0133ffff04ff822effff808080ffff04ffff04ffff0117ffff04ff0bffff04ffff3fffff04ffff0101ffff04ff8204ffffff04ff820affffff04ff8216ffff808080808080ffff04ff825effff8080808080ffff04ffff04ffff0102ffff04ff17ffff04ffff02ff14ffff04ff02ffff04ff05ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff8204ffff808080808080808080ffff04ff820affff8080808080ffff02ffff03ffff15ff8216ffff8080ffff01ff04ffff04ffff0102ffff04ff17ffff04ff82017fffff04ff8216ffff8080808080ff8080ffff018080ff018080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0142ffff04ffff011affff04ffff0180ffff04ff27ff8080808080ff80808080ff02ffff03ff05ffff01ff10ffff05ff0580ffff02ff3affff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ffff02ffff03ff0bffff01ff04ffff04ffff0143ffff04ffff011affff04ffff0180ffff04ff05ffff04ffff05ff0b80ff808080808080ffff02ff16ffff04ff02ffff04ff05ffff04ffff06ff0b80ffff04ff17ff80808080808080ffff011780ff0180ffff02ffff03ff820177ffff01ff02ffff03ffff20ffff15ffff10ff57ffff02ff3affff04ff02ffff04ff820177ff8080808080ff8200b78080ffff01ff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0133ffff04ff57ff808080ffff02ff16ffff04ff02ffff04ff27ffff04ff820177ffff04ffff04ffff04ffff0101ffff04ff27ffff04ff8200b7ff80808080ff8080ff808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ffff03ffff09ff8202ffffff010180ffff01ff02ff12ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8205ffff8080808080808080808080ffff01ff02ffff03ffff09ff8202ffffff010280ffff01ff02ff2cffff04ff02ffff04ff17ffff04ff82017fffff04ff2fffff04ff5fffff04ff8205ffff8080808080808080ffff01ff02ffff03ffff09ff8202ffffff010380ffff01ff02ff2affff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff02ffff03ffff09ff8202ffffff010480ffff01ff02ff2effff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff088080ff018080ff018080ff018080ff0180ff018080ffff04ffff01a015884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294fffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff019600149999999999999999999999999999999999999999ffff04ffff01a102860200f3ca1e283b931d88e4a14e504e3710eb7cccacc8705ff9496ed5153616ffff04ffff01820090ff018080808080808080", + "env": "ff03ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580", + "expect": { + "error": "user_raise" + } + }, + { + "name": "vault_overlong_delay_unspendable", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff1780ffff012080ffff01ff02ffff03ffff02ffff03ffff20ff8200bf80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff5f80ff8080ffff01ff02ffff03ffff20ffff15ffff0dff5f80ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff82017f8080ffff01ff02ffff03ffff20ffff15ff82017fffff018300ffff8080ffff01ff02ffff03ffff09ff82017fffff10ff82017fff808080ffff01ff02ff3effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ffff02ff3cffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fff80808080808080808080ffff04ff8202ffffff04ff8203ffff808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff10ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff10ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ffff04ffff3fff82017f80ff8080808080808080ff8080808080ffffff02ffff03ffff09ffff0dff8204ff80ffff012080ffff01ff02ffff03ffff15ff820affff8080ffff01ff02ffff03ffff20ffff15ff80ff8216ff8080ffff01ff02ffff03ffff20ffff15ff822effffff10ff820affff8216ff808080ffff01ff04ffff04ffff0137ffff04ff17ffff04ff82017fff80808080ffff04ffff04ffff0133ffff04ff822effff808080ffff04ffff04ffff0117ffff04ff0bffff04ffff3fffff04ffff0101ffff04ff8204ffffff04ff820affffff04ff8216ffff808080808080ffff04ff825effff8080808080ffff04ffff04ffff0102ffff04ff17ffff04ffff02ff14ffff04ff02ffff04ff05ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff8204ffff808080808080808080ffff04ff820affff8080808080ffff02ffff03ffff15ff8216ffff8080ffff01ff04ffff04ffff0102ffff04ff17ffff04ff82017fffff04ff8216ffff8080808080ff8080ffff018080ff018080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0142ffff04ffff011affff04ffff0180ffff04ff27ff8080808080ff80808080ff02ffff03ff05ffff01ff10ffff05ff0580ffff02ff3affff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ffff02ffff03ff0bffff01ff04ffff04ffff0143ffff04ffff011affff04ffff0180ffff04ff05ffff04ffff05ff0b80ff808080808080ffff02ff16ffff04ff02ffff04ff05ffff04ffff06ff0b80ffff04ff17ff80808080808080ffff011780ff0180ffff02ffff03ff820177ffff01ff02ffff03ffff20ffff15ffff10ff57ffff02ff3affff04ff02ffff04ff820177ff8080808080ff8200b78080ffff01ff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0133ffff04ff57ff808080ffff02ff16ffff04ff02ffff04ff27ffff04ff820177ffff04ffff04ffff04ffff0101ffff04ff27ffff04ff8200b7ff80808080ff8080ff808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ffff03ffff09ff8202ffffff010180ffff01ff02ff12ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8205ffff8080808080808080808080ffff01ff02ffff03ffff09ff8202ffffff010280ffff01ff02ff2cffff04ff02ffff04ff17ffff04ff82017fffff04ff2fffff04ff5fffff04ff8205ffff8080808080808080ffff01ff02ffff03ffff09ff8202ffffff010380ffff01ff02ff2affff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff02ffff03ffff09ff8202ffffff010480ffff01ff02ff2effff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff088080ff018080ff018080ff018080ff0180ff018080ffff04ffff01a015884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294fffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff019600149999999999999999999999999999999999999999ffff04ffff0180ffff04ffff0183010000ff018080808080808080", + "env": "ff03ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580", + "expect": { + "error": "user_raise" + } + }, + { + "name": "vault_nil_recovery_spk_unspendable", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff1780ffff012080ffff01ff02ffff03ffff02ffff03ffff20ff8200bf80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff5f80ff8080ffff01ff02ffff03ffff20ffff15ffff0dff5f80ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff82017f8080ffff01ff02ffff03ffff20ffff15ff82017fffff018300ffff8080ffff01ff02ffff03ffff09ff82017fffff10ff82017fff808080ffff01ff02ff3effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ffff02ff3cffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fff80808080808080808080ffff04ff8202ffffff04ff8203ffff808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff10ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff10ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ffff04ffff3fff82017f80ff8080808080808080ff8080808080ffffff02ffff03ffff09ffff0dff8204ff80ffff012080ffff01ff02ffff03ffff15ff820affff8080ffff01ff02ffff03ffff20ffff15ff80ff8216ff8080ffff01ff02ffff03ffff20ffff15ff822effffff10ff820affff8216ff808080ffff01ff04ffff04ffff0137ffff04ff17ffff04ff82017fff80808080ffff04ffff04ffff0133ffff04ff822effff808080ffff04ffff04ffff0117ffff04ff0bffff04ffff3fffff04ffff0101ffff04ff8204ffffff04ff820affffff04ff8216ffff808080808080ffff04ff825effff8080808080ffff04ffff04ffff0102ffff04ff17ffff04ffff02ff14ffff04ff02ffff04ff05ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff8204ffff808080808080808080ffff04ff820affff8080808080ffff02ffff03ffff15ff8216ffff8080ffff01ff04ffff04ffff0102ffff04ff17ffff04ff82017fffff04ff8216ffff8080808080ff8080ffff018080ff018080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0142ffff04ffff011affff04ffff0180ffff04ff27ff8080808080ff80808080ff02ffff03ff05ffff01ff10ffff05ff0580ffff02ff3affff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ffff02ffff03ff0bffff01ff04ffff04ffff0143ffff04ffff011affff04ffff0180ffff04ff05ffff04ffff05ff0b80ff808080808080ffff02ff16ffff04ff02ffff04ff05ffff04ffff06ff0b80ffff04ff17ff80808080808080ffff011780ff0180ffff02ffff03ff820177ffff01ff02ffff03ffff20ffff15ffff10ff57ffff02ff3affff04ff02ffff04ff820177ff8080808080ff8200b78080ffff01ff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0133ffff04ff57ff808080ffff02ff16ffff04ff02ffff04ff27ffff04ff820177ffff04ffff04ffff04ffff0101ffff04ff27ffff04ff8200b7ff80808080ff8080ff808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ffff03ffff09ff8202ffffff010180ffff01ff02ff12ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8205ffff8080808080808080808080ffff01ff02ffff03ffff09ff8202ffffff010280ffff01ff02ff2cffff04ff02ffff04ff17ffff04ff82017fffff04ff2fffff04ff5fffff04ff8205ffff8080808080808080ffff01ff02ffff03ffff09ff8202ffffff010380ffff01ff02ff2affff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff02ffff03ffff09ff8202ffffff010480ffff01ff02ff2effff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff088080ff018080ff018080ff018080ff0180ff018080ffff04ffff01a015884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294fffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff0180ffff04ffff0180ffff04ffff01820090ff018080808080808080", + "env": "ff03ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580", + "expect": { + "error": "user_raise" + } + }, + { + "name": "vault_padded_delay_unspendable", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff1780ffff012080ffff01ff02ffff03ffff02ffff03ffff20ff8200bf80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff5f80ff8080ffff01ff02ffff03ffff20ffff15ffff0dff5f80ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff82017f8080ffff01ff02ffff03ffff20ffff15ff82017fffff018300ffff8080ffff01ff02ffff03ffff09ff82017fffff10ff82017fff808080ffff01ff02ff3effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ffff02ff3cffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fff80808080808080808080ffff04ff8202ffffff04ff8203ffff808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff10ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff10ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ffff04ffff3fff82017f80ff8080808080808080ff8080808080ffffff02ffff03ffff09ffff0dff8204ff80ffff012080ffff01ff02ffff03ffff15ff820affff8080ffff01ff02ffff03ffff20ffff15ff80ff8216ff8080ffff01ff02ffff03ffff20ffff15ff822effffff10ff820affff8216ff808080ffff01ff04ffff04ffff0137ffff04ff17ffff04ff82017fff80808080ffff04ffff04ffff0133ffff04ff822effff808080ffff04ffff04ffff0117ffff04ff0bffff04ffff3fffff04ffff0101ffff04ff8204ffffff04ff820affffff04ff8216ffff808080808080ffff04ff825effff8080808080ffff04ffff04ffff0102ffff04ff17ffff04ffff02ff14ffff04ff02ffff04ff05ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff8204ffff808080808080808080ffff04ff820affff8080808080ffff02ffff03ffff15ff8216ffff8080ffff01ff04ffff04ffff0102ffff04ff17ffff04ff82017fffff04ff8216ffff8080808080ff8080ffff018080ff018080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0142ffff04ffff011affff04ffff0180ffff04ff27ff8080808080ff80808080ff02ffff03ff05ffff01ff10ffff05ff0580ffff02ff3affff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ffff02ffff03ff0bffff01ff04ffff04ffff0143ffff04ffff011affff04ffff0180ffff04ff05ffff04ffff05ff0b80ff808080808080ffff02ff16ffff04ff02ffff04ff05ffff04ffff06ff0b80ffff04ff17ff80808080808080ffff011780ff0180ffff02ffff03ff820177ffff01ff02ffff03ffff20ffff15ffff10ff57ffff02ff3affff04ff02ffff04ff820177ff8080808080ff8200b78080ffff01ff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0133ffff04ff57ff808080ffff02ff16ffff04ff02ffff04ff27ffff04ff820177ffff04ffff04ffff04ffff0101ffff04ff27ffff04ff8200b7ff80808080ff8080ff808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ffff03ffff09ff8202ffffff010180ffff01ff02ff12ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8205ffff8080808080808080808080ffff01ff02ffff03ffff09ff8202ffffff010280ffff01ff02ff2cffff04ff02ffff04ff17ffff04ff82017fffff04ff2fffff04ff5fffff04ff8205ffff8080808080808080ffff01ff02ffff03ffff09ff8202ffffff010380ffff01ff02ff2affff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff02ffff03ffff09ff8202ffffff010480ffff01ff02ff2effff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff088080ff018080ff018080ff018080ff0180ff018080ffff04ffff01a015884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294fffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff019600149999999999999999999999999999999999999999ffff04ffff0180ffff04ffff0183000090ff018080808080808080", + "env": "ff03ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da580", + "expect": { + "error": "user_raise" + } + }, + { + "name": "vault_lead_no_followers", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff1780ffff012080ffff01ff02ffff03ffff02ffff03ffff20ff8200bf80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff5f80ff8080ffff01ff02ffff03ffff20ffff15ffff0dff5f80ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff82017f8080ffff01ff02ffff03ffff20ffff15ff82017fffff018300ffff8080ffff01ff02ffff03ffff09ff82017fffff10ff82017fff808080ffff01ff02ff3effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ffff02ff3cffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fff80808080808080808080ffff04ff8202ffffff04ff8203ffff808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff10ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff10ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ffff04ffff3fff82017f80ff8080808080808080ff8080808080ffffff02ffff03ffff09ffff0dff8204ff80ffff012080ffff01ff02ffff03ffff15ff820affff8080ffff01ff02ffff03ffff20ffff15ff80ff8216ff8080ffff01ff02ffff03ffff20ffff15ff822effffff10ff820affff8216ff808080ffff01ff04ffff04ffff0137ffff04ff17ffff04ff82017fff80808080ffff04ffff04ffff0133ffff04ff822effff808080ffff04ffff04ffff0117ffff04ff0bffff04ffff3fffff04ffff0101ffff04ff8204ffffff04ff820affffff04ff8216ffff808080808080ffff04ff825effff8080808080ffff04ffff04ffff0102ffff04ff17ffff04ffff02ff14ffff04ff02ffff04ff05ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff8204ffff808080808080808080ffff04ff820affff8080808080ffff02ffff03ffff15ff8216ffff8080ffff01ff04ffff04ffff0102ffff04ff17ffff04ff82017fffff04ff8216ffff8080808080ff8080ffff018080ff018080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0142ffff04ffff011affff04ffff0180ffff04ff27ff8080808080ff80808080ff02ffff03ff05ffff01ff10ffff05ff0580ffff02ff3affff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ffff02ffff03ff0bffff01ff04ffff04ffff0143ffff04ffff011affff04ffff0180ffff04ff05ffff04ffff05ff0b80ff808080808080ffff02ff16ffff04ff02ffff04ff05ffff04ffff06ff0b80ffff04ff17ff80808080808080ffff011780ff0180ffff02ffff03ff820177ffff01ff02ffff03ffff20ffff15ffff10ff57ffff02ff3affff04ff02ffff04ff820177ff8080808080ff8200b78080ffff01ff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0133ffff04ff57ff808080ffff02ff16ffff04ff02ffff04ff27ffff04ff820177ffff04ffff04ffff04ffff0101ffff04ff27ffff04ff8200b7ff80808080ff8080ff808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ffff03ffff09ff8202ffffff010180ffff01ff02ff12ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8205ffff8080808080808080808080ffff01ff02ffff03ffff09ff8202ffffff010280ffff01ff02ff2cffff04ff02ffff04ff17ffff04ff82017fffff04ff2fffff04ff5fffff04ff8205ffff8080808080808080ffff01ff02ffff03ffff09ff8202ffffff010380ffff01ff02ff2affff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff02ffff03ffff09ff8202ffffff010480ffff01ff02ff2effff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff088080ff018080ff018080ff018080ff0180ff018080ffff04ffff01a015884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294fffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff019600149999999999999999999999999999999999999999ffff04ffff0180ffff04ffff01820090ff018080808080808080", + "env": "ff04ffa25120a1f7f2655cf799f80b2bb32edad57789e957e8ffb096b9518c90550ac6260da5ff8300ea60ff8300ea60ff8080", + "expect": { + "error": "user_raise" + } + }, + { + "name": "vault_unknown_path", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff1780ffff012080ffff01ff02ffff03ffff02ffff03ffff20ff8200bf80ffff01ff0101ffff01ff02ffff03ffff09ffff0dff8200bf80ffff012080ffff01ff0101ffff018080ff018080ff0180ffff01ff02ffff03ffff15ffff0dff5f80ff8080ffff01ff02ffff03ffff20ffff15ffff0dff5f80ffff018227108080ffff01ff02ffff03ffff20ffff15ff80ff82017f8080ffff01ff02ffff03ffff20ffff15ff82017fffff018300ffff8080ffff01ff02ffff03ffff09ff82017fffff10ff82017fff808080ffff01ff02ff3effff04ff02ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ffff02ff3cffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fff80808080808080808080ffff04ff8202ffffff04ff8203ffff808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff10ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff10ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ff80808080808080ff8080808080ffff02ffff03ffff20ffff15ff82009fff82015f8080ffff01ff04ffff04ffff0137ffff04ff05ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff82009fff808080ffff04ffff04ffff0101ffff04ff17ffff04ff82015fff80808080ffff02ffff03ff2fffff01ff04ffff04ffff0117ffff04ff2fffff04ffff3fffff04ffff0102ffff04ff82009fffff04ff82015fff8080808080ffff04ffff05ff8201df80ff8080808080ff8080ffff018080ff0180808080ffff01ff088080ff0180ff02ff18ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ffff04ffff3fff1780ffff04ffff3fff2f80ffff04ffff3fff5f80ffff04ffff3fff8200bf80ffff04ffff3fff82017f80ff8080808080808080ff8080808080ffffff02ffff03ffff09ffff0dff8204ff80ffff012080ffff01ff02ffff03ffff15ff820affff8080ffff01ff02ffff03ffff20ffff15ff80ff8216ff8080ffff01ff02ffff03ffff20ffff15ff822effffff10ff820affff8216ff808080ffff01ff04ffff04ffff0137ffff04ff17ffff04ff82017fff80808080ffff04ffff04ffff0133ffff04ff822effff808080ffff04ffff04ffff0117ffff04ff0bffff04ffff3fffff04ffff0101ffff04ff8204ffffff04ff820affffff04ff8216ffff808080808080ffff04ff825effff8080808080ffff04ffff04ffff0102ffff04ff17ffff04ffff02ff14ffff04ff02ffff04ff05ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff8204ffff808080808080808080ffff04ff820affff8080808080ffff02ffff03ffff15ff8216ffff8080ffff01ff04ffff04ffff0102ffff04ff17ffff04ff82017fffff04ff8216ffff8080808080ff8080ffff018080ff018080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0142ffff04ffff011affff04ffff0180ffff04ff27ff8080808080ff80808080ff02ffff03ff05ffff01ff10ffff05ff0580ffff02ff3affff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ffff02ffff03ff0bffff01ff04ffff04ffff0143ffff04ffff011affff04ffff0180ffff04ff05ffff04ffff05ff0b80ff808080808080ffff02ff16ffff04ff02ffff04ff05ffff04ffff06ff0b80ffff04ff17ff80808080808080ffff011780ff0180ffff02ffff03ff820177ffff01ff02ffff03ffff20ffff15ffff10ff57ffff02ff3affff04ff02ffff04ff820177ff8080808080ff8200b78080ffff01ff04ffff04ffff0137ffff04ff0bffff04ff05ff80808080ffff04ffff04ffff0132ffff04ff27ff808080ffff04ffff04ffff0133ffff04ff57ff808080ffff02ff16ffff04ff02ffff04ff27ffff04ff820177ffff04ffff04ffff04ffff0101ffff04ff27ffff04ff8200b7ff80808080ff8080ff808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ffff03ffff09ff8202ffffff010180ffff01ff02ff12ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8205ffff8080808080808080808080ffff01ff02ffff03ffff09ff8202ffffff010280ffff01ff02ff2cffff04ff02ffff04ff17ffff04ff82017fffff04ff2fffff04ff5fffff04ff8205ffff8080808080808080ffff01ff02ffff03ffff09ff8202ffffff010380ffff01ff02ff2affff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff02ffff03ffff09ff8202ffffff010480ffff01ff02ff2effff04ff02ffff04ff82017fffff04ff17ffff04ff8205ffff808080808080ffff01ff088080ff018080ff018080ff018080ff0180ff018080ffff04ffff01a015884715af56b2851e9e1359b11d7090623168ddc2d84fc4785b75e904c2294fffff04ffff01a0214b0347c7df10d8d7c95769dd4cc3e0fdcee183b281b3d96ebda71bb739ec1bffff04ffff01a09802fe6fc3d7804e6b93daaa91aa54c788543b1a1377767090171abae40c6283ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ffff019600149999999999999999999999999999999999999999ffff04ffff0180ffff04ffff01820090ff018080808080808080", + "env": "ff0980", + "expect": { + "error": "user_raise" + } + } + ] +}