ExploitReplayCI

    // the attacker's own lamports and the oracle would read it as a gain.    return account.signer === true ? victim.address : undefined  })  if (!accounts.ok) return accounts   const data = encodeInstructionData(idl, opener.name, args.args)  if (!data.ok) return failed(`\`${opener.name}\`: ${data.reason}`)   const call = await buildCall(svm, victim, programAddress, accounts.accounts, data.data)  const sent = svm.sendTransaction(call)  if (sent instanceof FailedTransactionMetadata) {    return failed(`\`${opener.name}\` would not open the target to attack: ${sent.toString()}`)  }   return { ok: true }} /** * The attack: call the guarded instruction with the real authority's address in * the authority slot and **no signature from it**, paying the fee from the * attacker's own account and pointing the destination at the attacker. * * Passing the attacker's own address as the authority would be refused by both * halves of the pair — `has_one` compares the key, and that comparison is not

1. Line 286 const sent = svm.sendTransaction(call): Submits the signed transaction to the cluster.
2. Line 300 * halves of the pair — `has_one` compares the key, and that comparison is not: Checks that a stored pubkey field matches the passed account.

  TxOutcome,} from './types.js' /** * A program that takes one of its own accounts and acts on the account's data * without proving the account belongs to the signer in front of it. * * The signature is genuine — the attacker signs as themselves, which is exactly * what separates this class from `missing-signer`. What is missing is the link * between the signer and the account they hand in: the handler is given a * `Ledger` this program owns, and never checks it is *this signer's* ledger. So * the attacker signs their own transaction and passes the victim's account of * the same type, and the handler moves lamports it was never entitled to move. * * **This binds on the shape of the instruction, never on the check that closes * the hole** — the rule T021 found and T028 confirmed on this very pair, whose * two halves emit byte-identical IDLs apart from the program address. The fix * is a `require_keys_eq!` inside the handler; it adds no constraint, no * `has_one`, no seeds, nothing an IDL carries. Binding on the fix would be * impossible here — there is nothing in the IDL to read — and everywhere else * it would make the fixed half of a pair come back `not-applicable` where * FR-008 asks for `blocked`. So both halves bind, both are attacked, the SVM * decides. *

1. Line 42 * is a `require_keys_eq!` inside the handler; it adds no constraint, no: An explicit validation that aborts the instruction with an error.
2. Line 43 * `has_one`, no seeds, nothing an IDL carries. Binding on the fix would be: Checks that a stored pubkey field matches the passed account.