@intent-engine/solver 0.1.35 → 0.1.37

package/dist/src/solver.d.ts

@@ -3,7 +3,8 @@ import { type Config, type Intent } from "@intent-engine/core";
 import { type Backoff } from "./backoff.js";
 import { type Tip } from "./build.js";
 import type { Pricer } from "./market.js";
-import { type Strategy } from "./plan.js";
+import { type Plan, type Strategy } from "./plan.js";
+import { type Hold } from "./holds.js";
 export { BACKOFF_MAX_INTERVALS, type Backoff, backingOff, backoff } from "./backoff.js";
 export { createdRent, DEFAULT_MAX_RENT, DEFAULT_MAX_SOL_COST, LAMPORTS_PER_SIGNATURE, MICRO_LAMPORTS_PER_LAMPORT, mintExtensions, rentExempt, type SolCost, signaturesOf, solCost, TOKEN_2022_ACCOUNT_SPACE, TOKEN_2022_PROGRAM, TOKEN_ACCOUNT_SPACE, tokenAccountSpace, tooCostly, tooMuchRent, } from "./costs.js";
 export type Chain = {
@@ -42,22 +43,30 @@ export type SolverOptions = {
     maxSolCost?: bigint;
     maxRent?: bigint;
     backoff?: Backoff;
+    concurrency?: number;
+    planned?(intent: Address): void;
+    held?(account: Address): bigint;
     unitPrice(instructions: readonly Instruction[]): Promise<bigint>;
     simulate(wire: Base64EncodedWireTransaction, watch: readonly Address[]): Promise<Simulated>;
     send(wire: Base64EncodedWireTransaction): Promise<Sent>;
+    sendBundle?: (wires: readonly Base64EncodedWireTransaction[]) => Promise<string>;
+    bundleSize?: number;
 };
 export type Report = {
     filled: {
         intent: Address;
         profit: bigint;
+        cost: bigint;
         signature: string;
         rent?: bigint;
     }[];
     sent: {
         intent: Address;
         profit: bigint;
+        cost: bigint;
         signature: string;
         rent?: bigint;
+        holds?: Hold;
     }[];
     skipped: {
         intent: Address;
@@ -73,22 +82,10 @@ export declare const SIMULATION_REFUSED = "the fill failed in simulation, so it
 export declare const BALANCES_REFUSED = "the fill would leave the solver with less of a token than planned, so it was not sent";
 export declare const ROUTE_ACCOUNT_BUDGETS: readonly [40, 30, 20];
 export declare const tooLarge: (bytes: number | null, accounts: number) => string;
+export declare const DEFAULT_CONCURRENCY = 4;
+export declare const MAX_CONCURRENCY = 32;
+export declare const badConcurrency: (value: number) => string;
+export declare const ALREADY_FILLING = "the order already has a fill in this tick";
+export declare const INVENTORY_SPENT = "the solver no longer holds enough of the output token for this fill";
+export declare function firstToSend(a: Plan, b: Plan): number;
 export declare function tick(o: SolverOptions): Promise<Report>;
-export type Flight = {
-    until: bigint;
-    signature: string;
-};
-export declare const FAILED_ON_CHAIN = "the fill was sent but failed on chain";
-export declare function landings(flights: Map<Address, Flight>, now: bigint, listed: readonly {
-    address: Address;
-    intent: Intent;
-}[], failedOnChain: (signature: string) => Promise<boolean>, held: Backoff): Promise<{
-    intent: Address;
-    error: string;
-}[]>;
-export declare const CONFIG_TTL_MS = 30000;
-export declare const BLOCKHASH_TTL_MS = 20000;
-export type Remembering = Chain & {
-    forget(): void;
-};
-export declare function remembering(chain: Chain, clock?: () => number): Remembering;

package/dist/src/solver.js

@@ -1,21 +1,218 @@
 import {} from "@solana/kit";
-import { findAssociatedTokenAddress, IntentStatus } from "@intent-engine/core";
+import { findAssociatedTokenAddress } from "@intent-engine/core";
 import { backingOff } from "./backoff.js";
 import { createdRent, DEFAULT_MAX_RENT, DEFAULT_MAX_SOL_COST, signaturesOf, solCost, tooCostly, tooMuchRent } from "./costs.js";
 import { accountsOf, bytesFit, compile, fillInstructions, headroom, locksFit, lookupTablesOf, MAX_COMPUTE_UNITS, MAX_TX_ACCOUNTS, PACKET_DATA_SIZE, payoutAccounts, wireSize, } from "./build.js";
+import { bundleSizeFits, badBundleSize, sendBundles, withoutTip } from "./bundle.js";
+import { MAX_BUNDLE } from "./jito.js";
 import { RateLimited } from "./jupiter.js";
 import { decide, standing } from "./plan.js";
+import { netShort, solValueFits } from "./net.js";
+import { freshly, fromCache } from "./quote-cache.js";
+import { spend, stockLeft } from "./inventory.js";
+import { unheld } from "./holds.js";
 export { BACKOFF_MAX_INTERVALS, backingOff, backoff } from "./backoff.js";
 export { createdRent, DEFAULT_MAX_RENT, DEFAULT_MAX_SOL_COST, LAMPORTS_PER_SIGNATURE, MICRO_LAMPORTS_PER_LAMPORT, mintExtensions, rentExempt, signaturesOf, solCost, TOKEN_2022_ACCOUNT_SPACE, TOKEN_2022_PROGRAM, TOKEN_ACCOUNT_SPACE, tokenAccountSpace, tooCostly, tooMuchRent, } from "./costs.js";
 export const SIMULATION_REFUSED = "the fill failed in simulation, so it was not sent";
 export const BALANCES_REFUSED = "the fill would leave the solver with less of a token than planned, so it was not sent";
 export const ROUTE_ACCOUNT_BUDGETS = [40, 30, 20];
 export const tooLarge = (bytes, accounts) => `even the smallest route makes the fill ${bytes === null ? "lock" : `${bytes} bytes with`} ${accounts} accounts; a transaction holds ${PACKET_DATA_SIZE} bytes and ${MAX_TX_ACCOUNTS} accounts`;
+export const DEFAULT_CONCURRENCY = 4;
+export const MAX_CONCURRENCY = 32;
+export const badConcurrency = (value) => `concurrency must be an integer from 1 to ${MAX_CONCURRENCY}, not ${value}`;
+export const ALREADY_FILLING = "the order already has a fill in this tick";
+export const INVENTORY_SPENT = "the solver no longer holds enough of the output token for this fill";
+export function firstToSend(a, b) {
+    if (a.profit !== b.profit) {
+        return a.profit > b.profit ? -1 : 1;
+    }
+    if (a.intent.expiresAt !== b.intent.expiresAt) {
+        return a.intent.expiresAt < b.intent.expiresAt ? -1 : 1;
+    }
+    return a.address < b.address ? -1 : a.address > b.address ? 1 : 0;
+}
+const skipped = (intent, reason, rent) => ({
+    kind: "skipped",
+    entry: { intent, reason, ...(rent === undefined ? {} : { rent }) },
+});
+const failed = (intent, error) => ({ kind: "failed", entry: { intent, error } });
+const messageOf = (error) => (error instanceof Error ? error.message : String(error));
+async function planOrder(o, config, now, address, intent) {
+    const ready = standing(intent, config, now, o.strategy);
+    if (typeof ready === "string") {
+        return skipped(address, ready);
+    }
+    const waiting = o.backoff?.waiting(address, intent) ?? null;
+    if (waiting !== null) {
+        return skipped(address, backingOff(waiting.failures, waiting.seconds));
+    }
+    const [inputTokenProgram, outputTokenProgram] = await Promise.all([
+        o.chain.tokenProgram(intent.inputMint),
+        o.chain.tokenProgram(intent.outputMint),
+    ]);
+    const payable = async (draft) => {
+        const payouts = await payoutAccounts(draft, config.feeRecipient, inputTokenProgram);
+        const found = await Promise.all(payouts.map((payout) => o.chain.exists(payout.address)));
+        const missing = payouts.filter((_, i) => !found[i]).map((payout) => payout.name);
+        return missing.length === 0 ? null : `no ${missing.join(" or ")} account to pay into`;
+    };
+    const solverInput = await findAssociatedTokenAddress({
+        owner: o.solver.address,
+        mint: intent.inputMint,
+        tokenProgram: inputTokenProgram,
+    });
+    const solverOutput = await findAssociatedTokenAddress({
+        owner: o.solver.address,
+        mint: intent.outputMint,
+        tokenProgram: outputTokenProgram,
+    });
+    const [inputExists, outputExists, latest] = await Promise.all([
+        o.chain.exists(solverInput),
+        o.chain.exists(solverOutput),
+        o.chain.blockhash(),
+    ]);
+    const draft = {
+        solver: o.solver,
+        feeRecipient: config.feeRecipient,
+        inputTokenProgram,
+        outputTokenProgram,
+        computeUnits: MAX_COMPUTE_UNITS,
+        unitPrice: 0n,
+        createSolverInput: !inputExists,
+        createSolverOutput: !outputExists,
+        tip: o.tip,
+    };
+    o.planned?.(address);
+    let size = { bytes: null, accounts: 0 };
+    for (const routeAccounts of ROUTE_ACCOUNT_BUDGETS) {
+        const budget = { ...o.strategy, routeAccounts };
+        const first = await decide(address, intent, config, now, o.pricer, o.solver.address, budget, payable);
+        const decision = first.kind === "fill" && fromCache(first.plan.route)
+            ? await decide(address, intent, config, now, freshly(o.pricer), o.solver.address, budget, payable)
+            : first;
+        if (decision.kind === "skip") {
+            return skipped(address, decision.reason);
+        }
+        const plan = decision.plan;
+        const context = { ...draft, unitPrice: await o.unitPrice(await fillInstructions(plan, draft)) };
+        const instructions = await fillInstructions(plan, context);
+        const accounts = accountsOf(instructions, o.solver.address);
+        if (!locksFit(accounts)) {
+            size = { bytes: null, accounts };
+            continue;
+        }
+        const tables = await o.chain.lookupTables(lookupTablesOf(plan, o.lookupTables));
+        const probe = await compile(instructions, o.solver, latest, tables);
+        const bytes = wireSize(probe);
+        size = { bytes, accounts };
+        if (bytesFit(bytes)) {
+            return { kind: "ready", ready: { plan, context, tables, probe, latest, solverInput, solverOutput } };
+        }
+    }
+    return skipped(address, tooLarge(size.bytes, size.accounts));
+}
+async function untipped(o, ready) {
+    if (ready.context.tip === null) {
+        return { kind: "ready", ready };
+    }
+    const bare = await withoutTip(ready.plan, ready.context, o.solver, ready.latest, ready.tables, o.unitPrice);
+    return "probe" in bare ? { kind: "ready", ready: { ...ready, ...bare } } : skipped(ready.plan.address, tooLarge(bare.bytes, bare.accounts));
+}
+async function checkOrder(o, caps, mintData, ready, stock) {
+    const { plan, context, tables, probe, latest, solverInput, solverOutput } = ready;
+    const address = plan.address;
+    const before = await Promise.all([o.chain.tokenAmount(solverInput), o.chain.tokenAmount(solverOutput)]);
+    const free = unheld(before[1] ?? 0n, o.held?.(solverOutput) ?? 0n);
+    const left = stockLeft(stock, solverOutput, free);
+    if (plan.route.inventory === true && left < plan.required) {
+        return skipped(address, `${INVENTORY_SPENT}: ${left} left, ${plan.required} needed`);
+    }
+    const simulated = await o.simulate(probe, [solverInput, solverOutput]);
+    if (simulated.err !== null) {
+        return failed(address, `${SIMULATION_REFUSED}: ${simulated.err}`);
+    }
+    const [inputAfter, outputAfter] = simulated.balances;
+    const least = plan.route.inventory === true
+        ? [(before[0] ?? 0n) + plan.fees.net, (before[1] ?? 0n) - plan.required]
+        : [before[0] ?? 0n, (before[1] ?? 0n) + plan.profit];
+    if (inputAfter === null || inputAfter === undefined || outputAfter === null || outputAfter === undefined || inputAfter < (least[0] ?? 0n) || outputAfter < (least[1] ?? 0n)) {
+        return failed(address, `${BALANCES_REFUSED}: input ${before[0]} to ${inputAfter}, output ${before[1]} to ${outputAfter}, expected at least ${least[0]} and ${least[1]}`);
+    }
+    const final = simulated.unitsConsumed === null ? context : { ...context, computeUnits: headroom(simulated.unitsConsumed) };
+    const instructions = await fillInstructions(plan, final);
+    const wire = simulated.unitsConsumed === null ? probe : await compile(instructions, o.solver, latest, tables);
+    const cost = solCost({
+        signatures: signaturesOf(wire),
+        unitPrice: final.unitPrice,
+        computeUnits: final.computeUnits,
+        tip: final.tip?.lamports ?? 0n,
+    });
+    const rent = await createdRent(instructions, (account) => o.chain.exists(account), mintData);
+    const kept = rent > 0n ? rent : undefined;
+    if (cost > caps.cost) {
+        return skipped(address, tooCostly(cost, caps.cost), kept);
+    }
+    if (rent > caps.rent) {
+        return skipped(address, tooMuchRent(rent, caps.rent), kept);
+    }
+    const short = netShort(plan, o.strategy.minProfit.get(plan.intent.outputMint) ?? 0n, cost, o.strategy.solValue);
+    if (short !== null) {
+        return skipped(address, short, kept);
+    }
+    if (wire !== probe) {
+        const checked = await o.simulate(wire, [solverInput, solverOutput]);
+        if (checked.err !== null) {
+            return failed(address, `${SIMULATION_REFUSED}: ${checked.err}`);
+        }
+    }
+    return {
+        kind: "checked",
+        wire,
+        entry: { intent: address, profit: plan.profit, cost, ...(kept === undefined ? {} : { rent: kept }) },
+        ...(plan.route.inventory === true ? { holds: { account: solverOutput, amount: plan.required } } : {}),
+        spend: () => {
+            if (plan.route.inventory === true) {
+                spend(stock, solverOutput, free, plan.required);
+            }
+        },
+    };
+}
+async function fillOrder(o, caps, mintData, ready, stock) {
+    const checked = await checkOrder(o, caps, mintData, ready, stock);
+    if (checked.kind !== "checked") {
+        return checked;
+    }
+    const sent = await o.send(checked.wire);
+    checked.spend();
+    const holds = !sent.confirmed && checked.holds !== undefined ? { holds: checked.holds } : {};
+    return { kind: sent.confirmed ? "filled" : "sent", entry: { ...checked.entry, signature: sent.signature, ...holds } };
+}
+async function queueOrder(o, caps, mintData, ready, stock) {
+    const bare = await untipped(o, ready);
+    if (bare.kind !== "ready") {
+        return bare;
+    }
+    const checked = await checkOrder(o, caps, mintData, bare.ready, stock);
+    if (checked.kind === "checked") {
+        checked.spend();
+    }
+    return checked;
+}
 export async function tick(o) {
-    const report = { filled: [], sent: [], skipped: [], failed: [] };
+    const concurrency = o.concurrency ?? DEFAULT_CONCURRENCY;
+    if (!Number.isInteger(concurrency) || concurrency < 1 || concurrency > MAX_CONCURRENCY) {
+        throw new RangeError(badConcurrency(concurrency));
+    }
+    const bundleSize = o.bundleSize ?? MAX_BUNDLE;
+    if (!bundleSizeFits(bundleSize)) {
+        throw new RangeError(badBundleSize(bundleSize));
+    }
+    const invalid = solValueFits(o.strategy.solValue);
+    if (invalid !== null) {
+        throw new RangeError(invalid);
+    }
     const [config, now, intents] = await Promise.all([o.chain.config(), o.chain.now(), o.chain.intents()]);
-    const cap = o.maxSolCost ?? DEFAULT_MAX_SOL_COST;
-    const rentCap = o.maxRent ?? DEFAULT_MAX_RENT;
+    const caps = { cost: o.maxSolCost ?? DEFAULT_MAX_SOL_COST, rent: o.maxRent ?? DEFAULT_MAX_RENT };
     const mints = new Map();
     const mintData = (mint) => {
         const known = mints.get(mint);
@@ -26,141 +223,124 @@ export async function tick(o) {
         mints.set(mint, loaded);
         return loaded;
     };
+    const outcomes = intents.map(() => undefined);
+    const planned = [];
     let limited = null;
-    for (const { address, intent } of intents) {
-        if (limited !== null) {
-            report.skipped.push({ intent: address, reason: limited });
-            continue;
+    let next = 0;
+    const planner = async () => {
+        for (let index = next; limited === null && index < intents.length; index = next) {
+            next = index + 1;
+            const entry = intents[index];
+            if (entry === undefined) {
+                continue;
+            }
+            const { address, intent } = entry;
+            try {
+                const result = await planOrder(o, config, now, address, intent);
+                if (result.kind === "ready") {
+                    planned.push({ index, ready: result.ready });
+                }
+                else {
+                    outcomes[index] = result;
+                }
+            }
+            catch (error) {
+                if (error instanceof RateLimited) {
+                    limited ??= error.message;
+                    outcomes[index] = skipped(address, error.message);
+                }
+                else {
+                    outcomes[index] = failed(address, messageOf(error));
+                }
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, intents.length) }, planner));
+    if (limited !== null) {
+        for (let index = next; index < intents.length; index += 1) {
+            const address = intents[index]?.address;
+            if (address !== undefined) {
+                outcomes[index] = skipped(address, limited);
+            }
         }
-        const ready = standing(intent, config, now, o.strategy);
-        if (typeof ready === "string") {
-            report.skipped.push({ intent: address, reason: ready });
+    }
+    planned.sort((a, b) => firstToSend(a.ready.plan, b.ready.plan) || a.index - b.index);
+    const filling = new Set();
+    const stock = new Map();
+    const queue = [];
+    let halted = null;
+    for (const { index, ready } of planned) {
+        const address = ready.plan.address;
+        if (halted !== null) {
+            outcomes[index] = skipped(address, halted);
             continue;
         }
-        const waiting = o.backoff?.waiting(address, intent) ?? null;
-        if (waiting !== null) {
-            report.skipped.push({ intent: address, reason: backingOff(waiting.failures, waiting.seconds) });
+        if (filling.has(address)) {
+            outcomes[index] = skipped(address, ALREADY_FILLING);
             continue;
         }
+        filling.add(address);
         try {
-            const [inputTokenProgram, outputTokenProgram] = await Promise.all([
-                o.chain.tokenProgram(intent.inputMint),
-                o.chain.tokenProgram(intent.outputMint),
-            ]);
-            const payable = async (draft) => {
-                const payouts = await payoutAccounts(draft, config.feeRecipient, inputTokenProgram);
-                const found = await Promise.all(payouts.map((payout) => o.chain.exists(payout.address)));
-                const missing = payouts.filter((_, i) => !found[i]).map((payout) => payout.name);
-                return missing.length === 0 ? null : `no ${missing.join(" or ")} account to pay into`;
-            };
-            const solverInput = await findAssociatedTokenAddress({
-                owner: o.solver.address,
-                mint: intent.inputMint,
-                tokenProgram: inputTokenProgram,
-            });
-            const solverOutput = await findAssociatedTokenAddress({
-                owner: o.solver.address,
-                mint: intent.outputMint,
-                tokenProgram: outputTokenProgram,
-            });
-            const [inputExists, outputExists, latest] = await Promise.all([
-                o.chain.exists(solverInput),
-                o.chain.exists(solverOutput),
-                o.chain.blockhash(),
-            ]);
-            const draft = {
-                solver: o.solver,
-                feeRecipient: config.feeRecipient,
-                inputTokenProgram,
-                outputTokenProgram,
-                computeUnits: MAX_COMPUTE_UNITS,
-                unitPrice: 0n,
-                createSolverInput: !inputExists,
-                createSolverOutput: !outputExists,
-                tip: o.tip,
-            };
-            let fitting = null;
-            let skipped = null;
-            let size = { bytes: null, accounts: 0 };
-            for (const routeAccounts of ROUTE_ACCOUNT_BUDGETS) {
-                const decision = await decide(address, intent, config, now, o.pricer, o.solver.address, { ...o.strategy, routeAccounts }, payable);
-                if (decision.kind === "skip") {
-                    skipped = decision.reason;
-                    break;
-                }
-                const plan = decision.plan;
-                const context = { ...draft, unitPrice: await o.unitPrice(await fillInstructions(plan, draft)) };
-                const instructions = await fillInstructions(plan, context);
-                const accounts = accountsOf(instructions, o.solver.address);
-                if (!locksFit(accounts)) {
-                    size = { bytes: null, accounts };
-                    continue;
+            if (o.sendBundle === undefined) {
+                outcomes[index] = await fillOrder(o, caps, mintData, ready, stock);
+            }
+            else {
+                const checked = await queueOrder(o, caps, mintData, ready, stock);
+                if (checked.kind === "checked") {
+                    queue.push({ index, ready, wire: checked.wire, entry: checked.entry, ...(checked.holds === undefined ? {} : { holds: checked.holds }) });
                 }
-                const tables = await o.chain.lookupTables(lookupTablesOf(plan, o.lookupTables));
-                const probe = await compile(instructions, o.solver, latest, tables);
-                const bytes = wireSize(probe);
-                size = { bytes, accounts };
-                if (bytesFit(bytes)) {
-                    fitting = { plan, context, tables, probe };
-                    break;
+                else {
+                    outcomes[index] = checked;
                 }
             }
-            if (skipped !== null || fitting === null) {
-                report.skipped.push({ intent: address, reason: skipped ?? tooLarge(size.bytes, size.accounts) });
-                continue;
-            }
-            const { plan, context, tables, probe } = fitting;
-            const before = await Promise.all([o.chain.tokenAmount(solverInput), o.chain.tokenAmount(solverOutput)]);
-            const simulated = await o.simulate(probe, [solverInput, solverOutput]);
-            if (simulated.err !== null) {
-                report.failed.push({ intent: address, error: `${SIMULATION_REFUSED}: ${simulated.err}` });
-                continue;
-            }
-            const [inputAfter, outputAfter] = simulated.balances;
-            const least = [before[0] ?? 0n, (before[1] ?? 0n) + plan.profit];
-            if (inputAfter === null || inputAfter === undefined || outputAfter === null || outputAfter === undefined || inputAfter < (least[0] ?? 0n) || outputAfter < (least[1] ?? 0n)) {
-                report.failed.push({
-                    intent: address,
-                    error: `${BALANCES_REFUSED}: input ${before[0]} to ${inputAfter}, output ${before[1]} to ${outputAfter}, expected at least ${least[0]} and ${least[1]}`,
-                });
-                continue;
+        }
+        catch (error) {
+            if (error instanceof RateLimited) {
+                halted = error.message;
+                outcomes[index] = skipped(address, halted);
             }
-            const final = simulated.unitsConsumed === null ? context : { ...context, computeUnits: headroom(simulated.unitsConsumed) };
-            const instructions = await fillInstructions(plan, final);
-            const wire = simulated.unitsConsumed === null ? probe : await compile(instructions, o.solver, latest, tables);
-            const cost = solCost({
-                signatures: signaturesOf(wire),
-                unitPrice: final.unitPrice,
-                computeUnits: final.computeUnits,
-                tip: final.tip?.lamports ?? 0n,
-            });
-            const rent = await createdRent(instructions, (account) => o.chain.exists(account), mintData);
-            const kept = rent > 0n ? { rent } : {};
-            if (cost > cap) {
-                report.skipped.push({ intent: address, reason: tooCostly(cost, cap), ...kept });
-                continue;
+            else {
+                outcomes[index] = failed(address, messageOf(error));
             }
-            if (rent > rentCap) {
-                report.skipped.push({ intent: address, reason: tooMuchRent(rent, rentCap), ...kept });
-                continue;
+        }
+    }
+    if (o.sendBundle !== undefined) {
+        const last = async (item) => {
+            const { ready, wire } = item;
+            if (o.tip === null) {
+                return wire;
             }
-            if (wire !== probe) {
-                const checked = await o.simulate(wire, [solverInput, solverOutput]);
-                if (checked.err !== null) {
-                    report.failed.push({ intent: address, error: `${SIMULATION_REFUSED}: ${checked.err}` });
-                    continue;
+            try {
+                const checked = await checkOrder(o, caps, mintData, ready, new Map());
+                if (checked.kind !== "checked") {
+                    return checked;
                 }
+                item.entry = checked.entry;
+                return checked.wire;
             }
-            const sent = await o.send(wire);
-            (sent.confirmed ? report.filled : report.sent).push({ intent: address, profit: plan.profit, signature: sent.signature, ...kept });
-        }
-        catch (error) {
-            if (error instanceof RateLimited) {
-                limited = error.message;
-                report.skipped.push({ intent: address, reason: limited });
-                continue;
+            catch (error) {
+                return error instanceof RateLimited ? skipped(ready.plan.address, error.message) : failed(ready.plan.address, messageOf(error));
             }
-            report.failed.push({ intent: address, error: error instanceof Error ? error.message : String(error) });
+        };
+        for (const done of await sendBundles(queue, bundleSize, o.sendBundle, last)) {
+            outcomes[done.item.index] =
+                "refused" in done
+                    ? done.refused
+                    : "error" in done
+                        ? failed(done.item.ready.plan.address, done.error)
+                        : { kind: "sent", entry: { ...done.item.entry, signature: done.signature, ...(done.item.holds === undefined ? {} : { holds: done.item.holds }) } };
+        }
+    }
+    const report = { filled: [], sent: [], skipped: [], failed: [] };
+    for (const outcome of outcomes) {
+        if (outcome?.kind === "skipped") {
+            report.skipped.push(outcome.entry);
+        }
+        else if (outcome?.kind === "failed") {
+            report.failed.push(outcome.entry);
+        }
+        else if (outcome !== undefined) {
+            report[outcome.kind].push(outcome.entry);
         }
     }
     if (o.backoff !== undefined) {
@@ -177,103 +357,4 @@ export async function tick(o) {
     }
     return report;
 }
-export const FAILED_ON_CHAIN = "the fill was sent but failed on chain";
-export async function landings(flights, now, listed, failedOnChain, held) {
-    const failed = [];
-    for (const { address, intent } of listed) {
-        const flight = flights.get(address);
-        if (flight === undefined || flight.until > now) {
-            continue;
-        }
-        flights.delete(address);
-        if (intent.status !== IntentStatus.Open) {
-            continue;
-        }
-        const lost = await failedOnChain(flight.signature).catch(() => false);
-        if (lost) {
-            held.failed(address, intent);
-            failed.push({ intent: address, error: `${FAILED_ON_CHAIN}: ${flight.signature}` });
-        }
-    }
-    return failed;
-}
-export const CONFIG_TTL_MS = 30_000;
-export const BLOCKHASH_TTL_MS = 20_000;
-function fresh(ttl, clock, load) {
-    let held = null;
-    return {
-        get: () => {
-            if (held === null || clock() - held.at > ttl) {
-                const value = load();
-                const entry = { at: clock(), value };
-                held = entry;
-                value.catch(() => {
-                    if (held === entry) {
-                        held = null;
-                    }
-                });
-            }
-            return held.value;
-        },
-        clear: () => {
-            held = null;
-        },
-    };
-}
-export function remembering(chain, clock = Date.now) {
-    const programs = new Map();
-    const mints = new Map();
-    const existing = new Set();
-    const config = fresh(CONFIG_TTL_MS, clock, () => chain.config());
-    const blockhash = fresh(BLOCKHASH_TTL_MS, clock, () => chain.blockhash());
-    return {
-        ...chain,
-        config: () => config.get(),
-        blockhash: () => blockhash.get(),
-        tokenProgram: (mint) => {
-            const known = programs.get(mint);
-            if (known !== undefined) {
-                return known;
-            }
-            const loaded = chain.tokenProgram(mint);
-            programs.set(mint, loaded);
-            loaded.catch(() => programs.delete(mint));
-            return loaded;
-        },
-        ...(chain.mintData === undefined
-            ? {}
-            : {
-                mintData: (mint) => {
-                    const known = mints.get(mint);
-                    if (known !== undefined) {
-                        return known;
-                    }
-                    const loaded = chain.mintData?.(mint) ?? Promise.resolve(null);
-                    mints.set(mint, loaded);
-                    loaded.then((data) => {
-                        if (data === null) {
-                            mints.delete(mint);
-                        }
-                    }, () => mints.delete(mint));
-                    return loaded;
-                },
-            }),
-        exists: async (address) => {
-            if (existing.has(address)) {
-                return true;
-            }
-            const found = await chain.exists(address);
-            if (found) {
-                existing.add(address);
-            }
-            return found;
-        },
-        forget: () => {
-            programs.clear();
-            existing.clear();
-            config.clear();
-            blockhash.clear();
-        },
-    };
-}
 //# sourceMappingURL=solver.js.map