diff --git a/docs/execution-plan.md b/docs/execution-plan.md index f663565..58b2859 100644 --- a/docs/execution-plan.md +++ b/docs/execution-plan.md @@ -84,11 +84,11 @@ 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:** 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. +- [ ] **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. Singleton wrapper second (2026-08-22), resequenced ahead of the pool and the offer: the Chia shape does not port, because a txid commits input outpoints but not input scripts and no VM operator performs the taproot tweak, so the lineage scriptPubKey is constant per launch and the state rides in a tagged OP_RETURN of the creating transaction, read back through two transaction preimages. The constant scriptPubKey is the built shape, both sides stated in `docs/puzzles/singleton.md` (decision by Evan, 2026-08-22, on the census below), and the taproot-tweak operator condition-record decision 3 declined is flagged for the Phase 4 gate with this puzzle as the case that answers decision 3's objection. The helpers that name a txid and an inner hash once are the assign trigger firing again. Value question answered 2026-08-22 in that doc (census of the vendored Chia corpora plus the Bitcoin constructions): Ark, Lightning, vaults, and pools get identity from the root outpoint and need no singleton, the lineage machinery is what the fungible asset token needs, and the remaining lineage effort belongs there. The token is a capability-and-risk study, not a goal: BitLisp does not want fungible asset tokens on Bitcoin, it wants to know what the vocabulary can build and what that exposes (decision by Evan, 2026-08-22). The name BAT1 applies if a standard is ever written. Eight authoring observations across the vault and the singleton are recorded there for the ledger. **Standing constraints:** -- **Hard scope boundary.** v0 is a small s-expression language with Chialisp-class ergonomics, BitLisp-native, no BLS vocabulary. Out of scope: static types, a Rue-class frontend, editor tooling, optimization beyond the obvious. The typed v1 question is a separate gate after Phase 5 review (ledger notes: 2026-08-11, types would let the REPL print by known type. 2026-08-16, whether the unit 6c macro cut holds for v1, decided on the unit 7 authoring experience). +- **Hard scope boundary.** v0 is a small s-expression language with Chialisp-class ergonomics, BitLisp-native, no BLS vocabulary. Out of scope: static types, a Rue-class frontend, editor tooling, optimization beyond the obvious. The typed v1 question is a separate gate after Phase 5 review (ledger notes: 2026-08-11, types would let the REPL print by known type. 2026-08-16, whether the unit 6c macro cut holds for v1, decided on the unit 7 authoring experience. 2026-08-22, eight observations from two puzzles in `docs/puzzles/singleton.md`: `let` first, domain guards as the typing evidence, a standard list library, `list*`, a shared test harness, and a Phase 4 encoding-operator cost question). - **Compiler correctness story.** The compiler sits outside spec-before-code, but compiler bugs become fund-loss bugs for users: every construct gets compile-and-run tests against the reference VM, and every compiled benchmark puzzle is pinned as a vector the same day. - **Fallback, pre-registered:** if v0 slips, Phase 4 proceeds with the stock Chialisp toolchain off-tree, constrained to the CLVM intersection. The stopgap never enters the tree. The fallback covers the language units only; the front end does not slip out of the phase. diff --git a/docs/glossary.md b/docs/glossary.md index 495f79a..49b95cd 100644 --- a/docs/glossary.md +++ b/docs/glossary.md @@ -73,3 +73,11 @@ A term enters this table in the same PR that introduces it. | 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 | +| singleton | no script equivalent, compare an inscription tracked by an indexer | singleton (singleton_top_layer) | the fourth benchmark puzzle: a lineage of coins, one live at a time, identity fixed at launch, state replaced per spend, uniqueness enforced by the program rather than by an indexer | +| launcher outpoint | the outpoint of any coin | launcher id (the launcher coin's id) | a singleton lineage's identity, the outpoint whose one spend created the first coin of the lineage, curried into the wrapper | +| lineage proof | the txid preimages of the creating and grandparent transactions | lineage proof (parent id, parent inner puzzle hash, parent amount) | the serialized transactions a singleton spend supplies to prove its creating transaction spent a coin at the lineage scriptPubKey | +| state output | an OP_RETURN output | the inner puzzle hash curried into the full puzzle, and CREATE_COIN creating exactly the named coin | the zero-value output of a singleton's creating transaction committing, under the lineage tag, the tree hash of the next inner program's hash, the child's amount, and the child's output index | +| inner program | no script equivalent | inner puzzle | the program a wrapper runs and whose conditions it rewrites, supplied by the spend and committed by the state output | +| lineage tag | no script equivalent | the launcher id in a singleton's announcements | the 36-byte launcher outpoint opening a state output's payload, so two singletons spent together each find their own | +| child marker | no script equivalent | the odd-amount CREATE_COIN the singleton top layer morphs | the one odd-amount CREATE_OUTPUT an inner program emits, which the wrapper rewrites into the child coin and its state output | +| committed placement | no script equivalent | CREATE_COIN creating exactly the named coin | the state output naming the child by amount and output index, plus the owner's SEAL_OUTPUTS, standing in for exact coin creation under index-free claims and free outputs | diff --git a/docs/puzzles/singleton.md b/docs/puzzles/singleton.md new file mode 100644 index 0000000..54d7e91 --- /dev/null +++ b/docs/puzzles/singleton.md @@ -0,0 +1,587 @@ +# The singleton wrapper benchmark puzzle + +The fourth of the Phase 3 benchmark puzzles: a coin that exists +exactly once. A singleton is a lineage of coins, one live at a time, +carrying an identity fixed at launch and a state its owner or its +rules replace on every spend. Chia's `singleton_top_layer` is the +reference: it wraps an arbitrary inner program, rewrites the inner +program's output-creation conditions so the child coin is wrapped +the same way, and proves on every spend that the coin descends from +its launcher. Everything in Chia that needs a unique on-chain +identity sits on it: NFTs, decentralized identifiers, pool state, +DataLayer roots, name registries. The wrapper pattern it embodies, +a program that runs another program and morphs its conditions, is +the userspace covenant engine the evaluation document names, and +this puzzle is its acceptance test. Whether the singleton itself +earns a place on Bitcoin is a separate question, answered honestly +in the next section: for the constructions Bitcoin cares about +first it does not, and what it built is the foundation the asset +token benchmark needs. This is tooling and vectors only: nothing +here changes `spec/` or the consensus implementation. + +Sources live in `puzzles/singleton/`, shared helpers in +`puzzles/lib/`. Both programs compile with the two include +directories on the search path: + +``` +bitlisp-compile puzzles/singleton/singleton.bl -I puzzles/lib -I puzzles/singleton +bitlisp-compile puzzles/singleton/owner-inner.bl -I puzzles/lib -I puzzles/singleton +``` + +## Is a singleton worth having on Bitcoin + +The singleton entered the plan with the repository's first commit +as one of four puzzles to write, with no recorded rationale, and +the evaluation document's benchmark suite never lists it. The suite +lists a fungible asset token, and mentions singletons once, as the +example of the wrapper pattern. So the question of value was owed +before review, and it was answered two ways on 2026-08-22: a census +of what the vendored Chia code actually uses singletons for, and a +pass over the constructions Bitcoin cares about first. + +The test that decides it is the **funded imitation**: anyone can +pay to a construction's scriptPubKey and then try to spend that coin +as if it were the real one. A singleton exists to make that coin +unspendable. The question for each construction is who loses if it +were spendable. + +| construction | identity comes from | state advanced by | a funded imitation hurts | singleton needed | +| --- | --- | --- | --- | --- | +| Lightning channel, LN-Symmetry | the funding outpoint | 2-of-2 signatures | the faker only | no | +| channel factory | the factory outpoint | n-of-n signatures | the faker only | no | +| Ark round | the round outpoint | the coordinator and the users, timelocks | the faker only | no | +| vault | the curried policy | the owner's key, then keyless paths | nobody, a funded "fake" vault coin is a deposit | no | +| payment pool | the pool outpoint | n-of-n, unilateral exit under rules | the faker only, an exit from a fake balance tree returns the faker's own sats | no | +| oracle or DLC with a fixed key | the key | the key | nobody, ASSERT_SIG_RAW suffices, no co-spend needed | no | +| fungible asset token | the issuance lineage | anyone holding tokens | everyone, a fake mints value from nothing | yes, this lineage proof | +| name registry, identity with a changing policy | the lineage | a program, not one key | whoever relied on the name or identity | yes | + +Every value-carrying construction gets identity from its root +outpoint, which base consensus spends exactly once, and authority +from its parties' signatures, and an imitation is someone buying +their own coin. The singleton earns its keep only where the coin's +meaning is external to its own satoshis: a token's provenance, a +name, an identity whose policy changes over time. + +The Chia census says the same. Every dependent in the vendored +corpora names a singleton by its launcher id: the NFT layers (one +NFT, one history), the DID inner puzzle (identity across key +recovery, and a forked DID could cast a recovery vote twice), the +pool member (a reward absorbed once, keyless), and the tibetswap +pair, whose reserve coins hold real value claimable only by the one +live descendant. chia-gaming, a real state channel with off-chain +state and preemption, never applies the wrapper at all: two keys +and per-coin curried commitments carry it, the Lightning shape. +Every Chia use is a token, an identity, or a coin governing other +coins, and none is a two-party value-carrying state machine. + +The census also settled the design question the next section +raises. No dependent needs the puzzle hash to move with the inner +puzzle. The only thing any of them reconstructs from the current +hash is an announcement target, and each such site +(`p2_singleton`, the liquidity TAIL, DID recovery) must be handed +the current inner hash at runtime to do it. Under a constant +scriptPubKey that overhead disappears, and Chia's singleton +fast-forward, today usable only for singletons whose inner puzzle +never changes, would apply to every singleton. The constant +scriptPubKey is the better shape on Chia's own evidence, not a +compromise. + +Verdict, recorded for the plan: the singleton as a standalone +identity primitive has thin demand on Bitcoin, and Ark, Lightning, +vaults, and pools will not import it. What this puzzle built, the +serialization library, the two-preimage lineage proof, the +committed placement, and the condition morph, is exactly what the +fungible asset token needs, the one construction on the list where +a funded imitation steals, and the suite's own entry. That is the +value this work delivered, and the remaining benchmark effort on +lineage belongs there. + +One thing the token benchmark is not: a goal. BitLisp does not set +out to put fungible asset tokens on Bitcoin. The benchmark exists +because a covenant vocabulary that can express a vault can +probably express a token layer too, and the project's obligation is +to know that, to know what it costs, and to state the risks, rather +than to discover them after deployment. The token is built to +understand the capability and its exposure, not to ship it. Should +a standard ever be written, its name is BAT1, the Bitcoin asset +token standard (decision by Evan, 2026-08-22). + +## Why the Chia construction does not port directly + +Chia identifies a coin by the hash of three things: its parent +coin's id, its own puzzle hash, and its amount. A singleton proves +its descent in one step. The spend supplies the parent's inner +puzzle hash, the wrapper recomputes what the parent's full puzzle +hash must have been, hashes that into the parent coin id, hashes +that into its own coin id, and asserts the result with +ASSERT_MY_COIN_ID. One hash chain, one fixed-size proof, and the +parent's program is part of the child's identity. + +Bitcoin identifies a coin by its outpoint: the txid of the creating +transaction and an output index. The txid commits to the creating +transaction's non-witness serialization, which names the outpoints +it spent and the scriptPubKeys it created, but never the +scriptPubKeys it spent. So a coin can prove which outpoint its +creating transaction consumed by supplying that transaction's +serialization, but to learn what script that outpoint carried it +must supply the grandparent's serialization as well. Two preimages +where Chia needs one, and the cost of the proof scales with the +size of the two transactions rather than being fixed. + +A second obstacle is sharper. Chia's wrapper recognizes its +parent's puzzle hash by recomputing it, and can, because a puzzle +hash is a tree hash. Here the parent's scriptPubKey is a taproot +output key, the internal key tweaked by the merkle root, and no VM +operator performs that tweak. `secp_verify` is BIP340 Schnorr only, +and a Schnorr verification cannot be bent into a point addition the +way an ECDSA verification could. The validator derives the tweak +for the spending input's own scriptPubKey through ASSERT_MY_TAPROOT +and for claimed outputs through CREATE_OUTPUT_TAPROOT, and for +nothing else. A program can therefore recognize exactly one +scriptPubKey as a member of its own family: its own. + +That constraint decides the construction. Every coin of a lineage +sits at one scriptPubKey, fixed at launch, so "the parent sat at a +lineage scriptPubKey" becomes a byte comparison against the coin's +own, which its own creating transaction reveals. The state, the +inner program the spend must run, cannot then live in the +scriptPubKey. It lives in the creating transaction instead: a +zero-value OP_RETURN output tagged with the lineage commits the +inner program's tree hash, together with the child's amount and +output index, and the child reads it back through the same +serialization it already supplies for the lineage proof. + +The alternative is the Chia shape with the inner program curried +into the wrapper, a scriptPubKey that changes with every state, and +a VM operator computing the taproot tweak so the parent's +scriptPubKey can be recognized. Condition-record decision 3 +declined such an operator when the curve door was decided, on the +ground that a pure VM could only check a solution-supplied claim +about a scriptPubKey. This puzzle is the first construction to +supply the other half of that claim: the scriptPubKey it would +check is bound, through the grandparent's serialization, to the +parent's txid, so the operator would be checking a consensus-bound +value, not a free one. Both sides of the shape question, for the +record: + +- For the constant scriptPubKey: it needs nothing the v0 vocabulary + lacks, it costs no point multiplication beyond the one + ASSERT_MY_TAPROOT already charges, a wallet watches one address + for the whole lineage, a counterparty paying to the singleton + addresses it by that one scriptPubKey rather than by a hash that + moves with the state, and the Chia census above found no + dependent that needs the hash to move. The state output costs + about 80 bytes per spend. +- For the Chia shape: the scriptPubKey commits the state, so a + construction that addresses a singleton by its current state + works by computing one hash, and the inner program is part of + the coin rather than a witness the spend reveals. It needs the + tweak operator, a consensus change priced at one point + multiplication, and the lineage proof still needs both + serializations, since the grandparent reveals the parent's + scriptPubKey either way. + +The constant scriptPubKey is the built shape, on the census +evidence and because it is buildable inside the phase (decision by +Evan, 2026-08-22). The tweak operator is flagged for the Phase 4 +gate against decision 3, with this puzzle as the case that answers +decision 3's objection, and the asset token as the construction +that would decide whether the Chia shape is worth the operator. + +## Instance identity + +A singleton lineage is the wrapper program curried with two fixed +values. Its coins' scriptPubKey is the taproot output of the BIP341 +nothing-up-my-sleeve point tweaked with the curried program's tree +hash as the merkle root, the same identity convention as the vault. +The vault curries its internal key. The wrapper fixes it as a +constant instead, because a singleton's guarantees are relied on by +third parties, and every one of them rests on a coin at the lineage +scriptPubKey moving only by running this program: a curried key +would let whoever held it replace the state by key path without +running the inner program, and no relying party could tell from +the scriptPubKey alone. + +| value | width | meaning | +| --- | --- | --- | +| `SINGLETON_MOD_HASH` | 32 | tree hash of the uncurried wrapper program | +| `LAUNCHER_OUTPOINT` | 36 | the lineage's identity: the outpoint of the coin whose spend created the first singleton coin | + +The launcher is any coin at all. Its outpoint exists before the +launch transaction does, so the identity is known, and the lineage +scriptPubKey computable, before the first singleton coin exists. +Base consensus spends the launcher once, and that is the whole +launch mechanism: no launcher program, no launch announcement. + +Every spend asserts ASSERT_MY_TAPROOT over the recomputed root, +which proves the coin commits to this program and nothing else, and +ASSERT_MY_OUTPOINT over the txid of the supplied creating +transaction, which makes that transaction's output at the coin's +index the coin's own scriptPubKey. The binding is program-to-coin +only, as for the vault: the wallet checks a curry before funding it. +The wrapper checks both values' widths on every spend so a +malformed instance fails on its first spend of any kind. + +## The lineage proof + +``` + launcher L coin 1 (first) coin 2 coin 3 + any script +----> spk_L, odd amt +----> spk_L, odd +--> spk_L, odd + outpoint L | state: h1, a, i | state: h2 | state: h3 + | | | | | | + v | v | v | + +----------+ | +----------+ | +----------+ | + | launch |---+ | spend 1 |--------+ | spend 2 |------+ + | spends L | | spends | | spends | + | out i -->| | coin 1 | | coin 2 | + | OP_RETURN| | out j -->| | out k -->| + | L || H( | | OP_RETURN| | OP_RETURN| + | h1,a,i) | | L || H( | | L || H( | + +----------+ | h2,a,j) | | h3,a,k) | + +----------+ +----------+ + + coin 3 proves: spend 2 hashes to my txid, one of its inputs is + coin 2, spend 1 hashes to coin 2's txid and + created it at spk_L, and spend 2's one state + output for L names my inner program, my amount, + and my index k. +``` + +A spend supplies its creating transaction in full, as the field +list `puzzles/lib/tx-wire.blib` serializes, and the wrapper hashes +the serialization twice and asserts ASSERT_MY_OUTPOINT over that +txid and the coin's own output index. The serialization library +emits every length prefix in Bitcoin's canonical compact-size +encoding and width-checks every fixed field, so Bitcoin's parser +reads back from the byte string exactly the fields it was built +from: a supplied field list proves the creating transaction's +structure, not merely its hash. + +**The parent check.** The spend names which input of the creating +transaction is the parent. If the parent's outpoint equals +`LAUNCHER_OUTPOINT`, the coin is the first of its lineage and the +check ends. Otherwise the spend supplies the parent's creating +transaction too, the grandparent, with the parent's output index in +it. The grandparent must hash to the txid half of the parent's +outpoint, the index must match the index half, and the output at +that index must carry the lineage scriptPubKey byte-exact. That is +the induction step: a coin at the lineage scriptPubKey is spendable +only by running this program, so a transaction that spent one spent +a genuine singleton, and a genuine singleton's spend created one +child. A coin at the lineage scriptPubKey that no singleton spend +created, however it was funded, has no proof and never moves. + +**Committed placement.** The parent's outpoint is spent by exactly +one transaction, so there is exactly one creating transaction per +generation. Within it, the state output names the child: its +payload is the tree hash of the list (inner program hash, amount, +output index), and the child verifies its own triple against it. +A second output at the lineage scriptPubKey, added by whoever +assembled the transaction, carries an amount or an index the state +output does not name, and is dust. This replaces the Chia wrapper's +reliance on CREATE_COIN creating exactly the coin it names, which +validation rule 1's index-free claims and rule 2's free outputs do +not provide. + +## The state output + +The creating transaction commits the child's state through one +output whose script is + +``` +OP_RETURN <68 bytes: LAUNCHER_OUTPOINT || sha256tree((INNER_HASH AMOUNT INDEX))> +``` + +spelled `0x6a 0x44` then the 68 bytes, 70 bytes in all, amount +zero. The wrapper scans the creating transaction's outputs for +scripts opening with `0x6a44` and the lineage's outpoint, requires +exactly one, and requires its payload to hash the supplied inner +program's tree hash with the coin's own amount and index. The tag +carries the lineage so that two singletons spent in one transaction +each find their own state output. Exactly one is required because +whoever assembles a transaction may add outputs the claims never +asked for: two tagged outputs would let the assembler offer two +states and let whoever can satisfy either inner program take the +singleton, so the child refuses both. + +An ending spend commits the same shape with the all-zero payload. +A live payload is a tree hash and nothing hashes to zero, so an +ended lineage's slot can never be refilled: a refill needs a tagged +output naming the refilled coin, and that is a second tagged output. + +## The spend + +The solution is `(MY_AMOUNT MY_INDEX CHILD_INDEX PARENT_TX +PARENT_INPUT PARENT_VOUT GRANDPARENT_TX INNER INNER_SOLUTION)`: the +coin's amount and output index, the index the child will take in +the spending transaction, the creating transaction, the parent's +input index in it, the parent's output index in the grandparent and +the grandparent itself (both nil for the first coin), the inner +program, and its solution. The scriptPubKey is not supplied: it is +the creating transaction's output at the coin's index. + +Checks, in order: the curried values' widths, the coin's amount +odd, the parent proven, the state proven. Then the wrapper runs the +inner program over the cons of the coin's own data onto the inner +solution, that data being +`(LAUNCHER_OUTPOINT MY_OUTPOINT MY_SPK MY_AMOUNT INNER_HASH)`, and +rewrites the conditions it yields. Emitted conditions: + +1. `ASSERT_MY_TAPROOT ` +2. `ASSERT_MY_AMOUNT MY_AMOUNT` +3. `ASSERT_MY_OUTPOINT ` +4. The inner program's conditions, morphed. + +**The morph.** Exactly one of the inner program's conditions must +be a CREATE_OUTPUT whose amount is odd, and the wrapper raises at +the second one or at the end of a list with none. Its scriptPubKey +operand is read as the next inner program's tree hash, 32 bytes, +and the condition becomes two: `CREATE_OUTPUT MY_SPK `, the +child at the lineage scriptPubKey, and `CREATE_OUTPUT 0`. An odd amount of exactly -113 +instead ends the lineage: the condition becomes the ending state +output alone and no child is created, Chia's own escape value for a +singleton's last spend, kept here so a lineage ends only on an +explicit signal and never because an inner program forgot to create +its child. Every other condition passes through unchanged, so an +inner program creates ordinary outputs with even amounts and +asserts whatever it likes. An odd-amount CREATE_OUTPUT_TAPROOT is +rejected, so a spend creates one odd output and no more, and an +odd-amount CREATE_OUTPUT at any other script is read as a second +child and rejected the same way. + +A singleton coin's amount is always odd, the child marker, and the +wrapper refuses to run on an even one. + +## The owner inner program + +`owner-inner.bl` is the simplest inner program that makes the +lineage useful: one curried key owns the state. Its solution is +`(NEXT_INNER_HASH NEXT_AMOUNT EXTRA_CONDITIONS OUTPUTS_HASH SIG)`. +It emits `ASSERT_SIG_MY_OUTPOINT OWNER_KEY SIG`, +binding the authorization to the singleton coin's own outpoint, +then `SEAL_OUTPUTS OUTPUTS_HASH`, then `CREATE_OUTPUT +NEXT_INNER_HASH NEXT_AMOUNT`, the child marker, then the extra +conditions verbatim. The seal is the owner's placement commitment: +the wrapper can claim the child and the state output but cannot +place them, and with the outputs sealed under the owner's signature +no observer can reorder them, double the state output, or +substitute a coin of their own, while the input side stays open for +anyone's fee input. Handing the singleton to a new owner is a spend +whose next inner hash is the program curried with the new key. The +signature and the seal travel through the wrapper untouched, +because the wrapper passes every condition but the marker through. +The extra conditions may create only even-amount outputs, and none +tagged with the lineage. + +## Chia correspondence + +| `singleton_top_layer` | here | +| --- | --- | +| `SINGLETON_STRUCT` = (mod hash, launcher id, launcher puzzle hash) | `SINGLETON_MOD_HASH`, `LAUNCHER_OUTPOINT`, no launcher program | +| launcher puzzle creating the eve coin and announcing it | any coin, spent by any transaction whose state output names the first coin | +| `INNER_PUZZLE` curried, full puzzle hash moves with the state | inner program supplied in the solution, committed by the state output, one scriptPubKey per lineage | +| lineage proof (parent's parent, parent inner hash, parent amount) and ASSERT_MY_COIN_ID | creating and grandparent transactions, ASSERT_MY_OUTPOINT, committed placement | +| eve proof (parent's parent, parent amount) checked against the launcher puzzle hash | parent outpoint equals `LAUNCHER_OUTPOINT` | +| truths prepended to the inner solution | the coin's own data `(LAUNCHER_OUTPOINT MY_OUTPOINT MY_SPK MY_AMOUNT INNER_HASH)` | +| CREATE_COIN creates exactly the named coin | the state output names the child by amount and index, and the owner's seal fixes the output set | +| exactly one odd CREATE_COIN, morphed to the wrapped puzzle hash | exactly one odd CREATE_OUTPUT, morphed to the lineage scriptPubKey plus the state output | +| -113 escape value | -113, `END_AMOUNT`, with the ending state output | +| my amount odd | same | + +Recorded divergences from the Chia construction: + +- The scriptPubKey is constant per lineage and the state is + committed by a tagged OP_RETURN output of the creating + transaction, for the reasons the opening sections state. +- The lineage proof carries two transaction serializations, and its + cost is the size of those transactions. A griefer who can assemble + a singleton's spend, which any party can for an inner program + with a public path, can bloat that transaction so the next two + spends carry it in their witnesses. Chia's proof is three + fixed-size fields. +- There is no launcher program. Chia's launcher exists to fix the + singleton id before the eve coin exists and to create exactly one + eve coin. Here the launcher's outpoint is the id, base consensus + spends it once, and the launch transaction's state output names + one output of that spend as the first coin. +- Placement is committed rather than created. Chia's CREATE_COIN + creates exactly the coin it names, so an inner program's + authorization is the child's existence. Here validation rule 1 + matches claims by content without fixing an index and rule 2 + leaves unclaimed outputs free, so the wrapper can claim the child + but cannot place it. Two mechanisms stand in: the state output + names the child by amount and index, so any other coin at the + lineage scriptPubKey is dust and an ended slot cannot be + refilled, and an inner program with a signer seals the outputs so + the signed placement is immutable. What remains is for inner + programs with a public path and no signer: whoever assembles such + a spend can end the lineage by misplacing the child or doubling + the state output, a griefing Chia's exact coin creation does not + allow, and one such a program accepts by having a public path at + all. It can never redirect the lineage: every outcome of + misplacement is a dead coin, not a live one under someone else's + state. +- Two lineages spent in one transaction need two OP_RETURN outputs, + which relay policy before Bitcoin Core 30 treated as non-standard. + Consensus never did, and the project records policy dependencies + rather than designing around them. + +## Adversarial cases + +Each is pinned in `vectors/vm/singleton-programs.json` or +`vectors/validation/singleton-lineage.json`, and reproduced with +its exact error code in `python/tests/test_singleton_puzzles.py`. + +- A coin at the lineage scriptPubKey funded by an ordinary payment, + with a perfect state output beside it, fails the parent check: + the input it names is neither the launcher nor a coin at the + lineage scriptPubKey, whether no grandparent, an unrelated + grandparent, or the real grandparent of an ordinary coin is + supplied, and a correct grandparent with the wrong output index + fails the index clause. +- The generation 1 spend re-assembled by an observer, a 1-satoshi + coin of the observer's own at the committed index and the + authorized coin moved elsewhere, fails the owner's seal, and + without the seal both coins are dead: one on amount, the other on + index. +- The ending spend re-assembled with a refill, a coin and a second + tagged output, fails the owner's seal, and the refilled coin finds + two tagged outputs and dies. +- A fee input prepended to the broadcast spend leaves it valid with + the owner's witness unchanged. Reordered outputs fail the seal. +- The authorized conditions presented for a coin at the wrong + outpoint fail ASSERT_MY_OUTPOINT in the validator. +- An inner program other than the committed one fails the state + check, and so does a creating transaction carrying two tagged + state outputs. +- An even amount, an inner program creating no odd output, one + creating two, and one creating an odd CREATE_OUTPUT_TAPROOT at the + lineage root, all raise. +- A malformed instance and a serialization with a wrong field + width raise before any condition is emitted, and a field list + with no inputs or no outputs never serializes. + +## Fees and composition + +The wrapper claims the child and the state output and asserts its +own data. It seals nothing itself, and the owner inner program +seals the outputs, so fee inputs attach freely to a broadcast spend +and two lineages compose in one transaction when their owners seal +the same output set, pinned by a vector. The transaction model +requires outputs not to exceed inputs, so every example transaction +carries an ordinary fee input beside the singleton coin, and the +launch transaction is a plain wallet transaction whose only BitLisp +content is the two outputs it creates. + +## Authoring observations across the vault and the singleton + +Two puzzles in the v0 language, about 500 source lines between +them, are enough to see repeated shapes. Each is recorded here with +a concrete candidate, for the typed v1 ledger and for the language +itself. None is implemented by this change. + +1. **Naming a value once is the dominant cost.** The vault's + `dispatch` exists to name a reconstructed root, and the + singleton's `spend` and `emit` exist to name a scriptPubKey, a + txid, and an inner hash, threading eleven and twelve parameters + through helpers whose only purpose is a binding. The + pre-registered `assign` trigger has now fired in both puzzles. + Candidate: a `let` form with several bindings, compiled exactly + as those helpers are written by hand, a synthetic function + taking the bound names as parameters and called once, so it + costs one apply and no new compiled shape. Chialisp's modern + compiler has `let` and `assign`, and the census that deferred + them found two test-only uses. The puzzles are the production + evidence that was missing. +2. **Every curried value gets a domain guard.** Both puzzles open + with an `assert` block checking widths and ranges of every fixed + value, because a malformed instance must fail on its first + spend rather than on the one path that reads the bad value. This + is the evidence the typed v1 gate asked for: the curried + parameter domains are the main thing a type would check, and a + compiler that emitted these guards from declared widths would + remove the block and the risk of omitting one entry from it. +3. **List helpers are rewritten per puzzle.** `sum-amounts`, + `require-conditions`, `state-scripts`, and the serializers are + the same recursion skeleton. Without function values or macros + there is no `map`, and that is Chialisp's position too. This + change starts `puzzles/lib/list.blib` owning the generic names + `length` and `nth`, so a library never claims them incidentally + under the one-namespace rule. +4. **Consing conditions onto a tail.** Condition lists are built as + `(c A (c B (c C TAIL)))` in both puzzles because `list` cannot + end in a tail. Candidate: a `list*` form consing its arguments + onto its last one, a purely syntactic compiler form with an + obvious expansion. Chialisp lacks it, so it would be a recorded + tooling divergence, and a small one. +5. **Identity reconstruction is the same call three times.** + `vault-root`, `triggered-root`, and `singleton-root` each spell + `curried-tree-hash` over a hand-written list of `sha256tree` + calls. A `map` would fold them, and its absence is item 3. + Until then a helper taking the raw values, one arity per + length, is the honest option, and the Phase 4 commitment scheme + may replace the whole convention. +6. **Self data arrives in the solution and is asserted.** The + amount and outpoint are supplied and then pinned with the self + asserts in every path of both puzzles, because no operator reads + the spending input's prevout. That is Chia's shape as well and + costs one condition each. A library helper emitting the asserts + together would remove the repetition without touching the + vocabulary. +7. **Byte-level encoding is clumsy at the VM layer.** Little-endian + widths are built one byte at a time through + `(substr (+ 256 B) 1 2)`, and the serialization library spends + most of its lines on compact-size and field widths. A Bitcoin + program that reads transactions will do this often. This is a + Phase 4 cost question, not a language one: a fixed-width + integer encoding operator, or a transaction-field family in the + spirit of the "opcodes special to parsing Bitcoin transactions" + Bram Cohen suggested for a UTXO-model Lisp, would shrink both the + witness and the cost line. +8. **Test harnesses repeat.** `test_vault_puzzles.py` and + `test_singleton_puzzles.py` each define proper-list building, + outpoint-bound signing, BitLisp input construction, and the + instance helper. A shared puzzle test module is due before the + third puzzle. + +## Worked instance + +The mod hashes, pinned in `python/tests/test_singleton_puzzles.py`: + +``` +$ bitlisp-compile -T puzzles/singleton/singleton.bl -I puzzles/lib -I puzzles/singleton +1d8a1a3714577ac5cee67abe6ae1a6972d29ba24ea0c599205f2f0069e943f83 +$ bitlisp-compile -T puzzles/singleton/owner-inner.bl -I puzzles/lib -I puzzles/singleton +40977e84db61eef5f52c9ac9b46dd2e2fbd6439674f50dd7a00ced5daf523bf0 +``` + +A lineage's merkle root and scriptPubKey follow from the launcher's +outpoint alone: + +``` +$ bitlisp-compile puzzles/singleton/singleton.bl -I puzzles/lib -I puzzles/singleton \ + | bitlisp-curry -a 0x -a 0x -T +``` + +Measured on the test lifecycle: the curried wrapper serializes to +3620 bytes, the first spend's solution to 551 bytes and a later +generation's to 832, the two serialized transactions being most of +it. Evaluation costs 166937 for the first spend and 244898 for a +later generation before the conditions charge, which add about 5.3 +million for the taproot assert, the signature assert, the seal, and +the two output claims. + +The compiled representatives, one per lifecycle step with the +in-program failures, are pinned in +`vectors/vm/singleton-programs.json`, and the condition-level +lifecycle in `vectors/validation/singleton-lineage.json`. The test +suite recompiles both programs, byte-compares every pinned program +and solution against a fresh compile, curry, and lifecycle +construction, builds the lifecycle from real transaction ids +through the transaction model, checks the serialization library +against the model's txid at every compact-size boundary, and +recomputes every conditions field in the validation vector file. +Source and corpus move together or not at all. diff --git a/puzzles/lib/list.blib b/puzzles/lib/list.blib new file mode 100644 index 0000000..0353ef8 --- /dev/null +++ b/puzzles/lib/list.blib @@ -0,0 +1,14 @@ +; Generic list helpers. +; +; Declarations share one namespace with the program that includes +; them, so these names belong to this file and nothing else defines +; them: a library needing a list helper includes this file rather +; than spelling its own. +( + (defun length (ITEMS) + (if ITEMS (+ 1 (length (r ITEMS))) 0)) + + ; The element at INDEX, raising past the end of the list. + (defun nth (ITEMS INDEX) + (if INDEX (nth (r ITEMS) (- INDEX 1)) (f ITEMS))) +) diff --git a/puzzles/lib/tx-wire.blib b/puzzles/lib/tx-wire.blib new file mode 100644 index 0000000..6531779 --- /dev/null +++ b/puzzles/lib/tx-wire.blib @@ -0,0 +1,81 @@ +; The non-witness wire serialization of a Bitcoin transaction, the +; preimage of its txid. +; +; A program that knows its own outpoint knows the txid of the +; transaction that created it, and that txid is the double SHA-256 of +; the transaction's serialization without witness data. Rebuilding +; that serialization from its fields and hashing it proves the fields: +; which outpoints the transaction spent and which outputs it created. +; Every length prefix is emitted in Bitcoin's canonical compact-size +; encoding, the only encoding the consensus parser accepts, and every +; fixed-width field is width-checked, so Bitcoin's parser reads back +; from the bytes built here exactly the fields they were built from. +; Each shape binds by position and ignores anything after its last +; field, and a transaction with no inputs or no outputs is rejected, +; since base consensus never creates one. +; +; A transaction is (VERSION INPUTS OUTPUTS LOCKTIME), each input +; (OUTPOINT SCRIPTSIG SEQUENCE), each output (AMOUNT SCRIPT). Fixed +; width fields arrive as raw wire bytes, little-endian where Bitcoin +; is: the version and locktime 4 bytes, an outpoint 36, a sequence 4, +; an amount 8. Scripts are raw bytes of any length, the scriptSig +; empty for every segwit input. +( + (include "list.blib") + + ; One byte holding an integer 0 to 255. Adding 256 forces a two + ; byte encoding whose low byte is the value, whatever its sign bit. + (defun-inline byte (VALUE) (substr (+ 256 VALUE) 1 2)) + + ; COUNT little-endian bytes of a non-negative integer. + (defun le-bytes (VALUE COUNT) + (if COUNT + (concat (byte (logand VALUE 255)) (le-bytes (ash VALUE -8) (- COUNT 1))) + ())) + + (defun compact-size (VALUE) + (if (> 253 VALUE) + (byte VALUE) + (if (> 65536 VALUE) + (concat 0xfd (le-bytes VALUE 2)) + (if (> 4294967296 VALUE) + (concat 0xfe (le-bytes VALUE 4)) + (concat 0xff (le-bytes VALUE 8)))))) + + (defun-inline tx-inputs (TX) (f (r TX))) + (defun-inline tx-outputs (TX) (f (r (r TX)))) + (defun-inline input-outpoint (INPUT) (f INPUT)) + (defun-inline output-script (OUTPUT) (f (r OUTPUT))) + + (defun serialize-input ((OUTPOINT SCRIPTSIG SEQUENCE)) + (assert (= (strlen OUTPOINT) 36) + (= (strlen SEQUENCE) 4) + (concat OUTPOINT (compact-size (strlen SCRIPTSIG)) SCRIPTSIG SEQUENCE))) + + (defun serialize-inputs (INPUTS) + (if INPUTS + (concat (serialize-input (f INPUTS)) (serialize-inputs (r INPUTS))) + ())) + + (defun serialize-output ((AMOUNT SCRIPT)) + (assert (= (strlen AMOUNT) 8) + (concat AMOUNT (compact-size (strlen SCRIPT)) SCRIPT))) + + (defun serialize-outputs (OUTPUTS) + (if OUTPUTS + (concat (serialize-output (f OUTPUTS)) (serialize-outputs (r OUTPUTS))) + ())) + + (defun serialize-tx ((VERSION INPUTS OUTPUTS LOCKTIME)) + (assert (= (strlen VERSION) 4) + (= (strlen LOCKTIME) 4) + INPUTS + OUTPUTS + (concat VERSION + (compact-size (length INPUTS)) (serialize-inputs INPUTS) + (compact-size (length OUTPUTS)) (serialize-outputs OUTPUTS) + LOCKTIME))) + + ; The txid in the byte order outpoints carry. + (defun-inline txid (TX) (sha256 (sha256 (serialize-tx TX)))) +) diff --git a/puzzles/singleton/owner-inner.bl b/puzzles/singleton/owner-inner.bl new file mode 100644 index 0000000..0353a50 --- /dev/null +++ b/puzzles/singleton/owner-inner.bl @@ -0,0 +1,26 @@ +; An inner program for the singleton wrapper: one key owns the state. +; +; The wrapper runs this program over the coin's own data consed onto +; the inner solution, so the environment is (OWNER_KEY OWN . ARGS) +; once OWNER_KEY is curried. The owner signs the next inner program's +; hash, the next coin's amount, the extra conditions, and the +; spending transaction's outputs hash, bound to the singleton coin's +; own outpoint, so an authorization fits exactly one spend of exactly +; one coin. The outputs hash is sealed: the wrapper can claim the +; child and its state output but cannot place them, and the seal is +; what makes the signed placement immutable while leaving the input +; side open for anyone's fee input. The odd-amount CREATE_OUTPUT is +; the wrapper's child marker, rewritten by the wrapper into the next +; singleton coin and its state output. NEXT_AMOUNT of -113 ends the +; lineage. EXTRA_CONDITIONS pass through the wrapper unchanged: they +; may create only even-amount outputs, and none tagged with this +; lineage. +(program (OWNER_KEY (LAUNCHER MY_OUTPOINT MY_SPK MY_AMOUNT MY_INNER_HASH) + NEXT_INNER_HASH NEXT_AMOUNT EXTRA_CONDITIONS OUTPUTS_HASH SIG) + (c (list ASSERT_SIG_MY_OUTPOINT OWNER_KEY + (sha256tree (list NEXT_INNER_HASH NEXT_AMOUNT EXTRA_CONDITIONS + OUTPUTS_HASH)) + SIG) + (c (list SEAL_OUTPUTS OUTPUTS_HASH) + (c (list CREATE_OUTPUT NEXT_INNER_HASH NEXT_AMOUNT) + EXTRA_CONDITIONS)))) diff --git a/puzzles/singleton/singleton.bl b/puzzles/singleton/singleton.bl new file mode 100644 index 0000000..40f5de3 --- /dev/null +++ b/puzzles/singleton/singleton.bl @@ -0,0 +1,189 @@ +; The singleton wrapper: a coin that exists exactly once. +; +; A singleton is a lineage of coins, one live at a time, carrying an +; identity fixed at launch and a state that each spend may replace. +; The identity is LAUNCHER_OUTPOINT, the outpoint of an ordinary coin +; whose spend created the first singleton coin. Every coin of the +; lineage sits at one scriptPubKey: the taproot output of the BIP341 +; nothing-up-my-sleeve point tweaked with this program curried with +; its two fixed values, recomputed here and asserted on every spend, +; so no key path exists and a coin there moves only by running this +; program. The state is an inner program, which the spend supplies in +; full and this program runs. The transaction that created the coin +; commits the state in a zero-value OP_RETURN output tagged with the +; lineage, whose payload hashes the inner program's tree hash, the +; coin's amount, and the coin's output index together, so the +; committed state names one output of that transaction and the +; state is read back through the txid rather than carried in the +; scriptPubKey. +; +; Anyone can pay to the lineage's scriptPubKey, so the coin proves +; its descent before it does anything. Its creating transaction is +; supplied in full and must hash to its own txid. One input of that +; transaction is the parent, and the parent must itself have sat at +; this same scriptPubKey, proven by the parent's creating transaction +; in turn, unless the parent is the launcher itself. Base consensus +; spends an outpoint once, so one transaction creates the child of +; any singleton coin, and that transaction's one tagged output names +; one child by amount and index: the lineage never forks, and a coin +; at this scriptPubKey that no singleton spend created is +; unspendable. +; +; The solution is (MY_AMOUNT MY_INDEX CHILD_INDEX PARENT_TX +; PARENT_INPUT PARENT_VOUT GRANDPARENT_TX INNER INNER_SOLUTION). +; PARENT_TX is the creating transaction in the field shape the +; serialization library reads, MY_INDEX the coin's output index in +; it, PARENT_INPUT the parent's input index in it, PARENT_VOUT the +; parent's output index in GRANDPARENT_TX, which is nil when the +; parent is the launcher, and CHILD_INDEX the output index the +; child will take in the spending transaction. The inner program +; runs over the cons of the coin's own data (LAUNCHER_OUTPOINT +; MY_OUTPOINT MY_SPK MY_AMOUNT INNER_HASH) onto INNER_SOLUTION and +; yields conditions. Exactly one of them must be a CREATE_OUTPUT +; with an odd amount: its scriptPubKey operand is the next inner +; program's tree hash, and this program rewrites it into the next +; singleton coin at this same scriptPubKey plus the state output +; committing that hash, the amount, and CHILD_INDEX. An odd amount +; of -113 ends the lineage instead: no child, and a state output +; whose payload no inner program matches, so the ended slot cannot +; be refilled. Every other condition passes through unchanged, and +; an odd-amount CREATE_OUTPUT_TAPROOT is rejected, so a spend +; creates one odd output and no more. A singleton coin's own amount +; is always odd. +(program (SINGLETON_MOD_HASH LAUNCHER_OUTPOINT + MY_AMOUNT MY_INDEX CHILD_INDEX PARENT_TX PARENT_INPUT PARENT_VOUT + GRANDPARENT_TX INNER INNER_SOLUTION) + (include "curry-hash.blib") + (include "list.blib") + (include "tx-wire.blib") + + ; The BIP341 nothing-up-my-sleeve point. Every lineage proof rests + ; on a coin at the lineage scriptPubKey moving only through this + ; program, so the internal key is fixed here rather than curried. + (defconstant INTERNAL_KEY + 0x50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0) + + (defconstant END_AMOUNT -113) + + ; OP_RETURN then a direct push of 68 bytes: the 36-byte lineage tag + ; followed by the 32-byte state payload. + (defconstant STATE_OPCODES 0x6a44) + (defconstant STATE_TAG_LENGTH (+ (strlen STATE_OPCODES) 36)) + + ; The payload of an ended lineage. A live state's payload is a + ; tree hash, and nothing hashes to this. + (defconstant END_PAYLOAD + 0x0000000000000000000000000000000000000000000000000000000000000000) + + (defun singleton-root (SMH L) + (curried-tree-hash SMH (list (sha256tree SMH) (sha256tree L)))) + + (defun-inline state-tag (L) (concat STATE_OPCODES L)) + (defun-inline state-script (L PAYLOAD) (concat (state-tag L) PAYLOAD)) + (defun-inline state-payload (INNER_HASH AMOUNT INDEX) + (sha256tree (list INNER_HASH AMOUNT INDEX))) + + ; The parent is the launcher, or it sat at this scriptPubKey: its + ; own creating transaction must hash to the txid half of its + ; outpoint and show this scriptPubKey at the index half. + (defun parent-proven (L MY_SPK PARENT PARENT_VOUT GRANDPARENT_TX) + (if (= PARENT L) + 1 + (and (l GRANDPARENT_TX) + (= (substr PARENT 0 32) (txid GRANDPARENT_TX)) + (= (substr PARENT 32 36) (le-bytes PARENT_VOUT 4)) + (= (output-script (nth (tx-outputs GRANDPARENT_TX) PARENT_VOUT)) + MY_SPK)))) + + ; The scripts of every output carrying this lineage's state tag. + (defun state-scripts (OUTPUTS TAG) + (if OUTPUTS + (if (and (not (> STATE_TAG_LENGTH (strlen (output-script (f OUTPUTS))))) + (= (substr (output-script (f OUTPUTS)) 0 STATE_TAG_LENGTH) TAG)) + (c (output-script (f OUTPUTS)) (state-scripts (r OUTPUTS) TAG)) + (state-scripts (r OUTPUTS) TAG)) + ())) + + ; Exactly one tagged output, and it commits this coin's inner + ; program, amount, and index. Two tagged outputs would let whoever + ; assembled the creating transaction choose between two states, so + ; they commit nothing. + (defun state-proven (SCRIPTS EXPECTED) + (and SCRIPTS (not (r SCRIPTS)) (= (f SCRIPTS) EXPECTED))) + + ; The amount an output-creating condition carries, else zero. + (defun-inline created-amount (CONDITION) + (if (= (f CONDITION) CREATE_OUTPUT) + (f (r (r CONDITION))) + (if (= (f CONDITION) CREATE_OUTPUT_TAPROOT) + (f (r (r (r CONDITION)))) + 0))) + + ; Rewrites the inner program's conditions: the one odd CREATE_OUTPUT + ; becomes the child coin and its state output, or the ending state + ; output alone, and everything else passes through. FOUND records + ; whether the odd condition has been seen, so a second one raises + ; and a list without one raises at its end. + (defun morph (L MY_SPK CHILD_INDEX CONDITIONS FOUND) + (if CONDITIONS + (morph-one L MY_SPK CHILD_INDEX (f CONDITIONS) (r CONDITIONS) FOUND + (logand (created-amount (f CONDITIONS)) 1)) + (assert FOUND ()))) + + (defun morph-one (L MY_SPK CHILD_INDEX CONDITION REST FOUND ODD) + (if ODD + (assert (not FOUND) + (= (f CONDITION) CREATE_OUTPUT) + (if (= (f (r (r CONDITION))) END_AMOUNT) + (c (list CREATE_OUTPUT (state-script L END_PAYLOAD) 0) + (morph L MY_SPK CHILD_INDEX REST 1)) + (assert (= (strlen (f (r CONDITION))) 32) + (c (list CREATE_OUTPUT MY_SPK (f (r (r CONDITION)))) + (c (list CREATE_OUTPUT + (state-script L (state-payload (f (r CONDITION)) + (f (r (r CONDITION))) + CHILD_INDEX)) + 0) + (morph L MY_SPK CHILD_INDEX REST 1)))))) + (c CONDITION (morph L MY_SPK CHILD_INDEX REST FOUND)))) + + (defun emit (L ROOT MY_SPK MY_AMOUNT MY_INDEX CHILD_INDEX MY_OUTPOINT + PARENT_PROVEN STATES INNER INNER_HASH INNER_SOLUTION) + (assert PARENT_PROVEN + (state-proven STATES + (state-script L (state-payload INNER_HASH MY_AMOUNT MY_INDEX))) + (c (list ASSERT_MY_TAPROOT INTERNAL_KEY ROOT) + (c (list ASSERT_MY_AMOUNT MY_AMOUNT) + (c (list ASSERT_MY_OUTPOINT MY_OUTPOINT) + (morph L MY_SPK CHILD_INDEX + (a INNER (c (list L MY_OUTPOINT MY_SPK MY_AMOUNT INNER_HASH) + INNER_SOLUTION)) + ())))))) + + ; Exists to name the scriptPubKey, the txid, and the inner hash + ; once. The scriptPubKey is the creating transaction's output at + ; the coin's own index, which the outpoint assert makes the coin's + ; own. + (defun spend (L ROOT MY_AMOUNT MY_INDEX CHILD_INDEX PARENT_TX PARENT_INPUT + PARENT_VOUT GRANDPARENT_TX INNER INNER_SOLUTION) + (emit L ROOT + (output-script (nth (tx-outputs PARENT_TX) MY_INDEX)) + MY_AMOUNT MY_INDEX CHILD_INDEX + (concat (txid PARENT_TX) (le-bytes MY_INDEX 4)) + (parent-proven L + (output-script (nth (tx-outputs PARENT_TX) MY_INDEX)) + (input-outpoint (nth (tx-inputs PARENT_TX) PARENT_INPUT)) + PARENT_VOUT GRANDPARENT_TX) + (state-scripts (tx-outputs PARENT_TX) (state-tag L)) + INNER (sha256tree INNER) INNER_SOLUTION)) + + ; The fixed values are checked first so a malformed instance fails + ; on its first spend, and the coin's own amount must be odd, the + ; mark every child carries and no pass-through output may. + (assert (= (strlen SINGLETON_MOD_HASH) 32) + (= (strlen LAUNCHER_OUTPOINT) 36) + (logand MY_AMOUNT 1) + (spend LAUNCHER_OUTPOINT + (singleton-root SINGLETON_MOD_HASH LAUNCHER_OUTPOINT) + MY_AMOUNT MY_INDEX CHILD_INDEX PARENT_TX PARENT_INPUT PARENT_VOUT + GRANDPARENT_TX INNER INNER_SOLUTION))) diff --git a/python/tests/test_singleton_puzzles.py b/python/tests/test_singleton_puzzles.py new file mode 100644 index 0000000..1241f8f --- /dev/null +++ b/python/tests/test_singleton_puzzles.py @@ -0,0 +1,819 @@ +"""Compile-and-run coverage for the singleton wrapper benchmark puzzle. + +The wrapper and the owner inner program compile from source here, so +these tests hold the source-to-bytes link: the mod tree hashes are +pinned as literals, the serialization library is checked against the +transaction model's own txid at every compact-size boundary the +model reaches, the lifecycle runs through the single-spend runner +over transactions whose ids are real (each spend consumes an outpoint +the previous model transaction created), 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 CreateOutput, parse_conditions # noqa: E402 +from bitlisp.sexp import NIL, int_to_atom, iter_proper_list # 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 / "singleton") +BUDGET = 11_000_000_000 +SEQ_FINAL = 0xFFFFFFFF + +# The BIP341 nothing-up-my-sleeve point, fixed inside the wrapper. +NUMS = bytes.fromhex("50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0") +OWNER_SK = (0xC0 << 248 | 11).to_bytes(32, "big") +OWNER_PK = compute_xonly_pubkey(OWNER_SK)[0] +OWNER2_SK = (0xC1 << 248 | 12).to_bytes(32, "big") +OWNER2_PK = compute_xonly_pubkey(OWNER2_SK)[0] +FEE_SPK = bytes.fromhex("0014") + b"\x11" * 20 +PAY_SPK = bytes.fromhex("0014") + b"\x22" * 20 +AUX = b"\x00" * 32 +END_AMOUNT = -113 +END_PAYLOAD = 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. +SINGLETON_MOD_HASH = bytes.fromhex( + "1d8a1a3714577ac5cee67abe6ae1a6972d29ba24ea0c599205f2f0069e943f83" +) +OWNER_INNER_MOD_HASH = bytes.fromhex( + "40977e84db61eef5f52c9ac9b46dd2e2fbd6439674f50dd7a00ced5daf523bf0" +) + +SINGLETON_NODE, _ = compile_program( + (PUZZLES / "singleton" / "singleton.bl").read_text(), INCLUDES +) +INNER_NODE, _ = compile_program( + (PUZZLES / "singleton" / "owner-inner.bl").read_text(), INCLUDES +) + + +def proper_list(*items): + node = NIL + for item in reversed(items): + node = (item, node) + return node + + +def outpoint(txid, index): + return txid + index.to_bytes(4, "little") + + +def tx_fields(tx): + """The transaction in the field shape tx-wire.blib serializes.""" + return proper_list( + tx.version.to_bytes(4, "little"), + proper_list( + *[ + proper_list( + outpoint(i.txid, i.index), + i.script_sig, + i.sequence.to_bytes(4, "little"), + ) + for i in tx.inputs + ] + ), + proper_list( + *[ + proper_list(o.amount.to_bytes(8, "little"), o.script_pubkey) + for o in tx.outputs + ] + ), + tx.locktime.to_bytes(4, "little"), + ) + + +def state_payload(inner_hash, amount, index): + return tree_hash(proper_list(inner_hash, int_to_atom(amount), int_to_atom(index))) + + +def state_script(launcher, payload): + """OP_RETURN then a 68-byte push of the lineage tag and the state + payload.""" + return bytes.fromhex("6a44") + launcher + payload + + +def state_output(launcher, inner_hash, amount, index): + return TxOutput(state_script(launcher, state_payload(inner_hash, amount, index)), 0) + + +def lineage(launcher): + """A lineage's curried wrapper, its merkle root, and its + scriptPubKey.""" + inst = curry(SINGLETON_NODE, [SINGLETON_MOD_HASH, launcher]) + root = tree_hash(inst) + return inst, root, b"\x51\x20" + secp256k1.taproot_output_key(NUMS, root) + + +def sig_my_outpoint(sk, txid, index, message_node): + tag = hashlib.sha256(b"BitLisp/sig/my_outpoint").digest() + digest = hashlib.sha256( + tag + tag + outpoint(txid, index) + tree_hash(message_node) + ).digest() + return sign_schnorr(sk, digest, AUX) + + +def inner_solution(sk, txid, index, next_hash, next_amount, tx, extra=NIL, sig=None): + """The owner inner program's solution, signed over the next state, + the extra conditions, and the spending transaction's outputs.""" + message = proper_list(next_hash, int_to_atom(next_amount), extra, tx.outputs_hash) + if sig is None: + sig = sig_my_outpoint(sk, txid, index, message) + return proper_list(next_hash, int_to_atom(next_amount), extra, tx.outputs_hash, sig) + + +def solution( + amount, + index, + child_index, + parent_tx, + parent_input, + parent_vout, + grandparent, + inner, + args, +): + return proper_list( + int_to_atom(amount), + int_to_atom(index), + int_to_atom(child_index), + tx_fields(parent_tx), + int_to_atom(parent_input), + NIL if parent_vout is None else int_to_atom(parent_vout), + NIL if grandparent is None else tx_fields(grandparent), + inner, + args, + ) + + +def fee_input(txid=b"\xbb" * 32, amount=50_000, index=0): + return TxInput(txid, index, FEE_SPK, amount, sequence=SEQ_FINAL) + + +def singleton_input(spk, root, txid, index, amount, conditions=None): + """A BitLisp input of a single-leaf taproot tree, where the + executing leaf's hash is also the spending path's merkle root.""" + return TxInput( + txid, + index, + spk, + amount, + sequence=SEQ_FINAL, + conditions=conditions, + tapleaf=root, + merkle_root=root, + ) + + +def tx(inputs, outputs): + return Transaction( + version=2, locktime=0, inputs=tuple(inputs), outputs=tuple(outputs) + ) + + +LAUNCHER_TXID = b"\xaa" * 32 +LAUNCHER = outpoint(LAUNCHER_TXID, 0) +SINGLETON, ROOT, SPK = lineage(LAUNCHER) +INNER1 = curry(INNER_NODE, [OWNER_PK]) +H1 = tree_hash(INNER1) +INNER2 = curry(INNER_NODE, [OWNER2_PK]) +H2 = tree_hash(INNER2) +AMOUNT = 10_001 + +# The launch: a plain wallet transaction spends the launcher coin and +# places the first singleton coin at output 0, beside the state output +# committing the first inner program, the amount, and that index. +LAUNCH = tx( + [TxInput(LAUNCHER_TXID, 0, FEE_SPK, 100_000, sequence=SEQ_FINAL)], + [ + TxOutput(SPK, AMOUNT), + state_output(LAUNCHER, H1, AMOUNT, 0), + TxOutput(FEE_SPK, 80_000), + ], +) + +# Generation 1: the first coin hands the lineage to the second owner, +# child at output 0 again. +TX1 = tx( + [singleton_input(SPK, ROOT, LAUNCH.txid, 0, AMOUNT), fee_input()], + [ + TxOutput(SPK, AMOUNT), + state_output(LAUNCHER, H2, AMOUNT, 0), + TxOutput(FEE_SPK, 40_000), + ], +) +SOL1 = solution( + AMOUNT, 0, 0, LAUNCH, 0, None, None, INNER1, + inner_solution(OWNER_SK, LAUNCH.txid, 0, H2, AMOUNT, TX1), +) # fmt: skip + +# Generation 2: the singleton sits at input 1 and its child at output +# 1, and the second owner hands the lineage back. +TX2 = tx( + [fee_input(b"\xcc" * 32), singleton_input(SPK, ROOT, TX1.txid, 0, AMOUNT)], + [ + TxOutput(FEE_SPK, 40_000), + TxOutput(SPK, AMOUNT), + state_output(LAUNCHER, H1, AMOUNT, 1), + ], +) +SOL2 = solution( + AMOUNT, 0, 1, TX1, 0, 0, LAUNCH, INNER2, + inner_solution(OWNER2_SK, TX1.txid, 0, H1, AMOUNT, TX2), +) # fmt: skip + +# Generation 3 ends the lineage, paying the coin's value out beside +# the ending state output. +PAYOUT = proper_list(proper_list(b"\x01", PAY_SPK, int_to_atom(10_000))) +TX3 = tx( + [singleton_input(SPK, ROOT, TX2.txid, 1, AMOUNT)], + [TxOutput(PAY_SPK, 10_000), TxOutput(state_script(LAUNCHER, END_PAYLOAD), 0)], +) +SOL3 = solution( + AMOUNT, 1, 0, TX2, 1, 0, TX1, INNER1, + inner_solution(OWNER_SK, TX2.txid, 1, NIL, END_AMOUNT, TX3, PAYOUT), +) # fmt: skip + +# A second lineage, for composition. +OTHER_LAUNCHER = outpoint(b"\xa1" * 32, 1) +OTHER, OTHER_ROOT, OTHER_SPK = lineage(OTHER_LAUNCHER) +OTHER_LAUNCH = tx( + [TxInput(b"\xa1" * 32, 1, FEE_SPK, 100_000, sequence=SEQ_FINAL)], + [ + TxOutput(OTHER_SPK, AMOUNT), + state_output(OTHER_LAUNCHER, H1, AMOUNT, 0), + TxOutput(FEE_SPK, 80_000), + ], +) +# Two lineages spent in one transaction, each finding its own child +# and its own tagged state output, both owners sealing the same +# output set. +COMPOSED = tx( + [ + singleton_input(SPK, ROOT, LAUNCH.txid, 0, AMOUNT), + singleton_input(OTHER_SPK, OTHER_ROOT, OTHER_LAUNCH.txid, 0, AMOUNT), + fee_input(), + ], + [ + TxOutput(SPK, AMOUNT), + TxOutput(OTHER_SPK, AMOUNT), + state_output(LAUNCHER, H2, AMOUNT, 0), + state_output(OTHER_LAUNCHER, H2, AMOUNT, 1), + TxOutput(FEE_SPK, 40_000), + ], +) +COMPOSED_SOL = solution( + AMOUNT, 0, 0, LAUNCH, 0, None, None, INNER1, + inner_solution(OWNER_SK, LAUNCH.txid, 0, H2, AMOUNT, COMPOSED), +) # fmt: skip +OTHER_SOL = solution( + AMOUNT, 0, 1, OTHER_LAUNCH, 0, None, None, INNER1, + inner_solution(OWNER_SK, OTHER_LAUNCH.txid, 0, H2, AMOUNT, COMPOSED), +) # fmt: skip + +# Hostile creating transactions. FUNDED pays to the lineage +# scriptPubKey from an ordinary coin with a perfect state output +# beside it. CHAINED does the same from a coin whose own creating +# transaction is real, so only the grandparent's script clause can +# reject it. +FUNDED = tx( + [TxInput(b"\xee" * 32, 3, FEE_SPK, 100_000, sequence=SEQ_FINAL)], + [TxOutput(SPK, AMOUNT), state_output(LAUNCHER, H1, AMOUNT, 0)], +) +UNRELATED = tx([fee_input(b"\xed" * 32, 400_000)], [TxOutput(FEE_SPK, 100_000)] * 4) +GRANDPARENT_OF_FEE = tx([fee_input(b"\xdd" * 32, 60_000)], [TxOutput(FEE_SPK, 60_000)]) +CHAINED = tx( + [TxInput(GRANDPARENT_OF_FEE.txid, 0, FEE_SPK, 60_000, sequence=SEQ_FINAL)], + [TxOutput(SPK, AMOUNT), state_output(LAUNCHER, H1, AMOUNT, 0)], +) +TWO_STATES = tx( + LAUNCH.inputs, LAUNCH.outputs + (state_output(LAUNCHER, H2, AMOUNT, 0),) +) +# The generation 1 spend re-assembled by an observer: a 1-satoshi +# coin of the observer's own at the committed index, the authorized +# child moved to index 3. +SUBSTITUTED = tx( + [singleton_input(SPK, ROOT, LAUNCH.txid, 0, AMOUNT), fee_input()], + [ + TxOutput(SPK, 1), + state_output(LAUNCHER, H2, AMOUNT, 0), + TxOutput(FEE_SPK, 40_000), + TxOutput(SPK, AMOUNT), + ], +) +# The ending spend re-assembled with a refill: a 1-satoshi coin and a +# second tagged output naming the observer's inner program. +REFILLED = tx( + [singleton_input(SPK, ROOT, TX2.txid, 1, AMOUNT), fee_input()], + TX3.outputs + (TxOutput(SPK, 1), state_output(LAUNCHER, H2, 1, 2)), +) + + +def own_args(sk, parent, index, next_hash, amount, spending, extra=NIL): + return inner_solution(sk, parent.txid, index, next_hash, amount, spending, extra) + + +# Spends the owner sealed without the output the wrapper claims, so +# the claim alone fails validation. +CHILD_MISSING = tx(TX1.inputs, (TX1.outputs[1], TxOutput(FEE_SPK, 50_000))) +STATE_MISSING = tx(TX1.inputs, (TX1.outputs[0], TX1.outputs[2])) +END_STATE_MISSING = tx(TX3.inputs, (TX3.outputs[0],)) + + +def first_spend_sealing(spending): + return solution( + AMOUNT, 0, 0, LAUNCH, 0, None, None, INNER1, + own_args(OWNER_SK, LAUNCH, 0, H2, AMOUNT, spending), + ) # fmt: skip + + +def ending_spend_sealing(spending): + return solution( + AMOUNT, 1, 0, TX2, 1, 0, TX1, INNER1, + own_args(OWNER_SK, TX2, 1, NIL, END_AMOUNT, spending, PAYOUT), + ) # fmt: skip + + +def spend_error(program, sol, spending, input_index=0): + with pytest.raises(BitLispError) as info: + run_spend(program, sol, spending, input_index) + return info.value.code + + +def run_error(program, sol): + with pytest.raises(BitLispError) as info: + run(program, sol, BUDGET) + return info.value.code + + +def conditions_of(program, sol): + _, result = run(program, sol, BUDGET) + _, conds = parse_conditions(result, None) + return conds + + +def test_mod_hashes_pinned(): + assert tree_hash(SINGLETON_NODE) == SINGLETON_MOD_HASH + assert tree_hash(INNER_NODE) == OWNER_INNER_MOD_HASH + + +def test_curried_identity_matches_tooling(): + # The program's own root reconstruction, read off the taproot + # assert it emits, must agree with the tooling's tree hash over + # the curried node, and uncurry must read the values back. + inner, values = uncurry(SINGLETON) + assert inner == SINGLETON_NODE + assert values == [SINGLETON_MOD_HASH, LAUNCHER] + conds = conditions_of(SINGLETON, SOL1) + assert conds[0].internal_key == NUMS + assert conds[0].merkle_root == ROOT + assert conds[0].script_pubkey == SPK + + +def test_wire_serialization_matches_model(): + # The library's txid over the field shape equals the model's txid + # at every compact-size boundary the model can reach: script + # lengths 252, 253, 65535, and 65536, a 253-input list, and a + # non-empty legacy scriptSig. + txid_program, _ = compile_program( + '(program (TX) (include "tx-wire.blib") (txid TX))', INCLUDES + ) + legacy = TxInput( + b"\xdd" * 32, 7, FEE_SPK, 9_000, sequence=0x12345678, script_sig=b"\x00" * 5 + ) + samples = [LAUNCH, TX2] + for width in (252, 253, 65_535, 65_536): + samples.append( + Transaction( + version=1, + locktime=500_000, + inputs=(legacy, fee_input()), + outputs=( + TxOutput(b"\x6a" + b"\x55" * (width - 1), 0), + TxOutput(FEE_SPK, 59_000), + ), + ) + ) + samples.append( + tx( + [fee_input(bytes([i]) * 32, 1_000) for i in range(253)], + [TxOutput(FEE_SPK, 1_000)], + ) + ) + for sample in samples: + _, result = run(txid_program, proper_list(tx_fields(sample)), BUDGET) + assert result == sample.txid + + +def test_wire_serialization_rejects_empty_lists(): + txid_program, _ = compile_program( + '(program (TX) (include "tx-wire.blib") (txid TX))', INCLUDES + ) + fields = tx_fields(LAUNCH) + no_inputs = proper_list(fields[0], NIL, fields[1][1][0], b"\x00" * 4) + no_outputs = proper_list(fields[0], fields[1][0], NIL, b"\x00" * 4) + for bad in (no_inputs, no_outputs): + assert run_error(txid_program, proper_list(bad)) == "user_raise" + + +def test_lifecycle(): + _, conds = run_spend(SINGLETON, SOL1, TX1) + created = [c for c in conds if isinstance(c, CreateOutput)] + assert [c.script_pubkey for c in created] == [SPK, TX1.outputs[1].script_pubkey] + assert created[0].amount == AMOUNT + run_spend(SINGLETON, SOL2, TX2, 1) + _, conds = run_spend(SINGLETON, SOL3, TX3) + # The ending spend creates no child: the ending state output in + # the marker's place, then the payout the inner program asked for. + created = [c for c in conds if isinstance(c, CreateOutput)] + assert [c.script_pubkey for c in created] == [TX3.outputs[1].script_pubkey, PAY_SPK] + + +def test_fee_input_prepended_keeps_spend_valid(): + # Placement is committed by the state output and the owner's + # seal, never by the input index, so anyone may prepend a fee + # input to the broadcast spend with the owner's witness unchanged. + bumped = tx([fee_input(b"\xc9" * 32)] + list(TX1.inputs), TX1.outputs) + run_spend(SINGLETON, SOL1, bumped, 1) + + +def test_reordered_outputs_fail_the_owner_seal(): + reordered = tx(TX1.inputs, (TX1.outputs[1], TX1.outputs[0], TX1.outputs[2])) + assert spend_error(SINGLETON, SOL1, reordered) == "unsatisfied_seal_assert" + + +def test_funded_coin_without_lineage_is_unspendable(): + # An ordinary payment to the lineage scriptPubKey, with a perfect + # state output beside it, cannot prove descent: its creating + # transaction's input is neither the launcher nor a coin at this + # scriptPubKey, whatever grandparent is offered, including none. + args = own_args(OWNER_SK, FUNDED, 0, H2, AMOUNT, TX1) + for vout, grandparent in ((None, None), (3, UNRELATED)): + sol = solution(AMOUNT, 0, 0, FUNDED, 0, vout, grandparent, INNER1, args) + assert run_error(SINGLETON, sol) == "user_raise" + + +def test_grandparent_script_and_index_clauses(): + # A real chain whose grandparent hashes correctly but shows an + # ordinary script at the parent's index fails on the script + # clause alone, and a correct grandparent with the wrong output + # index fails on the index clause alone. + args = own_args(OWNER_SK, CHAINED, 0, H2, AMOUNT, TX1) + chained = solution(AMOUNT, 0, 0, CHAINED, 0, 0, GRANDPARENT_OF_FEE, INNER1, args) + assert run_error(SINGLETON, chained) == "user_raise" + wrong_vout = solution( + AMOUNT, 0, 1, TX1, 0, 2, LAUNCH, INNER2, + own_args(OWNER2_SK, TX1, 0, H1, AMOUNT, TX2), + ) # fmt: skip + assert run_error(SINGLETON, wrong_vout) == "user_raise" + + +def test_parent_must_be_a_lineage_coin(): + # Naming the fee input as the parent fails: its own creating + # transaction shows no lineage scriptPubKey. + args = own_args(OWNER2_SK, TX1, 0, H1, AMOUNT, TX2) + sol = solution(AMOUNT, 0, 1, TX1, 1, 0, LAUNCH, INNER2, args) + assert run_error(SINGLETON, sol) == "user_raise" + + +def test_substituted_child_is_dead_and_so_is_the_displaced_one(): + # The state output commits amount and index, so the observer's + # 1-satoshi coin at the committed index fails on amount, and the + # authorized coin moved to index 3 fails on index. The owner's + # seal rejects the re-assembly outright as well. + assert spend_error(SINGLETON, SOL1, SUBSTITUTED) == "unsatisfied_seal_assert" + for index, amount in ((0, 1), (3, AMOUNT)): + sol = solution( + amount, index, 0, SUBSTITUTED, 0, 0, LAUNCH, INNER2, + own_args(OWNER2_SK, SUBSTITUTED, index, H1, amount, TX2), + ) # fmt: skip + assert run_error(SINGLETON, sol) == "user_raise" + + +def test_ended_lineage_cannot_be_refilled(): + # An ending spend claims a state output nothing hashes to. An + # observer's refill adds a coin and a second tagged output, which + # the owner's seal rejects, and the refilled coin itself finds two + # tagged outputs and dies. + assert spend_error(SINGLETON, SOL3, REFILLED) == "unsatisfied_seal_assert" + refill = solution( + 1, 2, 0, REFILLED, 0, 0, TX1, INNER2, + own_args(OWNER2_SK, REFILLED, 2, H1, 1, TX2), + ) # fmt: skip + assert run_error(SINGLETON, refill) == "user_raise" + + +def test_wrong_outpoint_fails_in_validator(): + wrong = tx( + [singleton_input(SPK, ROOT, TX1.txid, 2, AMOUNT), fee_input()], TX2.outputs + ) + assert spend_error(SINGLETON, SOL2, wrong) == "unsatisfied_outpoint_assert" + + +def test_state_must_match_committed_inner(): + # Supplying an inner program the state output does not commit + # raises, and so does a creating transaction with two tagged + # state outputs, which would let its assembler offer two states. + uncommitted = solution( + AMOUNT, 0, 0, LAUNCH, 0, None, None, INNER2, + own_args(OWNER2_SK, LAUNCH, 0, H2, AMOUNT, TX1), + ) # fmt: skip + assert run_error(SINGLETON, uncommitted) == "user_raise" + two_states = solution( + AMOUNT, 0, 0, TWO_STATES, 0, None, None, INNER1, + own_args(OWNER_SK, TWO_STATES, 0, H2, AMOUNT, TX1), + ) # fmt: skip + assert run_error(SINGLETON, two_states) == "user_raise" + + +def first_spend_with(extra, next_amount=AMOUNT): + return solution( + AMOUNT, 0, 0, LAUNCH, 0, None, None, INNER1, + own_args(OWNER_SK, LAUNCH, 0, H2, next_amount, TX1, extra), + ) # fmt: skip + + +SECOND_ODD = proper_list(proper_list(b"\x01", FEE_SPK, int_to_atom(3))) +ODD_TAPROOT = proper_list(proper_list(b"\x02", NUMS, ROOT, int_to_atom(3))) + + +def test_morph_requires_exactly_one_odd_output(): + # No odd output, a second odd CREATE_OUTPUT, and an odd + # CREATE_OUTPUT_TAPROOT at the lineage root all raise: a spend + # creates one odd coin and no more. + assert run_error(SINGLETON, first_spend_with(NIL, 10_000)) == "user_raise" + assert run_error(SINGLETON, first_spend_with(SECOND_ODD)) == "user_raise" + assert run_error(SINGLETON, first_spend_with(ODD_TAPROOT)) == "user_raise" + + +def test_even_amount_raises(): + sol = solution( + 10_000, 0, 0, LAUNCH, 0, None, None, INNER1, + own_args(OWNER_SK, LAUNCH, 0, H2, 10_000, TX1), + ) # fmt: skip + assert run_error(SINGLETON, sol) == "user_raise" + + +TRUNCATED_VERSION = proper_list( + b"\x02\x00\x00", tx_fields(LAUNCH)[1][0], tx_fields(LAUNCH)[1][1][0], b"\x00" * 4 +) +MALFORMED = curry(SINGLETON_NODE, [SINGLETON_MOD_HASH, LAUNCHER[:35]]) + + +def truncated_solution(): + items = list(iter_proper_list(SOL1)) + items[3] = TRUNCATED_VERSION + return proper_list(*items) + + +def test_malformed_instance_and_fields_raise(): + assert run_error(MALFORMED, SOL1) == "user_raise" + assert run_error(SINGLETON, truncated_solution()) == "user_raise" + + +def test_owner_signature_binds_outpoint_and_message(): + # The generation 1 authorization replayed on a later coin whose + # committed state is the same inner program fails on the outpoint + # binding, and the captured signature under a rewritten next state + # fails on the message binding. + args1 = list(iter_proper_list(SOL1))[8] + committed = tx( + TX1.inputs, + (TX1.outputs[0], state_output(LAUNCHER, H1, AMOUNT, 0), TX1.outputs[2]), + ) + later = tx( + [singleton_input(SPK, ROOT, committed.txid, 0, AMOUNT), fee_input()], + TX1.outputs, + ) + replayed = solution(AMOUNT, 0, 0, committed, 0, 0, LAUNCH, INNER1, args1) + assert spend_error(SINGLETON, replayed, later) == "unsatisfied_sig_assert" + captured = list(iter_proper_list(args1))[4] + rewritten = inner_solution( + OWNER_SK, LAUNCH.txid, 0, H1, AMOUNT, committed, sig=captured + ) + sol = solution(AMOUNT, 0, 0, LAUNCH, 0, None, None, INNER1, rewritten) + assert spend_error(SINGLETON, sol, committed) == "unsatisfied_sig_assert" + + +def test_two_lineages_compose(): + other_conds = conditions_of(OTHER, OTHER_SOL) + with_other = tx( + [ + COMPOSED.inputs[0], + singleton_input( + OTHER_SPK, OTHER_ROOT, OTHER_LAUNCH.txid, 0, AMOUNT, other_conds + ), + COMPOSED.inputs[2], + ], + COMPOSED.outputs, + ) + run_spend(SINGLETON, COMPOSED_SOL, with_other, 0) + # Each child reads its own committed index: the other lineage's + # at output 1, with its parent at input 1. + next_sol = solution( + AMOUNT, 1, 0, with_other, 1, 0, OTHER_LAUNCH, INNER2, + own_args(OWNER2_SK, with_other, 1, H1, AMOUNT, TX2), + ) # fmt: skip + conds = conditions_of(OTHER, next_sol) + assert conds[2].outpoint == outpoint(with_other.txid, 1) + + +def load_vector(name): + path = REPO_ROOT / "vectors" / name + return {case["name"]: case for case in json.loads(path.read_text())["cases"]} + + +def vm_cases(): + """Every pinned program and solution, by case name, built from + the sources and the lifecycle above.""" + funded = own_args(OWNER_SK, FUNDED, 0, H2, AMOUNT, TX1) + chained = own_args(OWNER_SK, CHAINED, 0, H2, AMOUNT, TX1) + second = own_args(OWNER2_SK, TX1, 0, H1, AMOUNT, TX2) + return { + "first_spend": (SINGLETON, SOL1), + "second_generation_at_input_one": (SINGLETON, SOL2), + "lineage_ends": (SINGLETON, SOL3), + "second_lineage_composed": (OTHER, OTHER_SOL), + "funded_coin_no_grandparent": ( + SINGLETON, + solution(AMOUNT, 0, 0, FUNDED, 0, None, None, INNER1, funded), + ), + "funded_coin_wrong_grandparent": ( + SINGLETON, + solution(AMOUNT, 0, 0, FUNDED, 0, 3, UNRELATED, INNER1, funded), + ), + "grandparent_shows_ordinary_script": ( + SINGLETON, + solution(AMOUNT, 0, 0, CHAINED, 0, 0, GRANDPARENT_OF_FEE, INNER1, chained), + ), + "grandparent_index_mismatch": ( + SINGLETON, + solution(AMOUNT, 0, 1, TX1, 0, 2, LAUNCH, INNER2, second), + ), + "parent_is_fee_input": ( + SINGLETON, + solution(AMOUNT, 0, 1, TX1, 1, 0, LAUNCH, INNER2, second), + ), + "substituted_child_amount_mismatch": ( + SINGLETON, + solution( + 1, + 0, + 0, + SUBSTITUTED, + 0, + 0, + LAUNCH, + INNER2, + own_args(OWNER2_SK, SUBSTITUTED, 0, H1, 1, TX2), + ), # fmt: skip + ), + "displaced_child_index_mismatch": ( + SINGLETON, + solution( + AMOUNT, + 3, + 0, + SUBSTITUTED, + 0, + 0, + LAUNCH, + INNER2, + own_args(OWNER2_SK, SUBSTITUTED, 3, H1, AMOUNT, TX2), + ), # fmt: skip + ), + "ended_lineage_refill": ( + SINGLETON, + solution( + 1, + 2, + 0, + REFILLED, + 0, + 0, + TX1, + INNER2, + own_args(OWNER2_SK, REFILLED, 2, H1, 1, TX2), + ), # fmt: skip + ), + "uncommitted_inner_program": ( + SINGLETON, + solution( + AMOUNT, + 0, + 0, + LAUNCH, + 0, + None, + None, + INNER2, + own_args(OWNER2_SK, LAUNCH, 0, H2, AMOUNT, TX1), + ), # fmt: skip + ), + "two_state_outputs": ( + SINGLETON, + solution( + AMOUNT, + 0, + 0, + TWO_STATES, + 0, + None, + None, + INNER1, + own_args(OWNER_SK, TWO_STATES, 0, H2, AMOUNT, TX1), + ), # fmt: skip + ), + "inner_creates_no_odd_output": (SINGLETON, first_spend_with(NIL, 10_000)), + "inner_creates_two_odd_outputs": (SINGLETON, first_spend_with(SECOND_ODD)), + "inner_creates_odd_taproot_output": (SINGLETON, first_spend_with(ODD_TAPROOT)), + "even_amount": ( + SINGLETON, + solution( + 10_000, + 0, + 0, + LAUNCH, + 0, + None, + None, + INNER1, + own_args(OWNER_SK, LAUNCH, 0, H2, 10_000, TX1), + ), # fmt: skip + ), + "malformed_launcher_outpoint_unspendable": (MALFORMED, SOL1), + "truncated_version_field": (SINGLETON, truncated_solution()), + } + + +def test_vm_vectors_match_source(): + # Every pinned program and solution is byte-identical to a fresh + # compile, curry, and lifecycle construction, so the corpus + # cannot drift from the sources. + cases = load_vector("vm/singleton-programs.json") + expected = vm_cases() + assert set(cases) == set(expected) + for name, (program, sol) in expected.items(): + assert cases[name]["program"] == serialize(program).hex(), name + assert cases[name]["env"] == serialize(sol).hex(), name + + +def emitted_hex(program, sol): + return serialize(run(program, sol, BUDGET)[1]).hex() + + +def validation_conditions(): + """Every conditions field the validation vector file carries.""" + first = emitted_hex(SINGLETON, SOL1) + sig = list(iter_proper_list(list(iter_proper_list(SOL1))[8]))[4] + flipped = bytes([sig[0] ^ 0x01]) + sig[1:] + return { + first, + first.replace(sig.hex(), flipped.hex()), + emitted_hex(SINGLETON, SOL2), + emitted_hex(SINGLETON, SOL3), + emitted_hex(SINGLETON, COMPOSED_SOL), + emitted_hex(OTHER, OTHER_SOL), + emitted_hex(SINGLETON, first_spend_sealing(CHILD_MISSING)), + emitted_hex(SINGLETON, first_spend_sealing(STATE_MISSING)), + emitted_hex(SINGLETON, ending_spend_sealing(END_STATE_MISSING)), + } + + +def test_validation_vectors_match_source(): + # The complete closure: every conditions field in the validation + # vector file is recomputed here from compiled source and the + # documented signature flip, set-equal in both directions. + observed = set() + for case in load_vector("validation/singleton-lineage.json").values(): + for entry in case["tx"]["inputs"]: + if "conditions" in entry: + observed.add(entry["conditions"]) + assert observed == validation_conditions() diff --git a/vectors/validation/singleton-lineage.json b/vectors/validation/singleton-lineage.json new file mode 100644 index 0000000..606ccdc --- /dev/null +++ b/vectors/validation/singleton-lineage.json @@ -0,0 +1,565 @@ +{ + "schema": "bitlisp-vector-v0", + "suite": "validation", + "spec": "VALIDATION.md rules 1, 2, and 8 and the seal family over CONDITIONS.md entries CREATE_OUTPUT, ASSERT_MY_TAPROOT, ASSERT_MY_AMOUNT, ASSERT_MY_OUTPOINT, ASSERT_SIG_MY_OUTPOINT, and SEAL_OUTPUTS: the singleton lineage", + "cases": [ + { + "name": "first_spend_valid", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "39122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c", + "index": 0, + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c80ffff33ff82271180ffff30ffa439122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c0000000080ffff17ffa0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ffa09d4be366d7fcaca85412243d9bfd8a388bf582c2f8f2abcf64cc35d0e228d47dffc04081da914935d389ea19b7436d7d3e72817f10fd45feea53ac95e641999b944cf4e0e4db64b35c2dff12a73baf6794316055be7544d89d605f3e25a932f1b55f6680ffff61ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6d80ffff01ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873dff82271180ffff01ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb02ff808080", + "tapleaf": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c", + "merkle_root": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001 + }, + { + "script_pubkey": "6a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb02", + "amount": 0 + }, + { + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 40000 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "second_generation_valid", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000, + "sequence": 4294967295 + }, + { + "txid": "5e1c638ff0f2c7e967ca6c9c144a385e4c3157464bb600edf1e08a9006c51705", + "index": 0, + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c80ffff33ff82271180ffff30ffa45e1c638ff0f2c7e967ca6c9c144a385e4c3157464bb600edf1e08a9006c517050000000080ffff17ffa0be8e646242c7c03c5c4a8470eca7308d80724b26214cd6c321480e2c63d513bfffa07d8850ad08df5244f18c9ac7daeea566587f50c0ba778d364a830c23ec3d1ab6ffc040a7716b0e3928d58a3b7081658e63dd658218dd9a719cbb1016aaccf1b915baad99f6bb3da116915f5bcdfa83f4d1592572ed38b60a19c34abdcac9de81edbe6f80ffff61ffa0d12ecf7d4d0e4328d3bd659a512bc4a96cbc169b3fa84333c91a4d2c96b600a180ffff01ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873dff82271180ffff01ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000f66c2f48dc33177818c478f0bce79f2dbbb686964cb29188334d492a7e9c0f9ff808080", + "tapleaf": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c", + "merkle_root": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c" + } + ], + "outputs": [ + { + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 40000 + }, + { + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001 + }, + { + "script_pubkey": "6a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000f66c2f48dc33177818c478f0bce79f2dbbb686964cb29188334d492a7e9c0f9", + "amount": 0 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "lineage_end_valid", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "902f7f3a31e20122395f3e25dd0ab93b2eda65f37de5849c9adfc048700abcc7", + "index": 1, + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c80ffff33ff82271180ffff30ffa4902f7f3a31e20122395f3e25dd0ab93b2eda65f37de5849c9adfc048700abcc70100000080ffff17ffa0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ffa04f82365f9cb3925158978c86a865f23ba3937f02033c58e980742bb8a26ff529ffc0407a075e941b77f70d240840bdf96750a11fb5775781367e68276161523afe291188948296e67eb07be3dded6e679d92b9bfad15121387a43399cf31005c6ed65a80ffff61ffa0cadcbbe7f911a315318ab4796309a10fdcd76012273fde62e47303860bb713c080ffff01ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000000000000000000000000000000000000000000000000000000000000000000ff8080ffff01ff9600142222222222222222222222222222222222222222ff8227108080", + "tapleaf": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c", + "merkle_root": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c" + } + ], + "outputs": [ + { + "script_pubkey": "00142222222222222222222222222222222222222222", + "amount": 10000 + }, + { + "script_pubkey": "6a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000000000000000000000000000000000000000000000000000000000000000000", + "amount": 0 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "fee_input_prepended_valid", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9c9", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000, + "sequence": 4294967295 + }, + { + "txid": "39122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c", + "index": 0, + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c80ffff33ff82271180ffff30ffa439122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c0000000080ffff17ffa0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ffa09d4be366d7fcaca85412243d9bfd8a388bf582c2f8f2abcf64cc35d0e228d47dffc04081da914935d389ea19b7436d7d3e72817f10fd45feea53ac95e641999b944cf4e0e4db64b35c2dff12a73baf6794316055be7544d89d605f3e25a932f1b55f6680ffff61ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6d80ffff01ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873dff82271180ffff01ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb02ff808080", + "tapleaf": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c", + "merkle_root": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001 + }, + { + "script_pubkey": "6a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb02", + "amount": 0 + }, + { + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 40000 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "two_lineages_one_tx_valid", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "39122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c", + "index": 0, + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c80ffff33ff82271180ffff30ffa439122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c0000000080ffff17ffa0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ffa0172405c809a8b623d60b59f69f18cd72ea091e01c56a5bb34c665838e6c8a268ffc04028a3772a4b55bd2a63f35fcb15259ed374240c209802c49b9313485eed788d97fd8742e43ac54d93f22deb7835d018ebfde743831670595bad6c5a3818bf28d980ffff61ffa03cb88455896d6a25df79e0c34bceaf7e08087ea9bbb1731a4cfe5215d7254e4480ffff01ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873dff82271180ffff01ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb02ff808080", + "tapleaf": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c", + "merkle_root": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c" + }, + { + "txid": "077fdf02a5070f2236242398ad1bdb6f75f17db127e0153bc3288b9704c54300", + "index": 0, + "script_pubkey": "5120485a1da19773af06c567b87cb1db30092cd4732575a801a25c7afe983a56c4dc", + "amount": 10001, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa01156648b85de76a431e4a9f32e56d478c56067e9ec0c4e5d7ead959ee1266cfb80ffff33ff82271180ffff30ffa4077fdf02a5070f2236242398ad1bdb6f75f17db127e0153bc3288b9704c543000000000080ffff17ffa0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ffa0172405c809a8b623d60b59f69f18cd72ea091e01c56a5bb34c665838e6c8a268ffc040e32ac7111ac1b0c29c8b7576f949549193b3fff199dd70d571d666f767b7336b2b24a292226776ca445e5f4d99e89a29b8191240df3346643f1bd9a1eb5f0d8680ffff61ffa03cb88455896d6a25df79e0c34bceaf7e08087ea9bbb1731a4cfe5215d7254e4480ffff01ffa25120485a1da19773af06c567b87cb1db30092cd4732575a801a25c7afe983a56c4dcff82271180ffff01ffc0466a44a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1010000003fe662881b40339972ff027cffb188343e15b7a4bb467d77cf2940d152042c02ff808080", + "tapleaf": "1156648b85de76a431e4a9f32e56d478c56067e9ec0c4e5d7ead959ee1266cfb", + "merkle_root": "1156648b85de76a431e4a9f32e56d478c56067e9ec0c4e5d7ead959ee1266cfb" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001 + }, + { + "script_pubkey": "5120485a1da19773af06c567b87cb1db30092cd4732575a801a25c7afe983a56c4dc", + "amount": 10001 + }, + { + "script_pubkey": "6a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb02", + "amount": 0 + }, + { + "script_pubkey": "6a44a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1010000003fe662881b40339972ff027cffb188343e15b7a4bb467d77cf2940d152042c02", + "amount": 0 + }, + { + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 40000 + } + ] + }, + "expect": { + "valid": true + } + }, + { + "name": "coin_at_wrong_outpoint", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "5e1c638ff0f2c7e967ca6c9c144a385e4c3157464bb600edf1e08a9006c51705", + "index": 2, + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c80ffff33ff82271180ffff30ffa45e1c638ff0f2c7e967ca6c9c144a385e4c3157464bb600edf1e08a9006c517050000000080ffff17ffa0be8e646242c7c03c5c4a8470eca7308d80724b26214cd6c321480e2c63d513bfffa07d8850ad08df5244f18c9ac7daeea566587f50c0ba778d364a830c23ec3d1ab6ffc040a7716b0e3928d58a3b7081658e63dd658218dd9a719cbb1016aaccf1b915baad99f6bb3da116915f5bcdfa83f4d1592572ed38b60a19c34abdcac9de81edbe6f80ffff61ffa0d12ecf7d4d0e4328d3bd659a512bc4a96cbc169b3fa84333c91a4d2c96b600a180ffff01ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873dff82271180ffff01ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000f66c2f48dc33177818c478f0bce79f2dbbb686964cb29188334d492a7e9c0f9ff808080", + "tapleaf": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c", + "merkle_root": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 40000 + }, + { + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001 + }, + { + "script_pubkey": "6a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000f66c2f48dc33177818c478f0bce79f2dbbb686964cb29188334d492a7e9c0f9", + "amount": 0 + } + ] + }, + "expect": { + "error": "unsatisfied_outpoint_assert" + } + }, + { + "name": "child_output_missing", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "39122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c", + "index": 0, + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c80ffff33ff82271180ffff30ffa439122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c0000000080ffff17ffa0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ffa08a96d0894f32453ed87c3a0d30715b55793f602ff2b48405875d85996ec15c87ffc0403b5aad08ab070f8be37e6ee43cd3c9cea27344d576b604a946e7256771e288bd3b5dd5023b252795d7c2b10073e3050a1c38f2b5ebd1b98b0488e49f7b4a985c80ffff61ffa05be183e173273fbab1671edce3847fbcda5a93e2205990a6c6e1324df57f9a6780ffff01ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873dff82271180ffff01ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb02ff808080", + "tapleaf": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c", + "merkle_root": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "6a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb02", + "amount": 0 + }, + { + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000 + } + ] + }, + "expect": { + "error": "unsatisfied_output_claim" + } + }, + { + "name": "state_output_missing", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "39122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c", + "index": 0, + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c80ffff33ff82271180ffff30ffa439122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c0000000080ffff17ffa0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ffa05fb3581f6f2a705e415b73b6f684fcd3e3ec98cc771c13e5b23ac1e0358c6aa3ffc0408504a31cfcfafcd35ba8c881d7f3c72371916f824daa79a5275ca2317579b77157fc473fc9957740d1de12122387cbb2fb06d2dd5b4912b4ab93ed4fd60ca5f480ffff61ffa08da9a060b32e2c1d5d731cad06af067d0f5f2ab9989a3058e8b547cbd1b9deb680ffff01ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873dff82271180ffff01ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb02ff808080", + "tapleaf": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c", + "merkle_root": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001 + }, + { + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 40000 + } + ] + }, + "expect": { + "error": "unsatisfied_output_claim" + } + }, + { + "name": "outputs_reordered_fails_seal", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "39122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c", + "index": 0, + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c80ffff33ff82271180ffff30ffa439122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c0000000080ffff17ffa0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ffa09d4be366d7fcaca85412243d9bfd8a388bf582c2f8f2abcf64cc35d0e228d47dffc04081da914935d389ea19b7436d7d3e72817f10fd45feea53ac95e641999b944cf4e0e4db64b35c2dff12a73baf6794316055be7544d89d605f3e25a932f1b55f6680ffff61ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6d80ffff01ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873dff82271180ffff01ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb02ff808080", + "tapleaf": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c", + "merkle_root": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "6a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb02", + "amount": 0 + }, + { + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001 + }, + { + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 40000 + } + ] + }, + "expect": { + "error": "unsatisfied_seal_assert" + } + }, + { + "name": "substituted_child_fails_seal", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "39122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c", + "index": 0, + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c80ffff33ff82271180ffff30ffa439122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c0000000080ffff17ffa0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ffa09d4be366d7fcaca85412243d9bfd8a388bf582c2f8f2abcf64cc35d0e228d47dffc04081da914935d389ea19b7436d7d3e72817f10fd45feea53ac95e641999b944cf4e0e4db64b35c2dff12a73baf6794316055be7544d89d605f3e25a932f1b55f6680ffff61ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6d80ffff01ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873dff82271180ffff01ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb02ff808080", + "tapleaf": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c", + "merkle_root": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 1 + }, + { + "script_pubkey": "6a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb02", + "amount": 0 + }, + { + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 40000 + }, + { + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001 + } + ] + }, + "expect": { + "error": "unsatisfied_seal_assert" + } + }, + { + "name": "ended_lineage_refill_fails_seal", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "902f7f3a31e20122395f3e25dd0ab93b2eda65f37de5849c9adfc048700abcc7", + "index": 1, + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c80ffff33ff82271180ffff30ffa4902f7f3a31e20122395f3e25dd0ab93b2eda65f37de5849c9adfc048700abcc70100000080ffff17ffa0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ffa04f82365f9cb3925158978c86a865f23ba3937f02033c58e980742bb8a26ff529ffc0407a075e941b77f70d240840bdf96750a11fb5775781367e68276161523afe291188948296e67eb07be3dded6e679d92b9bfad15121387a43399cf31005c6ed65a80ffff61ffa0cadcbbe7f911a315318ab4796309a10fdcd76012273fde62e47303860bb713c080ffff01ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000000000000000000000000000000000000000000000000000000000000000000ff8080ffff01ff9600142222222222222222222222222222222222222222ff8227108080", + "tapleaf": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c", + "merkle_root": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "00142222222222222222222222222222222222222222", + "amount": 10000 + }, + { + "script_pubkey": "6a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000000000000000000000000000000000000000000000000000000000000000000", + "amount": 0 + }, + { + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 1 + }, + { + "script_pubkey": "6a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0000000027e8eaeadd89d0bfa33045295c1f70a98fe429e8f7fb91882b98a651c6445fef", + "amount": 0 + } + ] + }, + "expect": { + "error": "unsatisfied_seal_assert" + } + }, + { + "name": "ending_state_output_missing", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "902f7f3a31e20122395f3e25dd0ab93b2eda65f37de5849c9adfc048700abcc7", + "index": 1, + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c80ffff33ff82271180ffff30ffa4902f7f3a31e20122395f3e25dd0ab93b2eda65f37de5849c9adfc048700abcc70100000080ffff17ffa0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ffa0e54a2f808c5f3d031e47f7c1bab76b0e351286e4ffcf12a7e588ab9632aca073ffc040e62933c09694356c7a64eedeccb83cfe8e4e06adaa6e4f90fb002ad43da90194059443ac495937ee68f459b66ab38db3b8098871003c263f0a6a48862c7f51ed80ffff61ffa0d3115aa658a3ca049d0b27f42a17a083c633478f194785be3db619677b762da080ffff01ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000000000000000000000000000000000000000000000000000000000000000000ff8080ffff01ff9600142222222222222222222222222222222222222222ff8227108080", + "tapleaf": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c", + "merkle_root": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c" + } + ], + "outputs": [ + { + "script_pubkey": "00142222222222222222222222222222222222222222", + "amount": 10000 + } + ] + }, + "expect": { + "error": "unsatisfied_output_claim" + } + }, + { + "name": "owner_signature_invalid", + "tx": { + "version": 2, + "locktime": 0, + "inputs": [ + { + "txid": "39122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c", + "index": 0, + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001, + "sequence": 4294967295, + "conditions": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c80ffff33ff82271180ffff30ffa439122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c0000000080ffff17ffa0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ffa09d4be366d7fcaca85412243d9bfd8a388bf582c2f8f2abcf64cc35d0e228d47dffc04080da914935d389ea19b7436d7d3e72817f10fd45feea53ac95e641999b944cf4e0e4db64b35c2dff12a73baf6794316055be7544d89d605f3e25a932f1b55f6680ffff61ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6d80ffff01ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873dff82271180ffff01ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb02ff808080", + "tapleaf": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c", + "merkle_root": "d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c" + }, + { + "txid": "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", + "index": 0, + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 50000, + "sequence": 4294967295 + } + ], + "outputs": [ + { + "script_pubkey": "5120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d", + "amount": 10001 + }, + { + "script_pubkey": "6a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb02", + "amount": 0 + }, + { + "script_pubkey": "00141111111111111111111111111111111111111111", + "amount": 40000 + } + ] + }, + "expect": { + "error": "unsatisfied_sig_assert" + } + } + ] +} diff --git a/vectors/vm/singleton-programs.json b/vectors/vm/singleton-programs.json new file mode 100644 index 0000000..033f997 --- /dev/null +++ b/vectors/vm/singleton-programs.json @@ -0,0 +1,171 @@ +{ + "schema": "bitlisp-vector-v0", + "suite": "vm", + "spec": "VM.md sections 3 and 4: the singleton wrapper benchmark program, compiled and curried, the lifecycle spends with the in-program lineage, state, and morph failures", + "cases": [ + { + "name": "first_spend", + "program": "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", + "env": "ff822711ff80ff80ffff8402000000ffffffa4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d80ffff888038010000000000ff96001411111111111111111111111111111111111111118080ff840000000080ff80ff80ff80ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ff018080ffffa0842c1702f4e63eace8b5f668fcfde3b8bd0d9de05af510a7ce5cf6c9e6f90f52ff822711ff80ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6dffc04081da914935d389ea19b7436d7d3e72817f10fd45feea53ac95e641999b944cf4e0e4db64b35c2dff12a73baf6794316055be7544d89d605f3e25a932f1b55f668080", + "expect": { + "result": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c80ffff33ff82271180ffff30ffa439122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c0000000080ffff17ffa0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ffa09d4be366d7fcaca85412243d9bfd8a388bf582c2f8f2abcf64cc35d0e228d47dffc04081da914935d389ea19b7436d7d3e72817f10fd45feea53ac95e641999b944cf4e0e4db64b35c2dff12a73baf6794316055be7544d89d605f3e25a932f1b55f6680ffff61ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6d80ffff01ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873dff82271180ffff01ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb02ff808080", + "cost": 166937 + } + }, + { + "name": "second_generation_at_input_one", + "program": "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", + "env": "ff822711ff80ff01ffff8402000000ffffffa439122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c00000000ff80ff84ffffffff80ffffa4bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb0280ffff88409c000000000000ff96001411111111111111111111111111111111111111118080ff840000000080ff80ff80ffff8402000000ffffffa4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d80ffff888038010000000000ff96001411111111111111111111111111111111111111118080ff840000000080ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0be8e646242c7c03c5c4a8470eca7308d80724b26214cd6c321480e2c63d513bfff018080ffffa0f23ab4ffc61f1b234916e8a9af63581abae530e23129ade927dcd57d87410021ff822711ff80ffa0d12ecf7d4d0e4328d3bd659a512bc4a96cbc169b3fa84333c91a4d2c96b600a1ffc040a7716b0e3928d58a3b7081658e63dd658218dd9a719cbb1016aaccf1b915baad99f6bb3da116915f5bcdfa83f4d1592572ed38b60a19c34abdcac9de81edbe6f8080", + "expect": { + "result": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c80ffff33ff82271180ffff30ffa45e1c638ff0f2c7e967ca6c9c144a385e4c3157464bb600edf1e08a9006c517050000000080ffff17ffa0be8e646242c7c03c5c4a8470eca7308d80724b26214cd6c321480e2c63d513bfffa07d8850ad08df5244f18c9ac7daeea566587f50c0ba778d364a830c23ec3d1ab6ffc040a7716b0e3928d58a3b7081658e63dd658218dd9a719cbb1016aaccf1b915baad99f6bb3da116915f5bcdfa83f4d1592572ed38b60a19c34abdcac9de81edbe6f80ffff61ffa0d12ecf7d4d0e4328d3bd659a512bc4a96cbc169b3fa84333c91a4d2c96b600a180ffff01ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873dff82271180ffff01ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000f66c2f48dc33177818c478f0bce79f2dbbb686964cb29188334d492a7e9c0f9ff808080", + "cost": 244898 + } + }, + { + "name": "lineage_ends", + "program": "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", + "env": "ff822711ff01ff80ffff8402000000ffffffa4cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc00000000ff80ff84ffffffff80ffffa45e1c638ff0f2c7e967ca6c9c144a385e4c3157464bb600edf1e08a9006c5170500000000ff80ff84ffffffff8080ffffff88409c000000000000ff960014111111111111111111111111111111111111111180ffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000f66c2f48dc33177818c478f0bce79f2dbbb686964cb29188334d492a7e9c0f98080ff840000000080ff01ff80ffff8402000000ffffffa439122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c00000000ff80ff84ffffffff80ffffa4bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb0280ffff88409c000000000000ff96001411111111111111111111111111111111111111118080ff840000000080ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ff018080ffff80ff818fffffff01ff9600142222222222222222222222222222222222222222ff8227108080ffa0cadcbbe7f911a315318ab4796309a10fdcd76012273fde62e47303860bb713c0ffc0407a075e941b77f70d240840bdf96750a11fb5775781367e68276161523afe291188948296e67eb07be3dded6e679d92b9bfad15121387a43399cf31005c6ed65a8080", + "expect": { + "result": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5c80ffff33ff82271180ffff30ffa4902f7f3a31e20122395f3e25dd0ab93b2eda65f37de5849c9adfc048700abcc70100000080ffff17ffa0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ffa04f82365f9cb3925158978c86a865f23ba3937f02033c58e980742bb8a26ff529ffc0407a075e941b77f70d240840bdf96750a11fb5775781367e68276161523afe291188948296e67eb07be3dded6e679d92b9bfad15121387a43399cf31005c6ed65a80ffff61ffa0cadcbbe7f911a315318ab4796309a10fdcd76012273fde62e47303860bb713c080ffff01ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000000000000000000000000000000000000000000000000000000000000000000ff8080ffff01ff9600142222222222222222222222222222222222222222ff8227108080", + "cost": 261997 + } + }, + { + "name": "second_lineage_composed", + "program": "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", + "env": "ff822711ff80ff01ffff8402000000ffffffa4a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a101000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120485a1da19773af06c567b87cb1db30092cd4732575a801a25c7afe983a56c4dc80ffff880000000000000000ffc0466a44a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a101000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d80ffff888038010000000000ff96001411111111111111111111111111111111111111118080ff840000000080ff80ff80ff80ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ff018080ffffa0842c1702f4e63eace8b5f668fcfde3b8bd0d9de05af510a7ce5cf6c9e6f90f52ff822711ff80ffa03cb88455896d6a25df79e0c34bceaf7e08087ea9bbb1731a4cfe5215d7254e44ffc040e32ac7111ac1b0c29c8b7576f949549193b3fff199dd70d571d666f767b7336b2b24a292226776ca445e5f4d99e89a29b8191240df3346643f1bd9a1eb5f0d868080", + "expect": { + "result": "ffff37ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa01156648b85de76a431e4a9f32e56d478c56067e9ec0c4e5d7ead959ee1266cfb80ffff33ff82271180ffff30ffa4077fdf02a5070f2236242398ad1bdb6f75f17db127e0153bc3288b9704c543000000000080ffff17ffa0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ffa0172405c809a8b623d60b59f69f18cd72ea091e01c56a5bb34c665838e6c8a268ffc040e32ac7111ac1b0c29c8b7576f949549193b3fff199dd70d571d666f767b7336b2b24a292226776ca445e5f4d99e89a29b8191240df3346643f1bd9a1eb5f0d8680ffff61ffa03cb88455896d6a25df79e0c34bceaf7e08087ea9bbb1731a4cfe5215d7254e4480ffff01ffa25120485a1da19773af06c567b87cb1db30092cd4732575a801a25c7afe983a56c4dcff82271180ffff01ffc0466a44a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1a1010000003fe662881b40339972ff027cffb188343e15b7a4bb467d77cf2940d152042c02ff808080", + "cost": 166939 + } + }, + { + "name": "funded_coin_no_grandparent", + "program": "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", + "env": "ff822711ff80ff80ffff8402000000ffffffa4eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee03000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d8080ff840000000080ff80ff80ff80ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ff018080ffffa0842c1702f4e63eace8b5f668fcfde3b8bd0d9de05af510a7ce5cf6c9e6f90f52ff822711ff80ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6dffc04066f06a93c253929f8c7fd274956ad337c5f28224942a6070910ef51145bd02250503f2ac426768d7f14caae1a44edd4fb4b0a069cdd410847214c1586366cb208080", + "expect": { + "error": "user_raise" + } + }, + { + "name": "funded_coin_wrong_grandparent", + "program": "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", + "env": "ff822711ff80ff80ffff8402000000ffffffa4eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee03000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d8080ff840000000080ff80ff03ffff8402000000ffffffa4edededededededededededededededededededededededededededededededed00000000ff80ff84ffffffff8080ffffff88a086010000000000ff960014111111111111111111111111111111111111111180ffff88a086010000000000ff960014111111111111111111111111111111111111111180ffff88a086010000000000ff960014111111111111111111111111111111111111111180ffff88a086010000000000ff96001411111111111111111111111111111111111111118080ff840000000080ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ff018080ffffa0842c1702f4e63eace8b5f668fcfde3b8bd0d9de05af510a7ce5cf6c9e6f90f52ff822711ff80ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6dffc04066f06a93c253929f8c7fd274956ad337c5f28224942a6070910ef51145bd02250503f2ac426768d7f14caae1a44edd4fb4b0a069cdd410847214c1586366cb208080", + "expect": { + "error": "user_raise" + } + }, + { + "name": "grandparent_shows_ordinary_script", + "program": "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", + "env": "ff822711ff80ff80ffff8402000000ffffffa438fa807228e37a99b1e53f108909779cc0900f91875f68c0f1fc680bd5a4d50400000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d8080ff840000000080ff80ff80ffff8402000000ffffffa4dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd00000000ff80ff84ffffffff8080ffffff8860ea000000000000ff96001411111111111111111111111111111111111111118080ff840000000080ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ff018080ffffa0842c1702f4e63eace8b5f668fcfde3b8bd0d9de05af510a7ce5cf6c9e6f90f52ff822711ff80ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6dffc04049dfd89d9b193335682fa446c63bd3ba30d997f96c6623ebf064be9dcdebfc8e1ace116a3d8ff441fb72329c1d6fc313b5f53a1ee384e14acc88aa0bf8be94768080", + "expect": { + "error": "user_raise" + } + }, + { + "name": "grandparent_index_mismatch", + "program": "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", + "env": "ff822711ff80ff01ffff8402000000ffffffa439122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c00000000ff80ff84ffffffff80ffffa4bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb0280ffff88409c000000000000ff96001411111111111111111111111111111111111111118080ff840000000080ff80ff02ffff8402000000ffffffa4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d80ffff888038010000000000ff96001411111111111111111111111111111111111111118080ff840000000080ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0be8e646242c7c03c5c4a8470eca7308d80724b26214cd6c321480e2c63d513bfff018080ffffa0f23ab4ffc61f1b234916e8a9af63581abae530e23129ade927dcd57d87410021ff822711ff80ffa0d12ecf7d4d0e4328d3bd659a512bc4a96cbc169b3fa84333c91a4d2c96b600a1ffc040a7716b0e3928d58a3b7081658e63dd658218dd9a719cbb1016aaccf1b915baad99f6bb3da116915f5bcdfa83f4d1592572ed38b60a19c34abdcac9de81edbe6f8080", + "expect": { + "error": "user_raise" + } + }, + { + "name": "parent_is_fee_input", + "program": "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", + "env": "ff822711ff80ff01ffff8402000000ffffffa439122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c00000000ff80ff84ffffffff80ffffa4bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb0280ffff88409c000000000000ff96001411111111111111111111111111111111111111118080ff840000000080ff01ff80ffff8402000000ffffffa4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d80ffff888038010000000000ff96001411111111111111111111111111111111111111118080ff840000000080ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0be8e646242c7c03c5c4a8470eca7308d80724b26214cd6c321480e2c63d513bfff018080ffffa0f23ab4ffc61f1b234916e8a9af63581abae530e23129ade927dcd57d87410021ff822711ff80ffa0d12ecf7d4d0e4328d3bd659a512bc4a96cbc169b3fa84333c91a4d2c96b600a1ffc040a7716b0e3928d58a3b7081658e63dd658218dd9a719cbb1016aaccf1b915baad99f6bb3da116915f5bcdfa83f4d1592572ed38b60a19c34abdcac9de81edbe6f8080", + "expect": { + "error": "user_raise" + } + }, + { + "name": "substituted_child_amount_mismatch", + "program": "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", + "env": "ff01ff80ff80ffff8402000000ffffffa439122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c00000000ff80ff84ffffffff80ffffa4bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb00000000ff80ff84ffffffff8080ffffff880100000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb0280ffff88409c000000000000ff960014111111111111111111111111111111111111111180ffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d8080ff840000000080ff80ff80ffff8402000000ffffffa4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d80ffff888038010000000000ff96001411111111111111111111111111111111111111118080ff840000000080ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0be8e646242c7c03c5c4a8470eca7308d80724b26214cd6c321480e2c63d513bfff018080ffffa0f23ab4ffc61f1b234916e8a9af63581abae530e23129ade927dcd57d87410021ff01ff80ffa0d12ecf7d4d0e4328d3bd659a512bc4a96cbc169b3fa84333c91a4d2c96b600a1ffc040eb1d428ac2425c3bd318507e45b8fb7d1150cda4917315f05f7f95dfb6b252a04d0cefdf3abe7ad6d8f23d5092b1fb5522691839e058ac8b86f7c63a5ffa27018080", + "expect": { + "error": "user_raise" + } + }, + { + "name": "displaced_child_index_mismatch", + "program": "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", + "env": "ff822711ff03ff80ffff8402000000ffffffa439122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c00000000ff80ff84ffffffff80ffffa4bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb00000000ff80ff84ffffffff8080ffffff880100000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb0280ffff88409c000000000000ff960014111111111111111111111111111111111111111180ffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d8080ff840000000080ff80ff80ffff8402000000ffffffa4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d80ffff888038010000000000ff96001411111111111111111111111111111111111111118080ff840000000080ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0be8e646242c7c03c5c4a8470eca7308d80724b26214cd6c321480e2c63d513bfff018080ffffa0f23ab4ffc61f1b234916e8a9af63581abae530e23129ade927dcd57d87410021ff822711ff80ffa0d12ecf7d4d0e4328d3bd659a512bc4a96cbc169b3fa84333c91a4d2c96b600a1ffc0404d6f5c7794bbfc2a49131f435312503542e2e8a4f394ebdf5c7caf0e38bc28ae71e65570282a2ef8f24c90c1e618733cca5fb9de4318cf44944ccbf1168f71748080", + "expect": { + "error": "user_raise" + } + }, + { + "name": "ended_lineage_refill", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff0580ffff012080ffff01ff02ffff03ffff09ffff0dff0b80ffff012480ffff01ff02ffff03ffff18ff17ffff010180ffff01ff02ff7effff04ff02ffff04ff0bffff04ffff02ff2affff04ff02ffff04ff05ffff04ff0bff8080808080ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8202ffffff04ff8205ffffff04ff820bffffff04ff8217ffff8080808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff20ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff20ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ffff03ff05ffff01ff10ffff0101ffff02ff28ffff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ff02ffff03ff0bffff01ff02ff38ffff04ff02ffff04ffff06ff0580ffff04ffff11ff0bffff010180ff8080808080ffff01ff05ff058080ff0180ffffff02ffff03ff0bffff01ff0effff0cffff10ffff01820100ffff18ff05ffff018200ff8080ffff0101ffff010280ffff02ff24ffff04ff02ffff04ffff16ff05ffff0181f880ffff04ffff11ff0bffff010180ff808080808080ffff018080ff0180ff02ffff03ffff15ffff018200fdff0580ffff01ff0cffff10ffff01820100ff0580ffff0101ffff010280ffff01ff02ffff03ffff15ffff0183010000ff0580ffff01ff0effff0181fdffff02ff24ffff04ff02ffff04ff05ffff04ffff0102ff808080808080ffff01ff02ffff03ffff15ffff01850100000000ff0580ffff01ff0effff0181feffff02ff24ffff04ff02ffff04ff05ffff04ffff0104ff808080808080ffff01ff0effff0181ffffff02ff24ffff04ff02ffff04ff05ffff04ffff0108ff80808080808080ff018080ff018080ff0180ffff02ffff03ffff09ffff0dff0980ffff012480ffff01ff02ffff03ffff09ffff0dff2d80ffff010480ffff01ff0eff09ffff02ff34ffff04ff02ffff04ffff0dff1580ff80808080ff15ff2d80ffff01ff088080ff0180ffff01ff088080ff0180ffff02ffff03ff05ffff01ff0effff02ff2cffff04ff02ffff04ffff05ff0580ff80808080ffff02ff5cffff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ff02ffff03ffff09ffff0dff0980ffff010880ffff01ff0eff09ffff02ff34ffff04ff02ffff04ffff0dff1580ff80808080ff1580ffff01ff088080ff0180ffffffff02ffff03ff05ffff01ff0effff02ff7cffff04ff02ffff04ffff05ff0580ff80808080ffff02ff22ffff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ff02ffff03ffff09ffff0dff0980ffff010480ffff01ff02ffff03ffff09ffff0dff5d80ffff010480ffff01ff02ffff03ff15ffff01ff02ffff03ff2dffff01ff0eff09ffff02ff34ffff04ff02ffff04ffff02ff28ffff04ff02ffff04ff15ff80808080ff80808080ffff02ff5cffff04ff02ffff04ff15ff80808080ffff02ff34ffff04ff02ffff04ffff02ff28ffff04ff02ffff04ff2dff80808080ff80808080ffff02ff22ffff04ff02ffff04ff2dff80808080ff5d80ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff02ff30ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ff808080ff8080808080ffff02ffff03ffff09ff17ff0580ffff01ff0101ffff01ff02ffff03ffff07ff5f80ffff01ff02ffff03ffff09ffff0cff17ff80ffff012080ffff0bffff0bffff02ff32ffff04ff02ffff04ff5fff80808080808080ffff01ff02ffff03ffff09ffff0cff17ffff0120ffff012480ffff02ff24ffff04ff02ffff04ff2fffff04ffff0104ff808080808080ffff01ff02ffff03ffff09ffff05ffff06ffff02ff38ffff04ff02ffff04ffff05ffff06ffff06ff5f808080ffff04ff2fff80808080808080ff0b80ffff01ff0101ffff018080ff0180ffff018080ff0180ffff018080ff0180ffff018080ff018080ff0180ff02ffff03ff05ffff01ff02ffff03ffff02ffff03ffff20ffff15ffff0126ffff0dffff05ffff06ffff05ff05808080808080ffff01ff02ffff03ffff09ffff0cffff05ffff06ffff05ff05808080ff80ffff012680ff0b80ffff01ff0101ffff018080ff0180ffff018080ff0180ffff01ff04ffff05ffff06ffff05ff05808080ffff02ff7affff04ff02ffff04ffff06ff0580ffff04ff0bff808080808080ffff01ff02ff7affff04ff02ffff04ffff06ff0580ffff04ff0bff808080808080ff0180ffff018080ff0180ffffff02ffff03ff05ffff01ff02ffff03ffff20ffff06ff058080ffff01ff02ffff03ffff09ffff05ff0580ff0b80ffff01ff0101ffff018080ff0180ffff018080ff0180ffff018080ff0180ff02ffff03ff2fffff01ff02ff2effff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ffff05ff2f80ffff04ffff06ff2f80ffff04ff5fffff04ffff18ffff02ffff03ffff09ffff05ffff05ff2f8080ffff010180ffff01ff05ffff06ffff06ffff05ff2f80808080ffff01ff02ffff03ffff09ffff05ffff05ff2f8080ffff010280ffff01ff05ffff06ffff06ffff06ffff05ff2f8080808080ffff018080ff018080ff0180ffff010180ff80808080808080808080ffff01ff02ffff03ff5fffff0180ffff01ff088080ff018080ff0180ffff02ffff03ff82017fffff01ff02ffff03ffff20ff8200bf80ffff01ff02ffff03ffff09ffff05ff2f80ffff010180ffff01ff02ffff03ffff09ffff05ffff06ffff06ff2f808080ffff01818f80ffff01ff04ffff04ffff0101ffff04ffff0effff0effff01826a44ff0580ffff01a0000000000000000000000000000000000000000000000000000000000000000080ffff04ff80ff80808080ffff02ff36ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff5fffff04ffff0101ff808080808080808080ffff01ff02ffff03ffff09ffff0dffff05ffff06ff2f808080ffff012080ffff01ff04ffff04ffff0101ffff04ff0bffff04ffff05ffff06ffff06ff2f808080ff80808080ffff04ffff04ffff0101ffff04ffff0effff0effff01826a44ff0580ffff3fffff04ffff05ffff06ff2f8080ffff04ffff05ffff06ffff06ff2f808080ffff04ff17ff808080808080ffff04ff80ff80808080ffff02ff36ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff5fffff04ffff0101ff80808080808080808080ffff01ff088080ff018080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff04ff2fffff02ff36ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff5fffff04ff8200bfff80808080808080808080ff0180ffff02ffff03ff8202ffffff01ff02ffff03ffff02ff26ffff04ff02ffff04ff8205ffffff04ffff0effff0effff01826a44ff0580ffff3fffff04ff8217ffffff04ff2fffff04ff5fff808080808080ff8080808080ffff01ff04ffff04ffff0137ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff2fff808080ffff04ffff04ffff0130ffff04ff82017fff808080ffff02ff36ffff04ff02ffff04ff05ffff04ff17ffff04ff8200bfffff04ffff02ff820bffffff04ffff04ff05ffff04ff82017fffff04ff17ffff04ff2fffff04ff8217ffff808080808080ff822fff8080ffff04ff80ff8080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ff5effff04ff02ffff04ff05ffff04ff0bffff04ffff05ffff06ffff02ff38ffff04ff02ffff04ffff05ffff06ffff06ff8200bf808080ffff04ff2fff80808080808080ffff04ff17ffff04ff2fffff04ff5fffff04ffff0effff0bffff0bffff02ff32ffff04ff02ffff04ff8200bfff808080808080ffff02ff24ffff04ff02ffff04ff2fffff04ffff0104ff808080808080ffff04ffff02ff5affff04ff02ffff04ff05ffff04ffff05ffff06ffff02ff38ffff04ff02ffff04ffff05ffff06ffff06ff8200bf808080ffff04ff2fff80808080808080ffff04ffff05ffff02ff38ffff04ff02ffff04ffff05ffff06ff8200bf8080ffff04ff82017fff808080808080ffff04ff8202ffffff04ff8205ffff8080808080808080ffff04ffff02ff7affff04ff02ffff04ffff05ffff06ffff06ff8200bf808080ffff04ffff0effff01826a44ff0580ff8080808080ffff04ff820bffffff04ffff3fff820bff80ffff04ff8217ffff808080808080808080808080808080ff018080ffff04ffff01a01d8a1a3714577ac5cee67abe6ae1a6972d29ba24ea0c599205f2f0069e943f83ffff04ffff01a4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000ff01808080", + "env": "ff01ff02ff80ffff8402000000ffffffa4902f7f3a31e20122395f3e25dd0ab93b2eda65f37de5849c9adfc048700abcc701000000ff80ff84ffffffff80ffffa4bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb00000000ff80ff84ffffffff8080ffffff881027000000000000ff960014222222222222222222222222222222222222222280ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000000000000000000000000000000000000000000000000000000000000000000080ffff880100000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa0000000027e8eaeadd89d0bfa33045295c1f70a98fe429e8f7fb91882b98a651c6445fef8080ff840000000080ff80ff80ffff8402000000ffffffa439122d32fdad7f7d1406817d0a4f24bdd1cf7e2e47beb0688b9f2a57440a5b3c00000000ff80ff84ffffffff80ffffa4bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb0280ffff88409c000000000000ff96001411111111111111111111111111111111111111118080ff840000000080ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0be8e646242c7c03c5c4a8470eca7308d80724b26214cd6c321480e2c63d513bfff018080ffffa0f23ab4ffc61f1b234916e8a9af63581abae530e23129ade927dcd57d87410021ff01ff80ffa0d12ecf7d4d0e4328d3bd659a512bc4a96cbc169b3fa84333c91a4d2c96b600a1ffc040dfdea911a337102fb63e1b896326c8d98ba89f5c84301e2cb281b045bdf7064a88c34f1574b3cc11f0711d3d22738420c28ef1a3b1c7e9d3e96fa7a931e2a5c78080", + "expect": { + "error": "user_raise" + } + }, + { + "name": "uncommitted_inner_program", + "program": "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", + "env": "ff822711ff80ff80ffff8402000000ffffffa4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d80ffff888038010000000000ff96001411111111111111111111111111111111111111118080ff840000000080ff80ff80ff80ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0be8e646242c7c03c5c4a8470eca7308d80724b26214cd6c321480e2c63d513bfff018080ffffa0842c1702f4e63eace8b5f668fcfde3b8bd0d9de05af510a7ce5cf6c9e6f90f52ff822711ff80ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6dffc040b52d9eafb806664f5d8fe85a94dfee24e9ba82fc0229d656aa5dd93afda6fb56fa5075c0c70bff04b022bff7cc7853ae68129f5871bd586265bcd40bba07d9c28080", + "expect": { + "error": "user_raise" + } + }, + { + "name": "two_state_outputs", + "program": "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", + "env": "ff822711ff80ff80ffff8402000000ffffffa4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d80ffff888038010000000000ff960014111111111111111111111111111111111111111180ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa000000000d37b3d1841540677697f67e014b8679549b970e8535f9f01e1c68dd151fcb028080ff840000000080ff80ff80ff80ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ff018080ffffa0842c1702f4e63eace8b5f668fcfde3b8bd0d9de05af510a7ce5cf6c9e6f90f52ff822711ff80ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6dffc04080007711ec1f63e9afdad6f8a18e9b3450a664817107bb0d37e4840ab945ac60a5401b8037c01f6b0e9daeef1d56cc7f83542acee096f4d8410b5d396efa70518080", + "expect": { + "error": "user_raise" + } + }, + { + "name": "inner_creates_no_odd_output", + "program": "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", + "env": "ff822711ff80ff80ffff8402000000ffffffa4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d80ffff888038010000000000ff96001411111111111111111111111111111111111111118080ff840000000080ff80ff80ff80ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ff018080ffffa0842c1702f4e63eace8b5f668fcfde3b8bd0d9de05af510a7ce5cf6c9e6f90f52ff822710ff80ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6dffc040de2a00fff9beb5a0da04c271237b33c5f147cec6de38477c9b8c08db5ecaa399c4455ad01305340e584da9b8af9a081ec362bd09292265a4a6678a19ad6562e98080", + "expect": { + "error": "user_raise" + } + }, + { + "name": "inner_creates_two_odd_outputs", + "program": "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", + "env": "ff822711ff80ff80ffff8402000000ffffffa4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d80ffff888038010000000000ff96001411111111111111111111111111111111111111118080ff840000000080ff80ff80ff80ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ff018080ffffa0842c1702f4e63eace8b5f668fcfde3b8bd0d9de05af510a7ce5cf6c9e6f90f52ff822711ffffff01ff9600141111111111111111111111111111111111111111ff038080ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6dffc0401de627f69df40228119a3d5a6f5db08b9c738d5ba5762404b3e4b58b4dc4bd4701d746d17a8baeb87e80a6a95976d8ecfef4f4fe448a82f565195639659583778080", + "expect": { + "error": "user_raise" + } + }, + { + "name": "inner_creates_odd_taproot_output", + "program": "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", + "env": "ff822711ff80ff80ffff8402000000ffffffa4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d80ffff888038010000000000ff96001411111111111111111111111111111111111111118080ff840000000080ff80ff80ff80ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ff018080ffffa0842c1702f4e63eace8b5f668fcfde3b8bd0d9de05af510a7ce5cf6c9e6f90f52ff822711ffffff02ffa050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffa0d9087f65037c81c4d68f31d4917ad46aa44af56086cd95f936f94ece24503d5cff038080ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6dffc0402e31c7e0e6162de47e57104895d2d81a8f5f99232c88bf2af357a30a5bca3ff41c6e8e472b1bca7993cc028c6661301b9c5bf44495b0e6d505c1d059352f786b8080", + "expect": { + "error": "user_raise" + } + }, + { + "name": "even_amount", + "program": "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", + "env": "ff822710ff80ff80ffff8402000000ffffffa4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d80ffff888038010000000000ff96001411111111111111111111111111111111111111118080ff840000000080ff80ff80ff80ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ff018080ffffa0842c1702f4e63eace8b5f668fcfde3b8bd0d9de05af510a7ce5cf6c9e6f90f52ff822710ff80ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6dffc040de2a00fff9beb5a0da04c271237b33c5f147cec6de38477c9b8c08db5ecaa399c4455ad01305340e584da9b8af9a081ec362bd09292265a4a6678a19ad6562e98080", + "expect": { + "error": "user_raise" + } + }, + { + "name": "malformed_launcher_outpoint_unspendable", + "program": "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", + "env": "ff822711ff80ff80ffff8402000000ffffffa4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d80ffff888038010000000000ff96001411111111111111111111111111111111111111118080ff840000000080ff80ff80ff80ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ff018080ffffa0842c1702f4e63eace8b5f668fcfde3b8bd0d9de05af510a7ce5cf6c9e6f90f52ff822711ff80ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6dffc04081da914935d389ea19b7436d7d3e72817f10fd45feea53ac95e641999b944cf4e0e4db64b35c2dff12a73baf6794316055be7544d89d605f3e25a932f1b55f668080", + "expect": { + "error": "user_raise" + } + }, + { + "name": "truncated_version_field", + "program": "ff02ffff01ff02ffff01ff02ffff03ffff09ffff0dff0580ffff012080ffff01ff02ffff03ffff09ffff0dff0b80ffff012480ffff01ff02ffff03ffff18ff17ffff010180ffff01ff02ff7effff04ff02ffff04ff0bffff04ffff02ff2affff04ff02ffff04ff05ffff04ff0bff8080808080ffff04ff17ffff04ff2fffff04ff5fffff04ff8200bfffff04ff82017fffff04ff8202ffffff04ff8205ffffff04ff820bffffff04ff8217ffff8080808080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff04ffff01ffffffffff02ffff03ff05ffff01ff0bffff0102ffff01a0a8d5dd63fba471ebcb1f3e8f7c1e1879b7152a6e7298a91ce119a63400ade7c5ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ffff05ff058080ffff0bffff0102ffff02ff20ffff04ff02ffff04ffff06ff0580ff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff01ff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b280ff0180ff0bffff0102ffff01a0a12871fee210fb8619291eaea194581cbd2531e4b23759d225f6806923f63222ffff0bffff0102ffff0bffff0102ffff01a09dcf97a184f32623d11a73124ceb99a5709b083721e878a16d78f596718ba7b2ff0580ffff0bffff0102ffff02ff20ffff04ff02ffff04ff0bff80808080ffff01a04bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a808080ffff02ffff03ff05ffff01ff10ffff0101ffff02ff28ffff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ff02ffff03ff0bffff01ff02ff38ffff04ff02ffff04ffff06ff0580ffff04ffff11ff0bffff010180ff8080808080ffff01ff05ff058080ff0180ffffff02ffff03ff0bffff01ff0effff0cffff10ffff01820100ffff18ff05ffff018200ff8080ffff0101ffff010280ffff02ff24ffff04ff02ffff04ffff16ff05ffff0181f880ffff04ffff11ff0bffff010180ff808080808080ffff018080ff0180ff02ffff03ffff15ffff018200fdff0580ffff01ff0cffff10ffff01820100ff0580ffff0101ffff010280ffff01ff02ffff03ffff15ffff0183010000ff0580ffff01ff0effff0181fdffff02ff24ffff04ff02ffff04ff05ffff04ffff0102ff808080808080ffff01ff02ffff03ffff15ffff01850100000000ff0580ffff01ff0effff0181feffff02ff24ffff04ff02ffff04ff05ffff04ffff0104ff808080808080ffff01ff0effff0181ffffff02ff24ffff04ff02ffff04ff05ffff04ffff0108ff80808080808080ff018080ff018080ff0180ffff02ffff03ffff09ffff0dff0980ffff012480ffff01ff02ffff03ffff09ffff0dff2d80ffff010480ffff01ff0eff09ffff02ff34ffff04ff02ffff04ffff0dff1580ff80808080ff15ff2d80ffff01ff088080ff0180ffff01ff088080ff0180ffff02ffff03ff05ffff01ff0effff02ff2cffff04ff02ffff04ffff05ff0580ff80808080ffff02ff5cffff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ff02ffff03ffff09ffff0dff0980ffff010880ffff01ff0eff09ffff02ff34ffff04ff02ffff04ffff0dff1580ff80808080ff1580ffff01ff088080ff0180ffffffff02ffff03ff05ffff01ff0effff02ff7cffff04ff02ffff04ffff05ff0580ff80808080ffff02ff22ffff04ff02ffff04ffff06ff0580ff8080808080ffff018080ff0180ff02ffff03ffff09ffff0dff0980ffff010480ffff01ff02ffff03ffff09ffff0dff5d80ffff010480ffff01ff02ffff03ff15ffff01ff02ffff03ff2dffff01ff0eff09ffff02ff34ffff04ff02ffff04ffff02ff28ffff04ff02ffff04ff15ff80808080ff80808080ffff02ff5cffff04ff02ffff04ff15ff80808080ffff02ff34ffff04ff02ffff04ffff02ff28ffff04ff02ffff04ff2dff80808080ff80808080ffff02ff22ffff04ff02ffff04ff2dff80808080ff5d80ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff02ff30ffff04ff02ffff04ff05ffff04ffff04ffff3fff0580ffff04ffff3fff0b80ff808080ff8080808080ffff02ffff03ffff09ff17ff0580ffff01ff0101ffff01ff02ffff03ffff07ff5f80ffff01ff02ffff03ffff09ffff0cff17ff80ffff012080ffff0bffff0bffff02ff32ffff04ff02ffff04ff5fff80808080808080ffff01ff02ffff03ffff09ffff0cff17ffff0120ffff012480ffff02ff24ffff04ff02ffff04ff2fffff04ffff0104ff808080808080ffff01ff02ffff03ffff09ffff05ffff06ffff02ff38ffff04ff02ffff04ffff05ffff06ffff06ff5f808080ffff04ff2fff80808080808080ff0b80ffff01ff0101ffff018080ff0180ffff018080ff0180ffff018080ff0180ffff018080ff018080ff0180ff02ffff03ff05ffff01ff02ffff03ffff02ffff03ffff20ffff15ffff0126ffff0dffff05ffff06ffff05ff05808080808080ffff01ff02ffff03ffff09ffff0cffff05ffff06ffff05ff05808080ff80ffff012680ff0b80ffff01ff0101ffff018080ff0180ffff018080ff0180ffff01ff04ffff05ffff06ffff05ff05808080ffff02ff7affff04ff02ffff04ffff06ff0580ffff04ff0bff808080808080ffff01ff02ff7affff04ff02ffff04ffff06ff0580ffff04ff0bff808080808080ff0180ffff018080ff0180ffffff02ffff03ff05ffff01ff02ffff03ffff20ffff06ff058080ffff01ff02ffff03ffff09ffff05ff0580ff0b80ffff01ff0101ffff018080ff0180ffff018080ff0180ffff018080ff0180ff02ffff03ff2fffff01ff02ff2effff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ffff05ff2f80ffff04ffff06ff2f80ffff04ff5fffff04ffff18ffff02ffff03ffff09ffff05ffff05ff2f8080ffff010180ffff01ff05ffff06ffff06ffff05ff2f80808080ffff01ff02ffff03ffff09ffff05ffff05ff2f8080ffff010280ffff01ff05ffff06ffff06ffff06ffff05ff2f8080808080ffff018080ff018080ff0180ffff010180ff80808080808080808080ffff01ff02ffff03ff5fffff0180ffff01ff088080ff018080ff0180ffff02ffff03ff82017fffff01ff02ffff03ffff20ff8200bf80ffff01ff02ffff03ffff09ffff05ff2f80ffff010180ffff01ff02ffff03ffff09ffff05ffff06ffff06ff2f808080ffff01818f80ffff01ff04ffff04ffff0101ffff04ffff0effff0effff01826a44ff0580ffff01a0000000000000000000000000000000000000000000000000000000000000000080ffff04ff80ff80808080ffff02ff36ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff5fffff04ffff0101ff808080808080808080ffff01ff02ffff03ffff09ffff0dffff05ffff06ff2f808080ffff012080ffff01ff04ffff04ffff0101ffff04ff0bffff04ffff05ffff06ffff06ff2f808080ff80808080ffff04ffff04ffff0101ffff04ffff0effff0effff01826a44ff0580ffff3fffff04ffff05ffff06ff2f8080ffff04ffff05ffff06ffff06ff2f808080ffff04ff17ff808080808080ffff04ff80ff80808080ffff02ff36ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff5fffff04ffff0101ff80808080808080808080ffff01ff088080ff018080ff0180ffff01ff088080ff0180ffff01ff088080ff0180ffff01ff04ff2fffff02ff36ffff04ff02ffff04ff05ffff04ff0bffff04ff17ffff04ff5fffff04ff8200bfff80808080808080808080ff0180ffff02ffff03ff8202ffffff01ff02ffff03ffff02ff26ffff04ff02ffff04ff8205ffffff04ffff0effff0effff01826a44ff0580ffff3fffff04ff8217ffffff04ff2fffff04ff5fff808080808080ff8080808080ffff01ff04ffff04ffff0137ffff04ffff01a050929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0ffff04ff0bff80808080ffff04ffff04ffff0133ffff04ff2fff808080ffff04ffff04ffff0130ffff04ff82017fff808080ffff02ff36ffff04ff02ffff04ff05ffff04ff17ffff04ff8200bfffff04ffff02ff820bffffff04ffff04ff05ffff04ff82017fffff04ff17ffff04ff2fffff04ff8217ffff808080808080ff822fff8080ffff04ff80ff8080808080808080808080ffff01ff088080ff0180ffff01ff088080ff0180ff02ff5effff04ff02ffff04ff05ffff04ff0bffff04ffff05ffff06ffff02ff38ffff04ff02ffff04ffff05ffff06ffff06ff8200bf808080ffff04ff2fff80808080808080ffff04ff17ffff04ff2fffff04ff5fffff04ffff0effff0bffff0bffff02ff32ffff04ff02ffff04ff8200bfff808080808080ffff02ff24ffff04ff02ffff04ff2fffff04ffff0104ff808080808080ffff04ffff02ff5affff04ff02ffff04ff05ffff04ffff05ffff06ffff02ff38ffff04ff02ffff04ffff05ffff06ffff06ff8200bf808080ffff04ff2fff80808080808080ffff04ffff05ffff02ff38ffff04ff02ffff04ffff05ffff06ff8200bf8080ffff04ff82017fff808080808080ffff04ff8202ffffff04ff8205ffff8080808080808080ffff04ffff02ff7affff04ff02ffff04ffff05ffff06ffff06ff8200bf808080ffff04ffff0effff01826a44ff0580ff8080808080ffff04ff820bffffff04ffff3fff820bff80ffff04ff8217ffff808080808080808080808080808080ff018080ffff04ffff01a01d8a1a3714577ac5cee67abe6ae1a6972d29ba24ea0c599205f2f0069e943f83ffff04ffff01a4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000ff01808080", + "env": "ff822711ff80ff80ffff83020000ffffffa4aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000ff80ff84ffffffff8080ffffff881127000000000000ffa25120430c9590002877b63c4b835e345e1bcd17547c910b9cb7a08b9bc750fbe3873d80ffff880000000000000000ffc0466a44aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa00000000bb7fddd3cdf133443eadcca7c860f957b292b75d900f464144f970e7e8bbdc6d80ffff888038010000000000ff96001411111111111111111111111111111111111111118080ff840000000080ff80ff80ff80ffff02ffff01ff04ffff04ffff0117ffff04ff02ffff04ffff3fffff04ff0bffff04ff17ffff04ff2fffff04ff5fff808080808080ffff04ff8200bfff8080808080ffff04ffff04ffff0161ffff04ff5fff808080ffff04ffff04ffff0101ffff04ff0bffff04ff17ff80808080ff2f808080ffff04ffff01a0d3d0021e1bbdad3f0f49e372755149521bfcb3f0ced67f8195735e25e4bd86c1ff018080ffffa0842c1702f4e63eace8b5f668fcfde3b8bd0d9de05af510a7ce5cf6c9e6f90f52ff822711ff80ffa04fc5c9c258b9d09f7234a416a0f22a89f25d1808dadaa49438a14cc4a53c6c6dffc04081da914935d389ea19b7436d7d3e72817f10fd45feea53ac95e641999b944cf4e0e4db64b35c2dff12a73baf6794316055be7544d89d605f3e25a932f1b55f668080", + "expect": { + "error": "user_raise" + } + } + ] +}