Reference

Program instructions

Every instruction: accounts, arguments, checks, effects and events.

The laplace program has 16 instructions. This page gives, for each one, who signs, the accounts in the order the program takes them, the arguments, every check with the error it raises, and what changes when it lands.

InstructionSignerArgumentsEffect
init_configadmin: the program's upgrade authority (checked through its ProgramData)fee_recipient, protocol_share_bps, slash_winner_bps, answer_deadline_secs, turn_deadline_secs, withdraw_cooldown_secscreates Config and the Vault, with registration_open false
set_configadminsame, plus new_admin, registration_openupdates Config; registration_open true lets anyone register models
register_modelpublisher: the admin while registration_open is falseslug, arch, weights_root, program_root, init_root, step_count, state_pages, chunk_count, input_max, output_len, window_secs, bond_lamports, files_hashcreates an immutable Model
register_operatorauthoritynonecreates Operator
deposit_bondauthoritylamportsSOL into the vault, bond_free += lamports
request_withdrawauthoritylamportsmarks free bond for withdrawal after withdraw_cooldown_secs
withdraw_bondauthoritynonepays the marked amount from the vault once the cooldown passed and it is still free
set_offerauthorityprice, active (mint as an account)creates or updates the Offer
requestrequesternonce, seed, input, max_feerefuses an offer priced above max_fee; creates Receipt (requested), moves price of the offer's mint into the escrow; answer_deadline = now + answer_deadline_secs
answerthe named operatoroutput, trace_rootbond_free -= model.bond, bond_locked += model.bond; window starts; answered
cancel_requestrequesternoneafter the answer deadline with no answer: full refund, void
challengechallengerindex, output, trace_root, pointsinside the window, output must differ: challenger's bond (= model bond) into the vault, Dispute number index opens over steps [0, step_count] with the challenger's first points; window pauses; challenged
bisectthe side on turnselect, pointspicks the first sub-interval of the other side's points it disagrees with, commits its own points inside it; when one step is left, proving
prove_stepanyonepayload (below)executes step lo with laplace-vm, compares the root it leads to with hi_root, pays out (below). Sent as a v1 transaction.
claim_timeoutanyonenonethe side on turn missed deadline: it loses as if proven wrong
finalizeanyonenoneafter the window with no dispute open: fee to the answerer less protocol_share_bps to the fee recipient (same instruction); bond unlocks (to bond_free for an operator, to the wallet for a challenger); final

Conventions

Instruction data. An 8-byte discriminator, then the arguments Borsh-encoded in the order listed: integers little-endian, a Vec as a u32 length followed by its elements, a [u8; 32] as 32 bytes.

Accounts. Each table lists the accounts in the order the instruction takes them. W marks a writable account and S a signer. Seeds are those on Program accounts. An optional account that is left out is passed as the program id in its position.

Fixed programs. system_program is 11111111111111111111111111111111, token_program is TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA and associated_token_program is ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL.

Checks. Account checks run before the instruction's own checks, which run in the order listed. A check with a name from 6000 up raises one of the program's errors. A check on how an account relates to another raises one of Anchor's constraint errors, named in the tables as ConstraintHasOne, ConstraintSeeds, ConstraintAddress, ConstraintRaw, ConstraintTokenMint, ConstraintTokenOwner and ConstraintAssociated. An amount or deadline that overflows, and a vault or bond_locked balance that would go below 0, raises MathOverflow.

Time. now is Clock.unix_timestamp in the slot the instruction lands.

Events. The program emits no events. Every effect is a change to the accounts listed, and prove_step writes one log line.

Builders. ix in @laplace/sdk has one builder per instruction, returning a web3.js TransactionInstruction with the accounts already derived. Each section gives its signature.

InstructionDiscriminator (bytes)
init_config23, 235, 115, 232, 168, 96, 1, 231
set_config108, 158, 154, 175, 212, 98, 52, 66
register_model111, 236, 93, 31, 195, 210, 142, 125
register_operator49, 242, 151, 125, 212, 136, 31, 89
deposit_bond120, 89, 18, 253, 112, 125, 87, 255
request_withdraw137, 95, 187, 96, 250, 138, 31, 182
withdraw_bond222, 199, 141, 31, 188, 93, 155, 40
set_offer230, 220, 7, 113, 40, 254, 223, 140
request46, 101, 67, 11, 76, 137, 12, 173
answer72, 214, 44, 32, 53, 222, 9, 244
cancel_request65, 196, 177, 247, 83, 151, 33, 130
challenge16, 107, 14, 39, 244, 150, 81, 187
bisect152, 154, 208, 235, 126, 186, 40, 168
prove_step64, 25, 26, 183, 166, 1, 169, 230
claim_timeout130, 234, 45, 53, 120, 90, 86, 178
finalize171, 61, 218, 56, 127, 115, 12, 217

Transaction format

Every instruction but one fits a legacy or v0 transaction of 1,232 bytes, and the SDK sends them as v0 with send. Each v0 transaction opens with two Compute Budget instructions: a compute-unit limit taken from its own simulation, and a compute-unit price (Priority fees).

prove_step carries a step's inputs and Merkle proofs, which run past that size, so it is sent as a v1 transaction of up to 4096 bytes. The SDK builds and sends it with sendV1 (or compileV1 and serializeV1): the signer signs the message bytes with signMessage, the transaction asks for 1,400,000 compute units, and its priority fee rides in the v1 header. A server key sends it: the network's keeper proves every game that reaches its last step, and the nodes prove their own. One step on chain describes the transaction and the payload in full.

init_config

The admin's. Creates Config and the vault and records the bump of the fee escrow authority. It runs once per program.

Signer: admin, which must be the program's upgrade authority.

Accounts

#AccountWSAddress
1adminWSThe upgrade authority. Pays the rent of both accounts.
2configWSeeds ["config"]. Created here.
3vaultWSeeds ["vault"]. Created here.
4escrowSeeds ["escrow"].
5programThe program id.
6program_dataThe program's ProgramData account: seeds [program id] under BPFLoaderUpgradeab1e11111111111111111111111.
7system_programThe System Program.

Arguments

One argument, args, of type ConfigArgs:

fee_recipientPubkeyrequired
The wallet that receives the protocol's share.
protocol_share_bpsu16required
Basis points of each finalized fee for the fee recipient.
slash_winner_bpsu16required
Basis points of a lost bond for the winner.
answer_deadline_secsi64required
Seconds an operator has to answer.
turn_deadline_secsi64required
Seconds a side has for a turn.
withdraw_cooldown_secsi64required
Seconds between requesting a withdrawal and withdrawing.

Checks

CheckError
program_data is this program's ProgramData accountConstraintRaw
admin is the upgrade authority in program_dataUnauthorized
Both basis-point values are at most 10,000, answer_deadline_secs and turn_deadline_secs are above 0, withdraw_cooldown_secs is 0 or moreInvalidConfig

Effects. Config is created with admin set to the signer, the six values from args, the bumps of the config, the vault and the escrow authority, and registration_open set to false, so only the admin registers models until set_config opens registration. The vault is created empty.

Builder: ix.initConfig(admin, config), with config as { feeRecipient, protocolShareBps, slashWinnerBps, answerDeadlineSecs, turnDeadlineSecs, withdrawCooldownSecs }.

set_config

The admin's. Replaces every value of Config, names the admin and opens or closes model registration.

Signer: admin, the key in Config.admin.

Accounts

#AccountWSAddress
1adminSConfig.admin.
2configWSeeds ["config"].

Arguments

argsConfigArgsrequired
The six values, as in init_config. All six are written.
new_adminPubkeyrequired
The admin from now on. Pass the current admin to keep it.
registration_openboolrequired
true lets any key register a model; false keeps register_model to the admin.

Checks

CheckError
admin equals Config.adminUnauthorized
The same bounds as init_configInvalidConfig

Effects. The six values, admin and registration_open are replaced. Receipts and disputes already open keep the deadlines they were given. A later finalize, prove_step or claim_timeout reads the share, the split and the fee recipient as they are then.

Builder: ix.setConfig(admin, config, newAdmin, registrationOpen).

register_model

Creates a Model. Nothing writes to it afterwards.

Signer: publisher: the admin while Config.registration_open is false, any key once it is true.

Accounts

#AccountWSAddress
1publisherWSThe admin, or any key while registration is open. Pays the rent.
2configSeeds ["config"].
3modelWSeeds ["model", slug]. Created here.
4system_programThe System Program.

Arguments

One argument, args, of type ModelArgs:

slugVec<u8>required
The slug's bytes.
archu8required
The architecture number from the manifest.
weights_root[u8; 32]required
Merkle root of the weight chunks.
program_root[u8; 32]required
Merkle root of the step descriptors.
init_root[u8; 32]required
The state root before step 0.
step_countu32required
Steps in one run.
state_pagesu32required
Pages in the state.
chunk_countu32required
Weight chunks.
input_maxu16required
Most input tokens.
output_lenu16required
Exact output tokens.
window_secsu32required
The window in seconds.
bond_lamportsu64required
The bond per answer in lamports.
files_hash[u8; 32]required
SHA-256 of the manifest file.

Checks

CheckError
Config.registration_open is true, or publisher is Config.adminUnauthorized
slug is 1 to 24 bytes, each a to z, 0 to 9 or -InvalidModel
step_count, state_pages, chunk_count, window_secs and bond_lamports are above 0InvalidModel
input_max and output_len are each 1 to 64InvalidModel

A slug that is already registered fails in the System Program, because its account exists.

Effects. The Model is created with the arguments, publisher set to the signer and registered_at set to now.

Builder: ix.registerModel(publisher, model), with model as { slug, arch, weightsRoot, programRoot, initRoot, stepCount, statePages, chunkCount, inputMax, outputLen, windowSecs, bondLamports, filesHash }. Publish a model is the guide.

register_operator

Creates the signer's Operator account.

Signer: authority.

Accounts

#AccountWSAddress
1authorityWSThe operator's key. Pays the rent.
2operatorWSeeds ["operator", authority]. Created here.
3system_programThe System Program.

No arguments and no checks of its own. A key that is already registered fails in the System Program.

Effects. Operator is created with authority, registered_at set to now, and every balance and counter at 0.

Builder: ix.registerOperator(authority).

deposit_bond

Moves SOL from the operator's wallet into the vault as free bond.

Signer: authority.

Accounts

#AccountWSAddress
1authorityWSThe operator's key.
2operatorWSeeds ["operator", authority].
3vaultWSeeds ["vault"].
4system_programThe System Program.

Arguments

lamportsu64required
The amount to deposit.

Checks

CheckError
operator is the signer's Operator accountConstraintSeeds

A wallet that holds less than lamports fails in the System Program.

Effects. lamports move from authority to the vault. bond_free rises by lamports.

Builder: ix.depositBond(authority, lamports).

request_withdraw

Marks free bond for withdrawal and starts the cooldown.

Signer: authority.

Accounts

#AccountWSAddress
1authoritySThe operator's key.
2configSeeds ["config"].
3operatorWSeeds ["operator", authority].

Arguments

lamportsu64required
The amount to mark.

Checks

CheckError
lamports is above 0 and at most bond_freeInsufficientFreeBond

Effects. withdraw_amount is set to lamports and withdraw_at to now + Config.withdraw_cooldown_secs. A new request replaces the earlier one and restarts the cooldown. The marked amount stays in bond_free and answer can still draw on it.

Builder: ix.requestWithdraw(authority, lamports).

withdraw_bond

Pays the marked amount from the vault to the operator's wallet.

Signer: authority.

Accounts

#AccountWSAddress
1authorityWSThe operator's key. Receives the lamports.
2operatorWSeeds ["operator", authority].
3vaultWSeeds ["vault"].

No arguments.

Checks

CheckError
withdraw_amount is above 0NoWithdrawal
now is at or after withdraw_atWithdrawNotReady
withdraw_amount is at most bond_freeInsufficientFreeBond

Effects. bond_free falls by withdraw_amount, that many lamports move from the vault to authority, and withdraw_amount and withdraw_at return to 0.

Builder: ix.withdrawBond(authority).

set_offer

Creates or replaces the operator's offer for one model.

Signer: authority.

Accounts

#AccountWSAddress
1authorityWSThe operator's key. Pays the rent the first time.
2operatorSeeds ["operator", authority]. The key must be registered.
3modelThe Model account.
4mintThe SPL Token mint the price is charged in.
5offerWSeeds ["offer", authority, model]. Created here if it does not exist.
6system_programThe System Program.

Arguments

priceu64required
The fee per request, in the mint's base units.
activeboolrequired
Whether the offer takes requests.

No checks of its own.

Effects. The offer's operator, model, mint, price and active are written and updated_at is set to now. Requests already made keep the mint and fee recorded on their receipts.

Builder: ix.setOffer(authority, model, mint, price, active).

request

Creates a receipt and moves the offer's price into the fee escrow.

Signer: requester.

Accounts

#AccountWSAddress
1requesterWSPays the fee and the rent.
2configSeeds ["config"].
3modelThe offer's Model account.
4offerThe Offer being taken.
5mintThe offer's mint.
6receiptWSeeds ["receipt", requester, nonce]. Created here.
7requester_tokenWA token account of mint owned by requester. The SDK passes the associated token account.
8escrowSeeds ["escrow"].
9escrow_tokenWThe associated token account of escrow for mint. Created here if it does not exist.
10token_programThe SPL Token program.
11associated_token_programThe Associated Token program.
12system_programThe System Program.

Arguments

nonceu64required
Chosen by the requester. Part of the receipt's address, so each nonce is used once per requester.
seedu64required
The run's seed, loaded into the model's state with the input.
inputVec<u16>required
The input token ids.
max_feeu64required
The most the requester pays, in the mint's base units: the price they were shown. An offer repriced above it is refused.

Checks

CheckError
offer.model equals modelConstraintHasOne
offer.mint equals mintMintMismatch
requester_token holds mintConstraintTokenMint
requester_token is owned by requesterConstraintTokenOwner
offer.active is trueOfferInactive
offer.price is at most max_feeFeeAboveMax
input has at least 1 token and at most model.input_maxInvalidInput

A requester_token balance below the price fails in the Token program.

Effects. offer.price moves from requester_token to escrow_token. The receipt is created with model, operator (the offer's), requester, nonce, seed, mint, fee (the price), the input, state requested, requested_at = now and answer_deadline = now + Config.answer_deadline_secs.

Builder: ix.request(requester, offer, nonce, seed, input, maxFee), with offer as { address, model, mint }.

answer

Posts the output and trace root and locks the model's bond behind them.

Signer: authority, the operator the receipt names.

Accounts

#AccountWSAddress
1authoritySThe operator's key.
2operatorWSeeds ["operator", authority].
3receiptWThe receipt being answered.
4modelThe receipt's Model account.

Arguments

outputVec<u16>required
The output token ids.
trace_root[u8; 32]required
The trace root of the run.

Checks

CheckError
receipt.model equals modelConstraintHasOne
The receipt is requestedWrongState
receipt.operator equals authorityNotNamedOperator
now is at or before answer_deadlineAnswerDeadlinePassed
output has exactly model.output_len tokensInvalidOutput
bond_free is at least model.bond_lamportsInsufficientFreeBond

Effects. On the operator: bond_free falls and bond_locked rises by the model's bond, answered rises by 1, last_answer_at = now. On the receipt: output, trace_root, answerer = authority, answerer_is_operator = true, bond set to the model's bond, state answered, answered_at = now, window_ends_at = now + model.window_secs.

Builder: ix.answer(authority, receipt, model, output, traceRoot).

cancel_request

Returns the fee of a request that was not answered in time.

Signer: requester.

Accounts

#AccountWSAddress
1requesterSThe receipt's requester.
2configSeeds ["config"].
3receiptWThe receipt being cancelled.
4mintThe receipt's mint.
5requester_tokenWThe token account of mint that receives the refund. The SDK passes the requester's associated token account.
6escrowSeeds ["escrow"].
7escrow_tokenWThe associated token account of escrow for mint.
8token_programThe SPL Token program.

No arguments.

Checks

CheckError
receipt.requester equals requesterUnauthorized
receipt.mint equals mintMintMismatch
requester_token holds mintConstraintTokenMint
escrow_token is the escrow's associated token account for mintConstraintTokenOwner, ConstraintAssociated
The receipt is requestedWrongState
now is after answer_deadlineAnswerDeadlineOpen

Effects. receipt.fee moves from escrow_token to requester_token. The receipt's state becomes void and finalized_at = now.

Builder: ix.cancelRequest(requester, receipt, mint).

challenge

Opens a dispute against the standing answer with a rival output, trace root and bond.

Signer: challenger.

Accounts

#AccountWSAddress
1challengerWSPays the bond and the dispute's rent.
2configSeeds ["config"].
3receiptWThe receipt being challenged.
4modelThe receipt's Model account.
5disputeWSeeds ["dispute", receipt, index]. Created here.
6vaultWSeeds ["vault"].
7system_programThe System Program.

Arguments

indexu16required
The receipt's current disputes count. Part of the dispute's address.
outputVec<u16>required
The challenger's output token ids.
trace_root[u8; 32]required
The challenger's trace root.
pointsVec<[u8; 32]>required
The challenger's state roots at the split points of [0, step_count].

Checks

CheckError
receipt.model equals modelConstraintHasOne
The receipt is answeredWrongState
index equals receipt.disputesWrongState
now is before window_ends_atWindowClosed
challenger is not receipt.answererSelfChallenge
output has exactly model.output_len tokensInvalidOutput
output differs from the receipt's outputSameOutput
points has the number of split points of [0, step_count]: 7 when step_count is above 8, otherwise step_count - 1PointCount

Effects. model.bond_lamports move from challenger to the vault. The dispute is created with:

  • defender and defender_is_operator from the receipt's answerer, and both sides' outputs and trace roots,
  • bond set to the model's bond,
  • lo = 0, hi = step_count, lo_root = model.init_root, hi_root set to the output leaf of the challenger's output, hi_owner the challenger,
  • the challenger's points, turn the defender, deadline = now + Config.turn_deadline_secs, turns = 1, state open, opened_at = now.

On the receipt: state challenged, window_remaining = window_ends_at - now, dispute set to the new account, disputes raised by 1.

Builder: ix.challenge(challenger, receipt, model, index, output, traceRoot, points).

bisect

One turn of the game: the side on turn selects a sub-interval of the other side's points and commits its own points inside it.

Signer: signer, the side on turn.

Accounts

#AccountWSAddress
1signerSThe defender or the challenger, whichever turn names.
2configSeeds ["config"].
3disputeWThe dispute.

Arguments

selectu8required
The index of the sub-interval to keep, from 0. With m points stored there are m + 1 sub-intervals.
pointsVec<[u8; 32]>required
The signer's state roots at the split points of the selected sub-interval. Empty when that sub-interval is one step.

Checks

CheckError
The dispute is openWrongState
signer is the side on turnNotYourTurn
now is at or before deadlineTurnExpired
select is at most the number of points storedSelectOutOfRange
points has the number of split points of the selected sub-interval, and none when it is one stepPointCount

Effects. With the stored points at steps p[1] … p[m] of [lo, hi]:

  • select = 0 keeps [lo, p[1]], select = m keeps [p[m], hi], and any other value s keeps [p[s], p[s+1]].
  • A new lo takes its root from the stored point there. A new hi takes its root from the stored point there, and hi_owner becomes the side that committed those points. When hi does not move, hi_root and hi_owner stay.
  • turns rises by 1 and deadline = now + Config.turn_deadline_secs.
  • If the interval is now one step: points_len becomes 0, the state becomes proving and turn is set to hi_owner.
  • Otherwise the signer's points are stored and turn passes to the other side.

The split points of an interval are lo + floor((hi - lo) * i / 8) for i from 1 to 7, or every interior step when hi - lo is 8 or less.

Builder: ix.bisect(signer, dispute, select, points).

prove_step

Executes the one disputed step and settles the dispute on its result. Sent as a v1 transaction.

Signer: signer, any key.

Accounts

#AccountWSAddress
1signerSAny key.
2configSeeds ["config"].
3disputeWThe dispute.
4receiptWThe dispute's receipt.
5modelThe receipt's Model account.
6vaultWSeeds ["vault"].
7fee_recipientWConfig.fee_recipient.
8defenderWdispute.defender.
9challengerWdispute.challenger.
10defender_operatorWOptional. The defender's Operator account, seeds ["operator", defender]. Required when defender_is_operator is true.

Arguments

payloadVec<u8>required
Step lo's descriptor, the state pages it opens and its weight chunk, each with a Merkle proof. One step on chain gives the format.

Checks

CheckError
dispute.receipt equals receipt, receipt.model equals modelConstraintHasOne
fee_recipient, defender and challenger are the addresses on Config and the disputeConstraintAddress
The dispute is provingWrongState
The payload's step is loBadStep
Its descriptor hashes into program_root, its pages hash into lo_root, its chunk hashes into weights_root, nothing follows it, and the step executesBadProof
The defender is an operator (defender_is_operator), whichever side wins: defender_operator is passed and its authority is the defenderUnauthorized

Effects. The program executes step lo from lo_root on the receipt's input and seed and gets the root the step leads to. If that root equals hi_root, hi_owner wins. If it differs, the other side wins. The program logs step <lo> computed <first 8 bytes of the root>, then settles as Settlement describes, with resolved_by = 0 and computed_root set to the root it computed.

Builder: ix.proveStep(signer, accounts, payload), with accounts as { dispute, receipt, model, feeRecipient, defender, challenger, defenderIsOperator }. laplace.proveStep(dispute) builds the payload from an honest run and sends it as a v1 transaction, for a server key. laplace.playTurn never sends it: at the last step it returns { kind: 'proving', step }.

claim_timeout

Settles a dispute against the side that missed its turn.

Signer: signer, any key.

Accounts. The same ten accounts as prove_step, in the same order.

No arguments.

Checks

CheckError
The account checks of prove_stepConstraintHasOne, ConstraintAddress
The dispute is open or provingWrongState
now is after deadlineTurnOpen
The defender is an operator (defender_is_operator), whichever side wins: defender_operator is passed and its authority is the defenderUnauthorized

Effects. The side on turn loses and the other side wins. The dispute settles as Settlement describes, with resolved_by = 1 and computed_root zero.

Builder: ix.claimTimeout(signer, accounts), with the same accounts as ix.proveStep.

Settlement

prove_step and claim_timeout end a dispute the same way. With bond as the dispute's bond:

Text
to_winner   = floor(bond * Config.slash_winner_bps / 10000)
to_protocol = bond - to_winner
The challenger winsThe defender wins
Vault to winner's walletto_winner to challengerto_winner to defender
Vault to fee_recipientto_protocolto_protocol
Defender's Operator, when the defender is an operatorbond_locked falls by bond, disputes_lost rises by 1disputes_won rises by 1
Receipt's answeroutput and trace_root become the challenger's, answerer the challenger, answerer_is_operator = false, bond the dispute's bond, answered_at = nowUnchanged
Receipt's windowwindow_ends_at = now + model.window_secswindow_ends_at = now + window_remaining

In both cases the receipt's state returns to answered, its dispute is cleared and window_remaining returns to 0. The dispute's state becomes resolved, with winner and resolved_at = now.

The winner's own bond does not move. A winning challenger's bond stays in the vault behind the answer that now stands, and leaves at finalize.

finalize

Closes a receipt whose window has ended: pays the fee, unlocks the bond and makes the receipt final.

Signer: signer, any key.

Accounts

#AccountWSAddress
1signerWSAny key.
2configSeeds ["config"].
3receiptWThe receipt.
4mintThe receipt's mint.
5escrowSeeds ["escrow"].
6escrow_tokenWThe associated token account of escrow for mint.
7answererWreceipt.answerer.
8answerer_tokenWThe associated token account of answerer for mint. It must exist.
9fee_recipient_tokenWThe associated token account of Config.fee_recipient for mint. It must exist.
10vaultWSeeds ["vault"].
11operatorWOptional. The answerer's Operator account, seeds ["operator", answerer], passed when answerer_is_operator is true.
12token_programThe SPL Token program.

No arguments.

Checks

CheckError
receipt.mint equals mintMintMismatch
The three token accounts are the associated token accounts named aboveConstraintTokenOwner, ConstraintAssociated
The receipt is answeredWrongState
now is at or after window_ends_atWindowOpen
answerer equals receipt.answererUnauthorized
The answerer is an operator: operator is passed and its authority is the answererUnauthorized

Effects.

Text
share = floor(fee * Config.protocol_share_bps / 10000)
  • fee - share moves from escrow_token to answerer_token, and share to fee_recipient_token. A part that is 0 is not transferred.
  • When the answerer is an operator, its bond_locked falls and its bond_free rises by the receipt's bond. When the answerer is a challenger, the receipt's bond moves from the vault to the answerer's wallet.
  • The receipt's state becomes final and finalized_at = now.

Builder: ix.finalize(signer, accounts), with accounts as { receipt, mint, answerer, answererIsOperator, feeRecipient }. laplace.finalize(receipt) sends it after two instructions that create the answerer's and the fee recipient's token accounts if they are missing.