@zga/client 0.0.0-stage → 0.1.1

package/dist/crank/lending.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLoanLiquidatable = isLoanLiquidatable;
+exports.lendingFeesTask = lendingFeesTask;
+exports.lendingLiquidationTask = lendingLiquidationTask;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@coral-xyz/anchor");
+const chain_1 = require("../chain");
+const lending_1 = require("../lending");
+const token_1 = require("../token");
+const LOAN_DISCRIMINATOR = [68, 228, 171, 3, 182, 214, 23, 125];
+const E9 = 1000000000n;
+const BPS = 10000n;
+const YEAR_SECS = 31536000n;
+const GRACE_SECS = 604800n;
+const big = (x) => BigInt(x.toString());
+const short = (e) => String(e?.message ?? e).slice(0, 160);
+const cu = (units) => [web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units })];
+function isLoanLiquidatable(f) {
+    if (f.now > f.dueAt + GRACE_SECS)
+        return true;
+    const age = f.now > f.accruedAt ? f.now - f.accruedAt : 0n;
+    const owed = f.principal + (f.principal * f.rateBps * age) / (BPS * YEAR_SECS);
+    const debtUsd = (owed * f.borrowPriceE9 + E9 - 1n) / E9;
+    if (debtUsd === 0n)
+        return false;
+    const collateralUsd = (f.collateralAmount * f.collateralScaleTo9 * f.collateralPriceE9) / E9;
+    return (collateralUsd * BPS) / debtUsd <= f.thresholdBps;
+}
+function lendingPdas(pid) {
+    const b = (s) => Buffer.from(s);
+    return {
+        lpLock: (0, chain_1.lpLockPda)(pid),
+        stakingVault: (0, chain_1.pda)(pid, b('staking_vault')),
+        stakingPool: (0, chain_1.pda)(pid, b('staking_pool')),
+        zgapReserve: (0, chain_1.pda)(pid, b('zgap_reserve')),
+        zgapMint: (0, chain_1.pda)(pid, b('zgap_mint')),
+        zgapAuthority: (0, chain_1.pda)(pid, b('zgap_authority')),
+        collateralVault: (0, chain_1.pda)(pid, b('zgap_collateral_vault')),
+        solVault: (0, chain_1.pda)(pid, b('zgap_sol_vault')),
+        reserveSol: (0, chain_1.pda)(pid, b('zgap_reserve_sol')),
+    };
+}
+function lendingFeesTask(everyMs = 3600000) {
+    return {
+        name: 'lending-fees',
+        everyMs,
+        async run(ctx) {
+            const pid = ctx.program.programId;
+            const p = lendingPdas(pid);
+            const feeAccount = (0, lending_1.lendingFeeAddress)(pid);
+            const held = await ctx.connection.getAccountInfo(feeAccount);
+            if (!held)
+                return;
+            const amount = held.data.readBigUInt64LE(64);
+            if (amount === 0n)
+                return;
+            const lock = await ctx.connection.getAccountInfo(p.lpLock);
+            if (!lock)
+                return;
+            const zgaMint = new web3_js_1.PublicKey(lock.data.subarray(0, 32));
+            await ctx.program.methods.routeZnlZgapFees().accountsPartial({
+                protocolRedeem: { zgaPriceCache: (0, chain_1.cachePda)(pid, chain_1.ZGA_ASSET_ID), solPriceCache: (0, chain_1.cachePda)(pid, chain_1.SOL_ASSET_ID), solVault: p.solVault, reserveSolAccount: p.reserveSol },
+                zgapAuthority: p.zgapAuthority, zgapMint: p.zgapMint, collateralVault: p.collateralVault, feeAccount,
+                stakingVault: p.stakingVault, stakingPool: p.stakingPool, lpLockVault: p.lpLock,
+                zgapReserve: p.zgapReserve, reserveZgaAccount: (0, token_1.associatedTokenAddress)(zgaMint, p.zgapReserve), tokenProgram: token_1.TOKEN_PROGRAM_ID,
+            }).preInstructions(cu(400000)).rpc();
+            ctx.log(`lending: ${amount} ZGAP of the protocol's cut routed to the staking yield`);
+        },
+    };
+}
+async function readCache(ctx, pid, assetId) {
+    const info = await ctx.connection.getAccountInfo((0, chain_1.cachePda)(pid, assetId));
+    if (!info)
+        return null;
+    const c = (0, chain_1.decodeAccount)(ctx.program, 'PriceCacheAccount', info.data).cache;
+    return { twap: big(c.twapE9), latest: big(c.latestE9) };
+}
+function lendingLiquidationTask(everyMs = 60000) {
+    const unaffordable = new Set();
+    return {
+        name: 'lending-liquidations',
+        everyMs,
+        async run(ctx) {
+            const pid = ctx.program.programId;
+            const accounts = await ctx.connection.getProgramAccounts(pid, {
+                filters: [{ memcmp: { offset: 0, bytes: anchor_1.utils.bytes.bs58.encode(Buffer.from(LOAN_DISCRIMINATOR)) } }],
+            });
+            if (accounts.length === 0)
+                return;
+            const now = BigInt((await ctx.connection.getBlockTime(await ctx.connection.getSlot())) ?? Math.floor(Date.now() / 1000));
+            const vaults = new Map();
+            const caches = new Map();
+            const cacheOf = async (id) => {
+                if (!caches.has(id))
+                    caches.set(id, await readCache(ctx, pid, id));
+                return caches.get(id) ?? null;
+            };
+            for (const { pubkey, account } of accounts) {
+                try {
+                    const loan = (0, chain_1.decodeAccount)(ctx.program, 'LendingLoan', account.data);
+                    const vaultKey = loan.vault.toBase58();
+                    if (!vaults.has(vaultKey))
+                        vaults.set(vaultKey, await ctx.program.account.lendingVault.fetch(loan.vault));
+                    const vault = vaults.get(vaultKey);
+                    const collateralCache = await cacheOf(Number(vault.collateralAssetId));
+                    const zgaCache = await cacheOf(chain_1.ZGA_ASSET_ID);
+                    if (!collateralCache || !zgaCache)
+                        continue;
+                    const facts = {
+                        principal: big(loan.principal),
+                        collateralAmount: big(loan.collateralAmount),
+                        accruedAt: big(loan.accruedAt),
+                        dueAt: big(loan.dueAt),
+                        rateBps: big(vault.interestRateBps),
+                        thresholdBps: big(vault.liquidationThresholdBps),
+                        collateralScaleTo9: big(vault.collateralScaleTo9),
+                        collateralPriceE9: collateralCache.twap < collateralCache.latest ? collateralCache.twap : collateralCache.latest,
+                        borrowPriceE9: vault.borrowIsZga ? (zgaCache.twap > zgaCache.latest ? zgaCache.twap : zgaCache.latest) : E9,
+                        now,
+                    };
+                    if (!isLoanLiquidatable(facts))
+                        continue;
+                    const owed = facts.principal + (facts.principal * facts.rateBps * (now > facts.accruedAt ? now - facts.accruedAt : 0n)) / (BPS * YEAR_SECS);
+                    const held = await ctx.connection.getTokenAccountBalance((0, token_1.associatedTokenAddress)(vault.borrowMint, ctx.caller.publicKey)).catch(() => null);
+                    if (!held || BigInt(held.value.amount) < owed) {
+                        if (!unaffordable.has(pubkey.toBase58())) {
+                            unaffordable.add(pubkey.toBase58());
+                            ctx.log(`loan ${pubkey.toBase58()} can be liquidated but the caller holds less than the ${owed} it owes in the borrowed asset`);
+                        }
+                        continue;
+                    }
+                    const builder = await (0, lending_1.liquidateLendingLoan)(ctx.program, { loan: pubkey, liquidator: ctx.caller.publicKey });
+                    await builder.preInstructions([...cu(400000)], true).rpc();
+                    unaffordable.delete(pubkey.toBase58());
+                    ctx.log(`loan ${pubkey.toBase58()} liquidated`);
+                }
+                catch (e) {
+                    ctx.log(`loan ${pubkey.toBase58()} not liquidated: ${short(e)}`);
+                }
+            }
+        },
+    };
+}

package/dist/crank/prices.d.ts

@@ -0,0 +1,11 @@
+import { PublicKey } from '@solana/web3.js';
+import { CrankTask } from './runner';
+export interface Feed {
+    assetId: number;
+    address: PublicKey;
+    data: any;
+}
+export declare function quoteAssets(d: any): number[];
+export declare function inDependencyOrder(feeds: Feed[]): Feed[];
+export declare function postDue(now: number, lastTs: number | null, spacing: number, minPostSecs: number): boolean;
+export declare function priceFeedsTask(everyMs?: number, minPostSecs?: number): CrankTask;

package/dist/crank/prices.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quoteAssets = quoteAssets;
+exports.inDependencyOrder = inDependencyOrder;
+exports.postDue = postDue;
+exports.priceFeedsTask = priceFeedsTask;
+const web3_js_1 = require("@solana/web3.js");
+const chain_1 = require("../chain");
+const MAX_ASSETS = 32;
+const SOURCE_SIGNED = 0;
+const SOURCE_POOL = 1;
+const SOURCE_DLMM = 2;
+const SOURCE_FIXED = 3;
+const SOURCE_AGGREGATED = 4;
+const SOURCE_DLMM_AGGREGATED = 5;
+const short = (e) => String(e?.message ?? e).slice(0, 160);
+const cu = (units) => [web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units })];
+async function loadFeeds(ctx) {
+    const pid = ctx.program.programId;
+    const addresses = Array.from({ length: MAX_ASSETS }, (_, id) => (0, chain_1.feedPda)(pid, id));
+    const infos = await ctx.connection.getMultipleAccountsInfo(addresses);
+    const feeds = [];
+    infos.forEach((info, id) => {
+        if (!info || !info.owner.equals(pid))
+            return;
+        feeds.push({ assetId: id, address: addresses[id], data: (0, chain_1.decodeAccount)(ctx.program, 'PriceFeedAccount', info.data) });
+    });
+    return feeds;
+}
+function quoteAssets(d) {
+    if (d.sourceKind === SOURCE_POOL || d.sourceKind === SOURCE_DLMM)
+        return [d.quoteAssetId];
+    if (d.sourceKind === SOURCE_AGGREGATED)
+        return [d.quoteAssetId, d.legs[0].quoteAssetId, d.legs[1].quoteAssetId];
+    if (d.sourceKind === SOURCE_DLMM_AGGREGATED)
+        return [d.quoteAssetId, d.legs[0].quoteAssetId];
+    return [];
+}
+function inDependencyOrder(feeds) {
+    const byAsset = new Map(feeds.map((f) => [f.assetId, f]));
+    const depth = new Map();
+    const walk = (id, seen) => {
+        if (depth.has(id))
+            return depth.get(id);
+        const f = byAsset.get(id);
+        if (!f || seen.has(id))
+            return 0;
+        seen.add(id);
+        const d = 1 + Math.max(-1, ...quoteAssets(f.data).map((q) => walk(q, seen)));
+        depth.set(id, quoteAssets(f.data).length === 0 ? 0 : d);
+        return depth.get(id);
+    };
+    feeds.forEach((f) => walk(f.assetId, new Set()));
+    return [...feeds].sort((a, b) => (depth.get(a.assetId) ?? 0) - (depth.get(b.assetId) ?? 0) || a.assetId - b.assetId);
+}
+function latestSample(d) {
+    if (d.sampleCount === 0)
+        return null;
+    const s = d.samples[d.cursor === 0 ? d.samples.length - 1 : d.cursor - 1];
+    return { ts: Number(s.ts.toString()) };
+}
+async function updateFeed(ctx, f) {
+    const pid = ctx.program.programId;
+    const d = f.data;
+    const m = ctx.program.methods;
+    switch (d.sourceKind) {
+        case SOURCE_FIXED:
+            await m.updatePriceFeedFixed().accountsPartial({ feed: f.address }).rpc();
+            return true;
+        case SOURCE_AGGREGATED:
+            await m.updatePriceFeedAggregated().accountsPartial({
+                feed: f.address,
+                poolA: d.pool, vaultQuoteA: d.vaultQuote, quoteCacheA: (0, chain_1.cachePda)(pid, d.quoteAssetId),
+                poolB: d.legs[0].pool, vaultQuoteB: d.legs[0].vaultQuote, quoteCacheB: (0, chain_1.cachePda)(pid, d.legs[0].quoteAssetId),
+                poolC: d.legs[1].pool, vaultQuoteC: d.legs[1].vaultQuote, quoteCacheC: (0, chain_1.cachePda)(pid, d.legs[1].quoteAssetId),
+            }).preInstructions(cu(400000)).rpc();
+            return true;
+        case SOURCE_DLMM_AGGREGATED:
+            await m.updatePriceFeedDlmmAggregated().accountsPartial({
+                feed: f.address,
+                lbPairA: d.pool, vaultQuoteA: d.vaultQuote, quoteCacheA: (0, chain_1.cachePda)(pid, d.quoteAssetId),
+                lbPairB: d.legs[0].pool, vaultQuoteB: d.legs[0].vaultQuote, quoteCacheB: (0, chain_1.cachePda)(pid, d.legs[0].quoteAssetId),
+            }).preInstructions(cu(400000)).rpc();
+            return true;
+        default:
+            return false;
+    }
+}
+function postDue(now, lastTs, spacing, minPostSecs) {
+    if (lastTs === null)
+        return true;
+    return now - lastTs >= Math.max(spacing + 2, minPostSecs);
+}
+async function updateInstruction(ctx, f) {
+    const pid = ctx.program.programId;
+    const d = f.data;
+    const m = ctx.program.methods;
+    switch (d.sourceKind) {
+        case SOURCE_FIXED:
+            return m.updatePriceFeedFixed().accountsPartial({ feed: f.address }).instruction();
+        case SOURCE_AGGREGATED:
+            return m.updatePriceFeedAggregated().accountsPartial({
+                feed: f.address,
+                poolA: d.pool, vaultQuoteA: d.vaultQuote, quoteCacheA: (0, chain_1.cachePda)(pid, d.quoteAssetId),
+                poolB: d.legs[0].pool, vaultQuoteB: d.legs[0].vaultQuote, quoteCacheB: (0, chain_1.cachePda)(pid, d.legs[0].quoteAssetId),
+                poolC: d.legs[1].pool, vaultQuoteC: d.legs[1].vaultQuote, quoteCacheC: (0, chain_1.cachePda)(pid, d.legs[1].quoteAssetId),
+            }).instruction();
+        case SOURCE_DLMM_AGGREGATED:
+            return m.updatePriceFeedDlmmAggregated().accountsPartial({
+                feed: f.address,
+                lbPairA: d.pool, vaultQuoteA: d.vaultQuote, quoteCacheA: (0, chain_1.cachePda)(pid, d.quoteAssetId),
+                lbPairB: d.legs[0].pool, vaultQuoteB: d.legs[0].vaultQuote, quoteCacheB: (0, chain_1.cachePda)(pid, d.legs[0].quoteAssetId),
+            }).instruction();
+        default:
+            return null;
+    }
+}
+async function postAndCrank(ctx, f) {
+    const pid = ctx.program.programId;
+    try {
+        const update = await updateInstruction(ctx, f);
+        if (!update)
+            return false;
+        const crank = await ctx.program.methods.crankPriceCache().accountsPartial({ cache: (0, chain_1.cachePda)(pid, f.assetId), feed: f.address }).instruction();
+        const tx = new web3_js_1.Transaction().add(web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units: 800000 }), update, crank);
+        await ctx.program.provider.sendAndConfirm(tx);
+        ctx.log(`asset ${f.assetId}: sample added and cache brought up to it`);
+        return true;
+    }
+    catch (e) {
+        ctx.log(`asset ${f.assetId}: the one-transaction post failed, trying two steps: ${short(e)}`);
+        return false;
+    }
+}
+async function crankCacheIfBehind(ctx, f) {
+    const pid = ctx.program.programId;
+    const cacheAddress = (0, chain_1.cachePda)(pid, f.assetId);
+    const cache = await ctx.program.account.priceCacheAccount.fetchNullable(cacheAddress);
+    if (!cache)
+        return;
+    const feed = await ctx.program.account.priceFeedAccount.fetch(f.address);
+    const newest = latestSample(feed);
+    if (!newest || newest.ts <= Number(cache.cache.updatedAt.toString()))
+        return;
+    try {
+        await ctx.program.methods.crankPriceCache().accountsPartial({ cache: cacheAddress, feed: f.address }).preInstructions(cu(400000)).rpc();
+        ctx.log(`asset ${f.assetId}: cache brought up to the newest sample`);
+    }
+    catch (e) {
+        ctx.log(`asset ${f.assetId}: cache not cranked: ${short(e)}`);
+    }
+}
+function priceFeedsTask(everyMs = 30000, minPostSecs = 0) {
+    return {
+        name: 'price-feeds',
+        everyMs,
+        async run(ctx) {
+            for (const f of inDependencyOrder(await loadFeeds(ctx))) {
+                const now = await (0, chain_1.chainTime)(ctx.connection);
+                const last = latestSample(f.data);
+                const spacing = Number(f.data.minSampleSpacingSecs);
+                if (postDue(now, last ? last.ts : null, spacing, minPostSecs)) {
+                    if (await postAndCrank(ctx, f))
+                        continue;
+                    try {
+                        if (await updateFeed(ctx, f))
+                            ctx.log(`asset ${f.assetId}: sample added`);
+                    }
+                    catch (e) {
+                        ctx.log(`asset ${f.assetId}: sample not added: ${short(e)}`);
+                    }
+                }
+                await crankCacheIfBehind(ctx, f);
+            }
+        },
+    };
+}

package/dist/crank/runner.d.ts

@@ -0,0 +1,15 @@
+import { Connection, Keypair } from '@solana/web3.js';
+export interface CrankContext {
+    program: any;
+    connection: Connection;
+    caller: Keypair;
+    log: (message: string) => void;
+}
+export interface CrankTask {
+    name: string;
+    everyMs: number;
+    run(ctx: CrankContext): Promise<void>;
+}
+export declare function runTasks(ctx: CrankContext, tasks: CrankTask[], opts?: {
+    once?: boolean;
+}): Promise<void>;

package/dist/crank/runner.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTasks = runTasks;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function runTasks(ctx, tasks, opts = {}) {
+    const lastRun = new Map();
+    const attempt = async (task) => {
+        try {
+            await task.run(ctx);
+        }
+        catch (e) {
+            ctx.log(`${task.name}: ${String(e?.message ?? e).slice(0, 200)}`);
+        }
+    };
+    if (opts.once) {
+        for (const task of tasks)
+            await attempt(task);
+        return;
+    }
+    for (;;) {
+        const now = Date.now();
+        for (const task of tasks) {
+            if (now - (lastRun.get(task.name) ?? 0) < task.everyMs)
+                continue;
+            lastRun.set(task.name, now);
+            await attempt(task);
+        }
+        await sleep(1000);
+    }
+}

package/dist/crank/shieldFees.d.ts

@@ -0,0 +1,15 @@
+import { PublicKey } from '@solana/web3.js';
+import { CrankTask } from './runner';
+export declare const NATIVE_MINT: PublicKey;
+export type AssetKind = 'zga' | 'sol' | 'zgap' | 'sink';
+export type Route = 'zga' | 'sol' | 'zgap-nop-tax' | 'zgap-fees' | 'sink';
+export interface FeesDue {
+    protocol: bigint;
+    unattributed: bigint;
+}
+export declare function classifyAsset(mint: PublicKey, mints: {
+    zga: PublicKey;
+    zgap: PublicKey;
+}, sink?: PublicKey | null): AssetKind | null;
+export declare function routesFor(kind: AssetKind, due: FeesDue): Route[];
+export declare function shieldFeesTask(everyMs?: number): CrankTask;

package/dist/crank/shieldFees.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NATIVE_MINT = void 0;
+exports.classifyAsset = classifyAsset;
+exports.routesFor = routesFor;
+exports.shieldFeesTask = shieldFeesTask;
+const web3_js_1 = require("@solana/web3.js");
+const chain_1 = require("../chain");
+const token_1 = require("../token");
+const MAX_ASSETS = 32;
+exports.NATIVE_MINT = new web3_js_1.PublicKey('So11111111111111111111111111111111111111112');
+const TOKEN_ACCOUNT_BYTES = 165;
+const INITIALIZE_ACCOUNT_3 = 18;
+const big = (x) => BigInt(x.toString());
+const short = (e) => String(e?.message ?? e).slice(0, 160);
+const cu = (units) => [web3_js_1.ComputeBudgetProgram.setComputeUnitLimit({ units })];
+function classifyAsset(mint, mints, sink = null) {
+    if (sink && !sink.equals(web3_js_1.PublicKey.default))
+        return 'sink';
+    if (mint.equals(mints.zga))
+        return 'zga';
+    if (mint.equals(exports.NATIVE_MINT))
+        return 'sol';
+    if (mint.equals(mints.zgap))
+        return 'zgap';
+    return null;
+}
+function routesFor(kind, due) {
+    const any = due.protocol > 0n || due.unattributed > 0n;
+    switch (kind) {
+        case 'zga':
+            return any ? ['zga'] : [];
+        case 'sol':
+            return any ? ['sol'] : [];
+        case 'zgap': {
+            const routes = [];
+            if (due.unattributed > 0n)
+                routes.push('zgap-nop-tax');
+            if (due.protocol > 0n)
+                routes.push('zgap-fees');
+            return routes;
+        }
+        case 'sink':
+            return any ? ['sink'] : [];
+        default:
+            return [];
+    }
+}
+function shieldPdas(pid) {
+    const b = (s) => Buffer.from(s);
+    return {
+        lpLock: (0, chain_1.lpLockPda)(pid),
+        asset: (id) => (0, chain_1.pda)(pid, b('shield_asset'), Buffer.from([id])),
+        vault: (id) => (0, chain_1.pda)(pid, b('shield_vault'), Buffer.from([id])),
+        nopRewardPool: (0, chain_1.pda)(pid, b('nop_reward_pool')),
+        stakingVault: (0, chain_1.pda)(pid, b('staking_vault')),
+        stakingPool: (0, chain_1.pda)(pid, b('staking_pool')),
+        zgapReserve: (0, chain_1.pda)(pid, b('zgap_reserve')),
+        zgapMint: (0, chain_1.pda)(pid, b('zgap_mint')),
+        zgapAuthority: (0, chain_1.pda)(pid, b('zgap_authority')),
+        collateralVault: (0, chain_1.pda)(pid, b('zgap_collateral_vault')),
+        solVault: (0, chain_1.pda)(pid, b('zgap_sol_vault')),
+        reserveSol: (0, chain_1.pda)(pid, b('zgap_reserve_sol')),
+    };
+}
+function initializeWrappedSolAccount(account, owner) {
+    return new web3_js_1.TransactionInstruction({
+        programId: token_1.TOKEN_PROGRAM_ID,
+        keys: [
+            { pubkey: account, isSigner: false, isWritable: true },
+            { pubkey: exports.NATIVE_MINT, isSigner: false, isWritable: false },
+        ],
+        data: Buffer.concat([Buffer.from([INITIALIZE_ACCOUNT_3]), owner.toBuffer()]),
+    });
+}
+async function send(ctx, assetId, route, zgaMint, sink) {
+    const pid = ctx.program.programId;
+    const p = shieldPdas(pid);
+    const m = ctx.program.methods;
+    const common = { assetConfig: p.asset(assetId), vault: p.vault(assetId), caller: ctx.caller.publicKey, tokenProgram: token_1.TOKEN_PROGRAM_ID };
+    switch (route) {
+        case 'sink':
+            await m.routeShieldFeesToSink(assetId).accountsPartial({ assetConfig: p.asset(assetId), vault: p.vault(assetId), sinkAccount: sink, tokenProgram: token_1.TOKEN_PROGRAM_ID }).rpc();
+            return;
+        case 'zga':
+            await m.routeShieldFees(assetId).accountsPartial({
+                ...common, nopRewardPool: null, stakingVault: p.stakingVault, stakingPool: p.stakingPool, zgapReserve: p.zgapReserve,
+                wsolTransit: null, reserveZgaAccount: (0, token_1.associatedTokenAddress)(zgaMint, p.zgapReserve),
+            }).rpc();
+            return;
+        case 'sol': {
+            const transit = web3_js_1.Keypair.generate();
+            const rent = await ctx.connection.getMinimumBalanceForRentExemption(TOKEN_ACCOUNT_BYTES);
+            const create = web3_js_1.SystemProgram.createAccount({
+                fromPubkey: ctx.caller.publicKey, newAccountPubkey: transit.publicKey, lamports: rent, space: TOKEN_ACCOUNT_BYTES, programId: token_1.TOKEN_PROGRAM_ID,
+            });
+            const route = await m.routeShieldFees(assetId).accountsPartial({
+                ...common, nopRewardPool: null, stakingVault: null, stakingPool: null, zgapReserve: p.zgapReserve,
+                wsolTransit: transit.publicKey, reserveZgaAccount: null,
+            }).instruction();
+            await ctx.program.provider.sendAndConfirm(new web3_js_1.Transaction().add(create, initializeWrappedSolAccount(transit.publicKey, ctx.caller.publicKey), route), [transit]);
+            return;
+        }
+        case 'zgap-nop-tax':
+            await m.routeShieldFees(assetId).accountsPartial({
+                ...common, nopRewardPool: p.nopRewardPool, stakingVault: null, stakingPool: null, zgapReserve: null, wsolTransit: null, reserveZgaAccount: null,
+            }).rpc();
+            return;
+        case 'zgap-fees':
+            await m.routeShieldZgapFees(assetId).accountsPartial({
+                assetConfig: p.asset(assetId), vault: p.vault(assetId),
+                protocolRedeem: { zgaPriceCache: (0, chain_1.cachePda)(pid, chain_1.ZGA_ASSET_ID), solPriceCache: (0, chain_1.cachePda)(pid, chain_1.SOL_ASSET_ID), solVault: p.solVault, reserveSolAccount: p.reserveSol },
+                zgapAuthority: p.zgapAuthority, zgapMint: p.zgapMint, collateralVault: p.collateralVault, stakingVault: p.stakingVault, stakingPool: p.stakingPool,
+                lpLockVault: p.lpLock, zgapReserve: p.zgapReserve, reserveZgaAccount: (0, token_1.associatedTokenAddress)(zgaMint, p.zgapReserve), tokenProgram: token_1.TOKEN_PROGRAM_ID,
+            }).preInstructions(cu(400000)).rpc();
+            return;
+        default:
+            return;
+    }
+}
+function shieldFeesTask(everyMs = 3600000) {
+    const unknown = new Set();
+    return {
+        name: 'shield-fees',
+        everyMs,
+        async run(ctx) {
+            const pid = ctx.program.programId;
+            const p = shieldPdas(pid);
+            const lock = await ctx.connection.getAccountInfo(p.lpLock);
+            if (!lock)
+                return;
+            const mints = { zga: new web3_js_1.PublicKey(lock.data.subarray(0, 32)), zgap: p.zgapMint };
+            const addresses = Array.from({ length: MAX_ASSETS }, (_, id) => p.asset(id));
+            const infos = await ctx.connection.getMultipleAccountsInfo(addresses);
+            for (let id = 0; id < infos.length; id++) {
+                const info = infos[id];
+                if (!info || !info.owner.equals(pid))
+                    continue;
+                const asset = (0, chain_1.decodeAccount)(ctx.program, 'ShieldAssetConfig', info.data);
+                const sink = asset.feeSink ?? web3_js_1.PublicKey.default;
+                const kind = classifyAsset(asset.mint, mints, sink);
+                if (!kind) {
+                    if (!unknown.has(id)) {
+                        unknown.add(id);
+                        ctx.log(`shield asset ${id}: no routing is known for its mint and governance has named no sink for it, so its fees are left`);
+                    }
+                    continue;
+                }
+                for (const route of routesFor(kind, { protocol: big(asset.feesProtocol), unattributed: big(asset.feesUnattributed) })) {
+                    try {
+                        await send(ctx, id, route, mints.zga, sink);
+                        ctx.log(`shield asset ${id}: ${route} fees routed`);
+                    }
+                    catch (e) {
+                        ctx.log(`shield asset ${id}: ${route} fees not routed: ${short(e)}`);
+                    }
+                }
+            }
+        },
+    };
+}

package/dist/epoch-root.d.ts

@@ -0,0 +1,23 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+export interface ProgramTx {
+    slot: number;
+    signature: string;
+}
+export interface IndexerRoot {
+    submissionEpoch: bigint;
+    committedEpoch: bigint;
+    root: Uint8Array;
+    entries: number;
+    startSlot: bigint;
+    endSlot: bigint;
+}
+export declare function epochSlotRange(configStartSlot: bigint, epoch: bigint, epochSlots?: bigint): {
+    start: bigint;
+    end: bigint;
+};
+export declare function epochRoot(committedEpoch: bigint, txs: ProgramTx[]): {
+    root: Uint8Array;
+    count: number;
+};
+export declare function collectProgramTxs(connection: Connection, programId: PublicKey, startSlot: number, endSlot: number): Promise<ProgramTx[]>;
+export declare function indexerRoot(program: any, connection: Connection, submissionEpoch: bigint): Promise<IndexerRoot>;