@telaro/sdk 0.1.0

package/dist/instructions.js

@@ -0,0 +1,841 @@
+import { SystemProgram, SYSVAR_RENT_PUBKEY, TransactionInstruction, } from "@solana/web3.js";
+import { TOKEN_PROGRAM_ID } from "@solana/spl-token";
+import { PROGRAM_ID } from "./constants.js";
+import { INSTRUCTION_DISC } from "./discriminators.js";
+import { findActionLogPda, findAgentPda, findBondVaultPda, findCapabilityRegistryPda, findClaimPda, findCreditLinePda, findDepositVaultPda, findLpPositionPda, findPoolConfigPda, findPoolMintAuthPda, findPoolStusdcMintPda, findPoolVaultPda, findProtocolConfigPda, findScoreFeedPda, findTsusdcConfigPda, findTsusdcMintAuthPda, findTsusdcMintPda, LP_KIND_KAMINO, LP_KIND_MARGINFI, } from "./pda.js";
+function writeString(s) {
+    const data = Buffer.from(s, "utf8");
+    const out = Buffer.alloc(4 + data.length);
+    out.writeUInt32LE(data.length, 0);
+    data.copy(out, 4);
+    return out;
+}
+function u64LE(v) {
+    const buf = Buffer.alloc(8);
+    buf.writeBigUInt64LE(v, 0);
+    return buf;
+}
+/**
+ * Step 1 of registration. Creates the Agent + ActionLog accounts. The agent
+ * is born frozen — it can't `record_action` until step 2 (`bond_agent`)
+ * posts a bond. Pair both ix in the same transaction for atomic registration.
+ */
+export function buildInitAgentIx(accounts, args, programId = PROGRAM_ID) {
+    const [agent] = findAgentPda(accounts.controller, programId);
+    const [log] = findActionLogPda(agent, programId);
+    const data = Buffer.concat([
+        INSTRUCTION_DISC.initAgent,
+        writeString(args.framework),
+        writeString(args.metadataUri),
+        args.scorer.toBuffer(),
+        args.bondMint.toBuffer(),
+    ]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: agent, isSigner: false, isWritable: true },
+            { pubkey: log, isSigner: false, isWritable: true },
+            { pubkey: accounts.controller, isSigner: true, isWritable: true },
+            { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+/**
+ * Step 2 of registration (or a top-up later on). Initializes the bond vault
+ * if it doesn't exist yet, transfers USDC, and unfreezes the agent if its
+ * bond ≥ MIN_BOND_USDC.
+ */
+export function buildBondAgentIx(accounts, amount, programId = PROGRAM_ID) {
+    const [vault] = findBondVaultPda(accounts.agent, programId);
+    const data = Buffer.concat([INSTRUCTION_DISC.bondAgent, u64LE(amount)]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: true },
+            { pubkey: accounts.bondMint, isSigner: false, isWritable: false },
+            { pubkey: vault, isSigner: false, isWritable: true },
+            { pubkey: accounts.payerBondAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.payer, isSigner: true, isWritable: true },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+            { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildFullAgentSetup(args, programId = PROGRAM_ID) {
+    const ixs = [];
+    const [initIx, bondIx] = buildRegisterAndBondIxs({
+        controller: args.controller,
+        controllerBondAta: args.controllerBondAta,
+        framework: args.framework,
+        metadataUri: args.metadataUri,
+        scorer: args.scorer,
+        bondMint: args.bondMint,
+        bondAmount: args.bondAmount,
+    }, programId);
+    ixs.push(initIx, bondIx);
+    if (!args.marginfi) {
+        return { ixs, marginfiAccountKeypair: null };
+    }
+    // Need a fresh keypair for the new MarginfiAccount. Caller signs the
+    // tx with this in addition to controller.
+    const { Keypair } = require("@solana/web3.js");
+    const marginfiAccountKp = Keypair.generate();
+    const [agent] = findAgentPda(args.controller, programId);
+    const [bondVault] = findBondVaultPda(agent, programId);
+    ixs.push(buildInitMarginfiAccountIx({
+        agent,
+        marginfiAccount: marginfiAccountKp.publicKey,
+        bondVaultMintWitness: bondVault,
+        marginfiGroup: args.marginfi.marginfiGroup,
+        marginfiProgram: args.marginfi.marginfiProgram,
+        feePayer: args.controller,
+    }, programId));
+    ixs.push(buildInitLpPositionIx({ agent, payer: args.controller }, LP_KIND_MARGINFI, args.marginfi.yieldRouter, marginfiAccountKp.publicKey, args.marginfi.marginfiBank, programId));
+    return { ixs, marginfiAccountKeypair: marginfiAccountKp };
+}
+export function buildRecordActionIx(controller, args, programId = PROGRAM_ID) {
+    const [agent] = findAgentPda(controller, programId);
+    const [log] = findActionLogPda(agent, programId);
+    if (args.actionHash.length !== 32) {
+        throw new Error("actionHash must be 32 bytes");
+    }
+    const data = Buffer.concat([
+        INSTRUCTION_DISC.recordAction,
+        Buffer.from(args.actionHash),
+        Buffer.from([args.kind & 0xff]),
+        Buffer.from([args.outcome & 0xff]),
+        u64LE(args.valueAtomic),
+    ]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: agent, isSigner: false, isWritable: true },
+            { pubkey: log, isSigner: false, isWritable: true },
+            { pubkey: controller, isSigner: true, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildTopUpIx(accounts, amount, programId = PROGRAM_ID) {
+    const [vault] = findBondVaultPda(accounts.agent, programId);
+    const data = Buffer.concat([INSTRUCTION_DISC.topUpBond, u64LE(amount)]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: true },
+            { pubkey: accounts.bondMint, isSigner: false, isWritable: false },
+            { pubkey: vault, isSigner: false, isWritable: true },
+            { pubkey: accounts.payerBondAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.payer, isSigner: true, isWritable: true },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildSubmitClaimIx(accounts, args, programId = PROGRAM_ID) {
+    if (args.actionHash.length !== 32) {
+        throw new Error("actionHash must be 32 bytes");
+    }
+    const [claim] = findClaimPda(accounts.agent, args.actionHash, accounts.claimer, programId);
+    const [deposit] = findDepositVaultPda(claim, programId);
+    const data = Buffer.concat([
+        INSTRUCTION_DISC.submitClaim,
+        Buffer.from(args.actionHash),
+        u64LE(args.claimedAmount),
+        writeString(args.evidenceUri),
+    ]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: true },
+            { pubkey: claim, isSigner: false, isWritable: true },
+            { pubkey: accounts.bondMint, isSigner: false, isWritable: false },
+            { pubkey: deposit, isSigner: false, isWritable: true },
+            { pubkey: accounts.claimerBondAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.claimer, isSigner: true, isWritable: true },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+            { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+/**
+ * Convenience: build the two ix needed for full registration. Pack both into
+ * a single Transaction for atomic register-and-bond.
+ */
+export function buildRegisterAndBondIxs(args, programId = PROGRAM_ID) {
+    const [agent] = findAgentPda(args.controller, programId);
+    const initIx = buildInitAgentIx({ controller: args.controller }, {
+        framework: args.framework,
+        metadataUri: args.metadataUri,
+        scorer: args.scorer,
+        bondMint: args.bondMint,
+    }, programId);
+    const bondIx = buildBondAgentIx({
+        agent,
+        bondMint: args.bondMint,
+        payer: args.controller,
+        payerBondAta: args.controllerBondAta,
+    }, args.bondAmount, programId);
+    return [initIx, bondIx];
+}
+export function buildResolveClaimIx(accounts, action, programId = PROGRAM_ID) {
+    const [vault] = findBondVaultPda(accounts.agent, programId);
+    const [deposit] = findDepositVaultPda(accounts.claim, programId);
+    const data = Buffer.concat([
+        INSTRUCTION_DISC.resolveClaim,
+        Buffer.from([action & 0xff]),
+    ]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.claim, isSigner: false, isWritable: true },
+            { pubkey: accounts.agent, isSigner: false, isWritable: true },
+            { pubkey: accounts.bondMint, isSigner: false, isWritable: false },
+            { pubkey: vault, isSigner: false, isWritable: true },
+            { pubkey: deposit, isSigner: false, isWritable: true },
+            { pubkey: accounts.claimerBondAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.signer, isSigner: true, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildUpdateScoreIx(agent, scorer, args, programId = PROGRAM_ID) {
+    const data = Buffer.alloc(8 + 2 + 4);
+    INSTRUCTION_DISC.updateScore.copy(data, 0);
+    data.writeUInt16LE(args.newScore, 8);
+    data.writeUInt32LE(args.bondRatioBps, 10);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: agent, isSigner: false, isWritable: true },
+            { pubkey: scorer, isSigner: true, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildWithdrawBondIx(accounts, amount, programId = PROGRAM_ID) {
+    const [vault] = findBondVaultPda(accounts.agent, programId);
+    const data = Buffer.concat([INSTRUCTION_DISC.withdrawBond, u64LE(amount)]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: true },
+            { pubkey: accounts.bondMint, isSigner: false, isWritable: false },
+            { pubkey: vault, isSigner: false, isWritable: true },
+            { pubkey: accounts.controllerBondAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.controller, isSigner: true, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildViewBondIx(agent, args, programId = PROGRAM_ID) {
+    const data = Buffer.alloc(8 + 8 + 2);
+    INSTRUCTION_DISC.viewBond.copy(data, 0);
+    data.writeBigUInt64LE(args.minBond, 8);
+    data.writeUInt16LE(args.minScore, 16);
+    return new TransactionInstruction({
+        programId,
+        keys: [{ pubkey: agent, isSigner: false, isWritable: false }],
+        data,
+    });
+}
+/**
+ * Idempotently set the agent's declared capability bitmap. The bitmap
+ * is a u64 where bit `n` set means the agent has capability id `n`.
+ * Use `capabilitiesBitmap([CAPABILITY_SWAP, CAPABILITY_LP])` to compose.
+ */
+export function buildRegisterCapabilitiesIx(accounts, bitmap, programId = PROGRAM_ID) {
+    const [registry] = findCapabilityRegistryPda(accounts.agent, programId);
+    const data = Buffer.alloc(8 + 8);
+    INSTRUCTION_DISC.registerCapabilities.copy(data, 0);
+    data.writeBigUInt64LE(bitmap, 8);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: false },
+            { pubkey: registry, isSigner: false, isWritable: true },
+            { pubkey: accounts.controller, isSigner: true, isWritable: true },
+            { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+/**
+ * Capability-aware view_bond. Same checks as `view_bond` PLUS the agent
+ * must have capability bit `capabilityBit` set in its registry. Use
+ * this when gating a specific surface (Jupiter for swap, Kamino for
+ * lending, etc.).
+ */
+/* ------------------------------------------------------------------ */
+/*  Score-as-Oracle                                                     */
+/* ------------------------------------------------------------------ */
+export function buildInitScoreFeedIx(agent, payer, programId = PROGRAM_ID) {
+    const [feed] = findScoreFeedPda(agent, programId);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: agent, isSigner: false, isWritable: false },
+            { pubkey: feed, isSigner: false, isWritable: true },
+            { pubkey: payer, isSigner: true, isWritable: true },
+            { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        data: Buffer.from(INSTRUCTION_DISC.initScoreFeed),
+    });
+}
+export function buildPushScoreIx(agent, programId = PROGRAM_ID) {
+    const [feed] = findScoreFeedPda(agent, programId);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: agent, isSigner: false, isWritable: false },
+            { pubkey: feed, isSigner: false, isWritable: true },
+        ],
+        data: Buffer.from(INSTRUCTION_DISC.pushScore),
+    });
+}
+/**
+ * CPI gate for the score feed. `maxStalenessSecs = 0` disables the
+ * freshness check.
+ */
+export function buildViewScoreIx(agent, args, programId = PROGRAM_ID) {
+    const [feed] = findScoreFeedPda(agent, programId);
+    const data = Buffer.alloc(8 + 2 + 8);
+    INSTRUCTION_DISC.viewScore.copy(data, 0);
+    data.writeUInt16LE(args.minScore, 8);
+    data.writeBigInt64LE(args.maxStalenessSecs, 10);
+    return new TransactionInstruction({
+        programId,
+        keys: [{ pubkey: feed, isSigner: false, isWritable: false }],
+        data,
+    });
+}
+export function buildViewBondCapabilityIx(agent, args, programId = PROGRAM_ID) {
+    const [registry] = findCapabilityRegistryPda(agent, programId);
+    const data = Buffer.alloc(8 + 8 + 2 + 1);
+    INSTRUCTION_DISC.viewBondCapability.copy(data, 0);
+    data.writeBigUInt64LE(args.minBond, 8);
+    data.writeUInt16LE(args.minScore, 16);
+    data.writeUInt8(args.capabilityBit & 0xff, 18);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: agent, isSigner: false, isWritable: false },
+            { pubkey: registry, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildAccrueYieldIx(accounts, amount, programId = PROGRAM_ID) {
+    const [vault] = findBondVaultPda(accounts.agent, programId);
+    const data = Buffer.concat([INSTRUCTION_DISC.accrueYield, u64LE(amount)]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: true },
+            { pubkey: accounts.bondMint, isSigner: false, isWritable: false },
+            { pubkey: vault, isSigner: false, isWritable: true },
+            { pubkey: accounts.sourceAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.scorer, isSigner: true, isWritable: true },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildClaimBuilderYieldIx(accounts, amount, programId = PROGRAM_ID) {
+    const [vault] = findBondVaultPda(accounts.agent, programId);
+    const data = Buffer.concat([INSTRUCTION_DISC.claimBuilderYield, u64LE(amount)]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: true },
+            { pubkey: accounts.bondMint, isSigner: false, isWritable: false },
+            { pubkey: vault, isSigner: false, isWritable: true },
+            { pubkey: accounts.controllerAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.controller, isSigner: true, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildClaimTreasuryYieldIx(accounts, amount, programId = PROGRAM_ID) {
+    const [vault] = findBondVaultPda(accounts.agent, programId);
+    const data = Buffer.concat([INSTRUCTION_DISC.claimTreasuryYield, u64LE(amount)]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: true },
+            { pubkey: accounts.bondMint, isSigner: false, isWritable: false },
+            { pubkey: vault, isSigner: false, isWritable: true },
+            { pubkey: accounts.treasuryAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.scorer, isSigner: true, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+/** User escalates a rejected claim. Pays additional 5% deposit; the
+ *  protocol arbiter has 7d to rule. Only the original claimer can call,
+ *  and only within ESCALATION_WINDOW_SECONDS (24h) of resolve. */
+export function buildEscalateClaimIx(accounts, programId = PROGRAM_ID) {
+    const [deposit] = findDepositVaultPda(accounts.claim, programId);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.claim, isSigner: false, isWritable: true },
+            { pubkey: accounts.agent, isSigner: false, isWritable: true },
+            { pubkey: accounts.bondMint, isSigner: false, isWritable: false },
+            { pubkey: deposit, isSigner: false, isWritable: true },
+            { pubkey: accounts.claimerBondAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.claimer, isSigner: true, isWritable: true },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data: INSTRUCTION_DISC.escalateClaim,
+    });
+}
+/** ArbiterRuling: 0 = ForUser, 1 = ForBuilder. */
+export var ArbiterRuling;
+(function (ArbiterRuling) {
+    ArbiterRuling[ArbiterRuling["ForUser"] = 0] = "ForUser";
+    ArbiterRuling[ArbiterRuling["ForBuilder"] = 1] = "ForBuilder";
+})(ArbiterRuling || (ArbiterRuling = {}));
+export function buildArbiterResolveIx(accounts, ruling, programId = PROGRAM_ID) {
+    const [vault] = findBondVaultPda(accounts.agent, programId);
+    const [deposit] = findDepositVaultPda(accounts.claim, programId);
+    const data = Buffer.concat([
+        INSTRUCTION_DISC.arbiterResolve,
+        Buffer.from([ruling & 0xff]),
+    ]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.claim, isSigner: false, isWritable: true },
+            { pubkey: accounts.agent, isSigner: false, isWritable: true },
+            { pubkey: accounts.bondMint, isSigner: false, isWritable: false },
+            { pubkey: vault, isSigner: false, isWritable: true },
+            { pubkey: deposit, isSigner: false, isWritable: true },
+            { pubkey: accounts.claimerBondAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.arbiter, isSigner: true, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+/** Anyone can crank after 7d arbiter window — defaults ForUser auto-payout. */
+export function buildArbiterTimeoutIx(accounts, programId = PROGRAM_ID) {
+    const [vault] = findBondVaultPda(accounts.agent, programId);
+    const [deposit] = findDepositVaultPda(accounts.claim, programId);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.claim, isSigner: false, isWritable: true },
+            { pubkey: accounts.agent, isSigner: false, isWritable: true },
+            { pubkey: accounts.bondMint, isSigner: false, isWritable: false },
+            { pubkey: vault, isSigner: false, isWritable: true },
+            { pubkey: deposit, isSigner: false, isWritable: true },
+            { pubkey: accounts.claimerBondAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.cranker, isSigner: true, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data: INSTRUCTION_DISC.arbiterTimeout,
+    });
+}
+/** One-shot init of the per-agent tsUSDC mint + config PDA. */
+export function buildInitTsusdcMintIx(accounts, programId = PROGRAM_ID) {
+    const [config] = findTsusdcConfigPda(accounts.agent, programId);
+    const [mintAuth] = findTsusdcMintAuthPda(accounts.agent, programId);
+    const [mint] = findTsusdcMintPda(accounts.agent, programId);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: false },
+            { pubkey: config, isSigner: false, isWritable: true },
+            { pubkey: mintAuth, isSigner: false, isWritable: false },
+            { pubkey: mint, isSigner: false, isWritable: true },
+            { pubkey: accounts.payer, isSigner: true, isWritable: true },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+            { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+            { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
+        ],
+        data: INSTRUCTION_DISC.initTsusdcMint,
+    });
+}
+/** First-mint tokenization (1:1 with current_bond). One-shot per agent. */
+export function buildMintTsusdcIx(accounts, programId = PROGRAM_ID) {
+    const [config] = findTsusdcConfigPda(accounts.agent, programId);
+    const [mintAuth] = findTsusdcMintAuthPda(accounts.agent, programId);
+    const [mint] = findTsusdcMintPda(accounts.agent, programId);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: false },
+            { pubkey: config, isSigner: false, isWritable: true },
+            { pubkey: mint, isSigner: false, isWritable: true },
+            { pubkey: mintAuth, isSigner: false, isWritable: false },
+            { pubkey: accounts.recipientAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.controller, isSigner: true, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data: INSTRUCTION_DISC.mintTsusdc,
+    });
+}
+/** Burn tsUSDC; anyone holding the token can call. */
+export function buildBurnTsusdcIx(accounts, amount, programId = PROGRAM_ID) {
+    const [config] = findTsusdcConfigPda(accounts.agent, programId);
+    const [mint] = findTsusdcMintPda(accounts.agent, programId);
+    const data = Buffer.concat([INSTRUCTION_DISC.burnTsusdc, u64LE(amount)]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: false },
+            { pubkey: config, isSigner: false, isWritable: true },
+            { pubkey: mint, isSigner: false, isWritable: true },
+            { pubkey: accounts.holderAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.holder, isSigner: true, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildInitUnderwriterPoolIx(accounts, depositCap, programId = PROGRAM_ID) {
+    const [pool] = findPoolConfigPda(programId);
+    const [mintAuth] = findPoolMintAuthPda(programId);
+    const [stusdcMint] = findPoolStusdcMintPda(programId);
+    const [vault] = findPoolVaultPda(programId);
+    const data = Buffer.concat([
+        INSTRUCTION_DISC.initUnderwriterPool,
+        u64LE(depositCap),
+    ]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: pool, isSigner: false, isWritable: true },
+            { pubkey: accounts.bondMint, isSigner: false, isWritable: false },
+            { pubkey: mintAuth, isSigner: false, isWritable: false },
+            { pubkey: stusdcMint, isSigner: false, isWritable: true },
+            { pubkey: vault, isSigner: false, isWritable: true },
+            { pubkey: accounts.admin, isSigner: true, isWritable: true },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+            { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+            // rent sysvar dropped — Anchor 0.30 inits don't require it, and the
+            // on-chain struct was trimmed for the same SBPF stack-frame reason.
+        ],
+        data,
+    });
+}
+export function buildDepositToPoolIx(accounts, amount, programId = PROGRAM_ID) {
+    const [pool] = findPoolConfigPda(programId);
+    const [vault] = findPoolVaultPda(programId);
+    const [mintAuth] = findPoolMintAuthPda(programId);
+    const [stusdcMint] = findPoolStusdcMintPda(programId);
+    const data = Buffer.concat([INSTRUCTION_DISC.depositToPool, u64LE(amount)]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: pool, isSigner: false, isWritable: true },
+            { pubkey: vault, isSigner: false, isWritable: true },
+            { pubkey: mintAuth, isSigner: false, isWritable: false },
+            { pubkey: stusdcMint, isSigner: false, isWritable: true },
+            { pubkey: accounts.depositorAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.depositorStusdcAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.depositor, isSigner: true, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildWithdrawFromPoolIx(accounts, stusdcAmount, programId = PROGRAM_ID) {
+    const [pool] = findPoolConfigPda(programId);
+    const [vault] = findPoolVaultPda(programId);
+    const [mintAuth] = findPoolMintAuthPda(programId);
+    const [stusdcMint] = findPoolStusdcMintPda(programId);
+    const data = Buffer.concat([
+        INSTRUCTION_DISC.withdrawFromPool,
+        u64LE(stusdcAmount),
+    ]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: pool, isSigner: false, isWritable: true },
+            { pubkey: vault, isSigner: false, isWritable: true },
+            { pubkey: mintAuth, isSigner: false, isWritable: false },
+            { pubkey: stusdcMint, isSigner: false, isWritable: true },
+            { pubkey: accounts.holderStusdcAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.holderAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.holder, isSigner: true, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildProcessPoolYieldIx(accounts, amount, programId = PROGRAM_ID) {
+    const [pool] = findPoolConfigPda(programId);
+    const [vault] = findPoolVaultPda(programId);
+    const data = Buffer.concat([INSTRUCTION_DISC.processPoolYield, u64LE(amount)]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: pool, isSigner: false, isWritable: true },
+            { pubkey: vault, isSigner: false, isWritable: true },
+            { pubkey: accounts.sourceAta, isSigner: false, isWritable: true },
+            { pubkey: accounts.sourceAuthority, isSigner: true, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+/* ------------------------------------------------------------------ */
+/*  Yield routing (Phase 1.0 — MarginFi)                                */
+/* ------------------------------------------------------------------ */
+export { LP_KIND_MARGINFI } from "./pda.js";
+/**
+ * One-shot init for a per-agent LP position. Pins which MarginFi account
+ * + bank this agent routes into. Caller supplies `marginfiAccount` (the
+ * MarginfiAccount must already have been created off-chain via the
+ * MarginFi SDK with bond_vault PDA as authority).
+ */
+export function buildInitLpPositionIx(accounts, lpKind, yieldRouter, marginfiAccount, marginfiBank, programId = PROGRAM_ID) {
+    const [lpPosition] = findLpPositionPda(accounts.agent, lpKind, programId);
+    const data = Buffer.concat([
+        INSTRUCTION_DISC.initLpPosition,
+        Buffer.from([lpKind]),
+        yieldRouter.toBuffer(),
+        marginfiAccount.toBuffer(),
+        marginfiBank.toBuffer(),
+    ]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: false },
+            { pubkey: lpPosition, isSigner: false, isWritable: true },
+            { pubkey: accounts.payer, isSigner: true, isWritable: true },
+            { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildInitMarginfiAccountIx(accounts, programId = PROGRAM_ID) {
+    const [bondVault] = findBondVaultPda(accounts.agent, programId);
+    const data = INSTRUCTION_DISC.initMarginfiAccount;
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: false },
+            { pubkey: accounts.marginfiGroup, isSigner: false, isWritable: false },
+            { pubkey: accounts.marginfiAccount, isSigner: true, isWritable: true },
+            { pubkey: bondVault, isSigner: false, isWritable: false },
+            { pubkey: accounts.bondVaultMintWitness, isSigner: false, isWritable: false },
+            { pubkey: accounts.marginfiProgram, isSigner: false, isWritable: false },
+            { pubkey: accounts.feePayer, isSigner: true, isWritable: true },
+            { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildRouteToMarginfiIx(accounts, amount, programId = PROGRAM_ID) {
+    const [lpPosition] = findLpPositionPda(accounts.agent, LP_KIND_MARGINFI, programId);
+    const [bondVault] = findBondVaultPda(accounts.agent, programId);
+    const data = Buffer.concat([INSTRUCTION_DISC.routeToMarginfi, u64LE(amount)]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: false },
+            { pubkey: lpPosition, isSigner: false, isWritable: true },
+            { pubkey: accounts.bondMint, isSigner: false, isWritable: false },
+            { pubkey: bondVault, isSigner: false, isWritable: true },
+            { pubkey: accounts.marginfiGroup, isSigner: false, isWritable: false },
+            { pubkey: accounts.marginfiBank, isSigner: false, isWritable: false },
+            { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
+            { pubkey: accounts.marginfiBankLiquidityVault, isSigner: false, isWritable: true },
+            { pubkey: accounts.marginfiProgram, isSigner: false, isWritable: false },
+            { pubkey: accounts.yieldRouter, isSigner: true, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildHarvestMarginfiYieldIx(accounts, yieldAmount, programId = PROGRAM_ID) {
+    const [lpPosition] = findLpPositionPda(accounts.agent, LP_KIND_MARGINFI, programId);
+    const [bondVault] = findBondVaultPda(accounts.agent, programId);
+    const data = Buffer.concat([INSTRUCTION_DISC.harvestMarginfiYield, u64LE(yieldAmount)]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: true },
+            { pubkey: lpPosition, isSigner: false, isWritable: true },
+            { pubkey: accounts.bondMint, isSigner: false, isWritable: false },
+            { pubkey: bondVault, isSigner: false, isWritable: true },
+            { pubkey: accounts.marginfiGroup, isSigner: false, isWritable: false },
+            { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
+            { pubkey: accounts.marginfiBank, isSigner: false, isWritable: false },
+            { pubkey: accounts.marginfiBankLiquidityVaultAuthority, isSigner: false, isWritable: false },
+            { pubkey: accounts.marginfiBankLiquidityVault, isSigner: false, isWritable: true },
+            { pubkey: accounts.marginfiProgram, isSigner: false, isWritable: false },
+            { pubkey: accounts.yieldRouter, isSigner: true, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildUnrouteFromMarginfiIx(accounts, amount, reason, programId = PROGRAM_ID) {
+    const [lpPosition] = findLpPositionPda(accounts.agent, LP_KIND_MARGINFI, programId);
+    const [bondVault] = findBondVaultPda(accounts.agent, programId);
+    const data = Buffer.concat([
+        INSTRUCTION_DISC.unrouteFromMarginfi,
+        u64LE(amount),
+        Buffer.from([reason]),
+    ]);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: false },
+            { pubkey: lpPosition, isSigner: false, isWritable: true },
+            { pubkey: accounts.bondMint, isSigner: false, isWritable: false },
+            { pubkey: bondVault, isSigner: false, isWritable: true },
+            { pubkey: accounts.marginfiGroup, isSigner: false, isWritable: false },
+            { pubkey: accounts.marginfiAccount, isSigner: false, isWritable: true },
+            { pubkey: accounts.marginfiBank, isSigner: false, isWritable: false },
+            { pubkey: accounts.marginfiBankLiquidityVaultAuthority, isSigner: false, isWritable: false },
+            { pubkey: accounts.marginfiBankLiquidityVault, isSigner: false, isWritable: true },
+            { pubkey: accounts.marginfiProgram, isSigner: false, isWritable: false },
+            { pubkey: accounts.yieldRouter, isSigner: true, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data,
+    });
+}
+export function buildInitKaminoObligationIx(accounts, programId = PROGRAM_ID) {
+    const [bondVault] = findBondVaultPda(accounts.agent, programId);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: false },
+            { pubkey: accounts.kaminoLendingMarket, isSigner: false, isWritable: false },
+            { pubkey: accounts.obligation, isSigner: true, isWritable: true },
+            { pubkey: bondVault, isSigner: false, isWritable: false },
+            { pubkey: accounts.bondVaultMintWitness, isSigner: false, isWritable: false },
+            { pubkey: accounts.kaminoProgram, isSigner: false, isWritable: false },
+            { pubkey: accounts.feePayer, isSigner: true, isWritable: true },
+            { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        data: INSTRUCTION_DISC.initKaminoObligation,
+    });
+}
+function kaminoKeys(accounts, lpPosition, bondVault, agentWritable) {
+    return [
+        { pubkey: accounts.agent, isSigner: false, isWritable: agentWritable },
+        { pubkey: lpPosition, isSigner: false, isWritable: true },
+        { pubkey: accounts.bondMint, isSigner: false, isWritable: false },
+        { pubkey: bondVault, isSigner: false, isWritable: true },
+        { pubkey: accounts.kaminoLendingMarket, isSigner: false, isWritable: false },
+        { pubkey: accounts.kaminoLendingMarketAuthority, isSigner: false, isWritable: false },
+        { pubkey: accounts.kaminoReserve, isSigner: false, isWritable: true },
+        { pubkey: accounts.kaminoObligation, isSigner: false, isWritable: true },
+        { pubkey: accounts.kaminoReserveLiquiditySupply, isSigner: false, isWritable: true },
+        { pubkey: accounts.kaminoReserveCollateralMint, isSigner: false, isWritable: true },
+        { pubkey: accounts.bondVaultCollateralAta, isSigner: false, isWritable: true },
+        { pubkey: accounts.kaminoProgram, isSigner: false, isWritable: false },
+        { pubkey: accounts.yieldRouter, isSigner: true, isWritable: false },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+    ];
+}
+export function buildRouteToKaminoIx(accounts, amount, programId = PROGRAM_ID) {
+    const [lpPosition] = findLpPositionPda(accounts.agent, LP_KIND_KAMINO, programId);
+    const [bondVault] = findBondVaultPda(accounts.agent, programId);
+    return new TransactionInstruction({
+        programId,
+        keys: kaminoKeys(accounts, lpPosition, bondVault, /* agentWritable */ false),
+        data: Buffer.concat([INSTRUCTION_DISC.routeToKamino, u64LE(amount)]),
+    });
+}
+export function buildHarvestKaminoYieldIx(accounts, yieldAmount, programId = PROGRAM_ID) {
+    const [lpPosition] = findLpPositionPda(accounts.agent, LP_KIND_KAMINO, programId);
+    const [bondVault] = findBondVaultPda(accounts.agent, programId);
+    return new TransactionInstruction({
+        programId,
+        keys: kaminoKeys(accounts, lpPosition, bondVault, /* agentWritable */ true),
+        data: Buffer.concat([INSTRUCTION_DISC.harvestKaminoYield, u64LE(yieldAmount)]),
+    });
+}
+export function buildUnrouteFromKaminoIx(accounts, amount, reason, programId = PROGRAM_ID) {
+    const [lpPosition] = findLpPositionPda(accounts.agent, LP_KIND_KAMINO, programId);
+    const [bondVault] = findBondVaultPda(accounts.agent, programId);
+    return new TransactionInstruction({
+        programId,
+        keys: kaminoKeys(accounts, lpPosition, bondVault, /* agentWritable */ false),
+        data: Buffer.concat([
+            INSTRUCTION_DISC.unrouteFromKamino,
+            u64LE(amount),
+            Buffer.from([reason]),
+        ]),
+    });
+}
+export function buildInitProtocolConfigIx(accounts, initialArbiter, programId = PROGRAM_ID) {
+    const [config] = findProtocolConfigPda(programId);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: config, isSigner: false, isWritable: true },
+            { pubkey: accounts.admin, isSigner: true, isWritable: true },
+            { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        data: Buffer.concat([INSTRUCTION_DISC.initProtocolConfig, initialArbiter.toBuffer()]),
+    });
+}
+export function buildSetProtocolArbiterIx(accounts, newArbiter, programId = PROGRAM_ID) {
+    const [config] = findProtocolConfigPda(programId);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: config, isSigner: false, isWritable: true },
+            { pubkey: accounts.admin, isSigner: true, isWritable: false },
+        ],
+        data: Buffer.concat([INSTRUCTION_DISC.setProtocolArbiter, newArbiter.toBuffer()]),
+    });
+}
+export function buildRequestCreditIx(accounts, amount, programId = PROGRAM_ID) {
+    const [bondVault] = findBondVaultPda(accounts.agent, programId);
+    const [creditLine] = findCreditLinePda(accounts.agent, programId);
+    const [pool] = findPoolConfigPda(programId);
+    const [poolVault] = findPoolVaultPda(programId);
+    const [poolMintAuth] = findPoolMintAuthPda(programId);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: true },
+            { pubkey: creditLine, isSigner: false, isWritable: true },
+            { pubkey: bondVault, isSigner: false, isWritable: true },
+            { pubkey: pool, isSigner: false, isWritable: true },
+            { pubkey: poolVault, isSigner: false, isWritable: true },
+            { pubkey: poolMintAuth, isSigner: false, isWritable: false },
+            { pubkey: accounts.controller, isSigner: true, isWritable: true },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+            { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        ],
+        data: Buffer.concat([INSTRUCTION_DISC.requestCredit, u64LE(amount)]),
+    });
+}
+export function buildRepayCreditIx(accounts, amount, programId = PROGRAM_ID) {
+    const [bondVault] = findBondVaultPda(accounts.agent, programId);
+    const [creditLine] = findCreditLinePda(accounts.agent, programId);
+    const [pool] = findPoolConfigPda(programId);
+    const [poolVault] = findPoolVaultPda(programId);
+    return new TransactionInstruction({
+        programId,
+        keys: [
+            { pubkey: accounts.agent, isSigner: false, isWritable: false },
+            { pubkey: creditLine, isSigner: false, isWritable: true },
+            { pubkey: bondVault, isSigner: false, isWritable: true },
+            { pubkey: pool, isSigner: false, isWritable: true },
+            { pubkey: poolVault, isSigner: false, isWritable: true },
+            { pubkey: accounts.payer, isSigner: true, isWritable: false },
+            { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data: Buffer.concat([INSTRUCTION_DISC.repayCredit, u64LE(amount)]),
+    });
+}
+//# sourceMappingURL=instructions.js.map