@zga/client 0.0.0-stage → 0.1.0

package/dist/addresses.d.ts

@@ -0,0 +1,29 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+export declare class Addresses {
+    readonly programId: PublicKey;
+    constructor(programId: PublicKey);
+    private derive;
+    get config(): PublicKey;
+    get zgapMint(): PublicKey;
+    get zgapAuthority(): PublicKey;
+    get zgapReserve(): PublicKey;
+    get zgapCollateralVault(): PublicKey;
+    get zgapSolVault(): PublicKey;
+    get zgapReserveSol(): PublicKey;
+    get lpLock(): PublicKey;
+    get yieldVault(): PublicKey;
+    get rewardDistributor(): PublicKey;
+    priceCache(assetId: number): PublicKey;
+    session(sessionId: Uint8Array): PublicKey;
+    vault(session: PublicKey): PublicKey;
+    prizeVault(session: PublicKey): PublicKey;
+    guild(guildId: Uint8Array): PublicKey;
+    rateLimit(guild: PublicKey): PublicKey;
+    gameManifest(gameId: Uint8Array): PublicKey;
+    gameCreator(creator: PublicKey, gameId: Uint8Array): PublicKey;
+    royaltyVault(creator: PublicKey, gameId: Uint8Array): PublicKey;
+    attestationCert(enclave: PublicKey): PublicKey;
+    player(session: PublicKey, user: PublicKey): PublicKey;
+    agentBond(user: PublicKey): PublicKey;
+}
+export declare function zgaMintOf(connection: Connection, addresses: Addresses): Promise<PublicKey>;

package/dist/addresses.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Addresses = void 0;
+exports.zgaMintOf = zgaMintOf;
+const web3_js_1 = require("@solana/web3.js");
+const enc = (s) => new TextEncoder().encode(s);
+class Addresses {
+    constructor(programId) {
+        this.programId = programId;
+    }
+    derive(...seeds) {
+        return web3_js_1.PublicKey.findProgramAddressSync(seeds, this.programId)[0];
+    }
+    get config() { return this.derive(enc('config')); }
+    get zgapMint() { return this.derive(enc('zgap_mint')); }
+    get zgapAuthority() { return this.derive(enc('zgap_authority')); }
+    get zgapReserve() { return this.derive(enc('zgap_reserve')); }
+    get zgapCollateralVault() { return this.derive(enc('zgap_collateral_vault')); }
+    get zgapSolVault() { return this.derive(enc('zgap_sol_vault')); }
+    get zgapReserveSol() { return this.derive(enc('zgap_reserve_sol')); }
+    get lpLock() { return this.derive(enc('lp_lock')); }
+    get yieldVault() { return this.derive(enc('yield_vault')); }
+    get rewardDistributor() { return this.derive(enc('reward_distributor')); }
+    priceCache(assetId) { return this.derive(enc('price_cache'), Uint8Array.of(assetId)); }
+    session(sessionId) { return this.derive(enc('session'), sessionId); }
+    vault(session) { return this.derive(enc('vault'), session.toBytes()); }
+    prizeVault(session) { return this.derive(enc('prize_vault'), session.toBytes()); }
+    guild(guildId) { return this.derive(enc('guild'), guildId); }
+    rateLimit(guild) { return this.derive(enc('rate_limit'), guild.toBytes()); }
+    gameManifest(gameId) { return this.derive(enc('game_manifest'), gameId); }
+    gameCreator(creator, gameId) { return this.derive(enc('game_creator'), creator.toBytes(), gameId); }
+    royaltyVault(creator, gameId) { return this.derive(enc('royalty_vault'), creator.toBytes(), gameId); }
+    attestationCert(enclave) { return this.derive(enc('attestation_cert'), enclave.toBytes()); }
+    player(session, user) { return this.derive(enc('player'), session.toBytes(), user.toBytes()); }
+    agentBond(user) { return this.derive(enc('agent_bond'), user.toBytes()); }
+}
+exports.Addresses = Addresses;
+async function zgaMintOf(connection, addresses) {
+    const info = await connection.getAccountInfo(addresses.lpLock);
+    if (!info)
+        throw new Error('The liquidity lock does not exist');
+    return new web3_js_1.PublicKey(info.data.subarray(0, 32));
+}

package/dist/billing.d.ts

@@ -0,0 +1,41 @@
+import { AddressLookupTableAccount, Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { EnclaveSigner } from './signer';
+export interface UsageReceipt {
+    session: PublicKey;
+    player: PublicKey;
+    hours: number;
+    fromSlot: bigint;
+    toSlot: bigint;
+}
+export interface BillingTerms {
+    slotsPerHour: bigint;
+    maxHoursPerBill: number;
+    marginSlots: bigint;
+}
+export declare const DEFAULT_BILLING_TERMS: BillingTerms;
+export declare function usageReceiptHash(r: UsageReceipt): Uint8Array;
+export declare function nextUsageReceipt(a: {
+    session: PublicKey;
+    player: PublicKey;
+    billedThroughSlot: bigint;
+    currentSlot: bigint;
+    rate: bigint;
+    credit: bigint;
+}, terms?: BillingTerms): UsageReceipt | null;
+export interface BillEnv {
+    program: any;
+    connection: Connection;
+    payer: Keypair;
+    enclave: EnclaveSigner;
+    lookupTable: AddressLookupTableAccount;
+}
+export interface Attestation {
+    slot: number;
+    publicKey: Uint8Array;
+    signature: Uint8Array;
+}
+export declare const subscriptionAddress: (programId: PublicKey, session: PublicKey, player: PublicKey) => PublicKey;
+export declare const subscriptionVaultAddress: (programId: PublicKey, subscription: PublicKey) => PublicKey;
+export declare const observerVaultAddress: (programId: PublicKey, session: PublicKey) => PublicKey;
+export declare function billSubscription(env: BillEnv, receipt: UsageReceipt, guildSignature: Uint8Array, attestations: Attestation[]): Promise<string>;
+export declare function claimObserverPay(program: any, connection: Connection, observer: Keypair, session: PublicKey): Promise<string>;

package/dist/billing.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.observerVaultAddress = exports.subscriptionVaultAddress = exports.subscriptionAddress = exports.DEFAULT_BILLING_TERMS = void 0;
+exports.usageReceiptHash = usageReceiptHash;
+exports.nextUsageReceipt = nextUsageReceipt;
+exports.billSubscription = billSubscription;
+exports.claimObserverPay = claimObserverPay;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@coral-xyz/anchor");
+const addresses_1 = require("./addresses");
+const sha256_1 = require("./sha256");
+const token_1 = require("./token");
+exports.DEFAULT_BILLING_TERMS = { slotsPerHour: 9000n, maxHoursPerBill: 744, marginSlots: 150n };
+function u32le(n) {
+    const b = new Uint8Array(4);
+    new DataView(b.buffer).setUint32(0, n, true);
+    return b;
+}
+function u64le(n) {
+    const b = new Uint8Array(8);
+    new DataView(b.buffer).setBigUint64(0, n, true);
+    return b;
+}
+function usageReceiptHash(r) {
+    return (0, sha256_1.sha256)(new TextEncoder().encode('zga-usage-v1'), r.session.toBytes(), r.player.toBytes(), u32le(r.hours), u64le(r.fromSlot), u64le(r.toSlot));
+}
+function nextUsageReceipt(a, terms = exports.DEFAULT_BILLING_TERMS) {
+    if (a.rate <= 0n)
+        return null;
+    const elapsed = a.currentSlot - terms.marginSlots - a.billedThroughSlot;
+    if (elapsed < terms.slotsPerHour)
+        return null;
+    let hours = elapsed / terms.slotsPerHour;
+    const affordable = a.credit / a.rate;
+    if (hours > affordable)
+        hours = affordable;
+    if (hours > BigInt(terms.maxHoursPerBill))
+        hours = BigInt(terms.maxHoursPerBill);
+    if (hours < 1n)
+        return null;
+    return {
+        session: a.session,
+        player: a.player,
+        hours: Number(hours),
+        fromSlot: a.billedThroughSlot,
+        toSlot: a.billedThroughSlot + hours * terms.slotsPerHour,
+    };
+}
+const subscriptionAddress = (programId, session, player) => web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('subscription'), session.toBuffer(), player.toBuffer()], programId)[0];
+exports.subscriptionAddress = subscriptionAddress;
+const subscriptionVaultAddress = (programId, subscription) => web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('sub_vault'), subscription.toBuffer()], programId)[0];
+exports.subscriptionVaultAddress = subscriptionVaultAddress;
+const observerVaultAddress = (programId, session) => web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('observer_vault'), session.toBuffer()], programId)[0];
+exports.observerVaultAddress = observerVaultAddress;
+async function billSubscription(env, receipt, guildSignature, attestations) {
+    const { program, connection, payer, enclave, lookupTable } = env;
+    const attesters = [...attestations].sort((x, y) => x.slot - y.slot);
+    if (attesters.length < 2 || attesters.length > 3)
+        throw new Error('A bill needs two or three attestations');
+    const addr = new addresses_1.Addresses(program.programId);
+    const session = await program.account.session.fetch(receipt.session);
+    const guildAccount = await program.account.guildAccount.fetch(session.guild);
+    const gameId = Uint8Array.from(session.gameId);
+    const manifest = await program.account.gameManifest.fetch(addr.gameManifest(gameId));
+    const creator = manifest.creator;
+    const hash = usageReceiptHash(receipt);
+    const signatureIxs = [
+        web3_js_1.Ed25519Program.createInstructionWithPublicKey({ publicKey: enclave.publicKey, message: hash, signature: guildSignature }),
+        ...attesters.map((a) => web3_js_1.Ed25519Program.createInstructionWithPublicKey({ publicKey: a.publicKey, message: hash, signature: a.signature })),
+    ];
+    const subscription = (0, exports.subscriptionAddress)(program.programId, receipt.session, receipt.player);
+    const zgaMint = await (0, addresses_1.zgaMintOf)(connection, addr);
+    const billIx = await program.methods
+        .billSubscription({ session: receipt.session, player: receipt.player, hours: receipt.hours, fromSlot: new anchor_1.BN(receipt.fromSlot.toString()), toSlot: new anchor_1.BN(receipt.toSlot.toString()) }, Buffer.from(attesters.map((a) => a.slot)))
+        .accounts({
+        protocolRedeem: {
+            zgaPriceCache: addr.priceCache(0), solPriceCache: addr.priceCache(1), solVault: addr.zgapSolVault, reserveSolAccount: addr.zgapReserveSol,
+        },
+        session: receipt.session,
+        subscription,
+        subVault: (0, exports.subscriptionVaultAddress)(program.programId, subscription),
+        observerVault: (0, exports.observerVaultAddress)(program.programId, receipt.session),
+        yieldVault: addr.yieldVault,
+        rewardDistributor: addr.rewardDistributor,
+        protocolConfig: addr.config,
+        zgapAuthority: addr.zgapAuthority,
+        zgapMint: addr.zgapMint,
+        zgapCollateralVault: addr.zgapCollateralVault,
+        zgapReserve: addr.zgapReserve,
+        zgapReserveZgaAccount: (0, token_1.associatedTokenAddress)(zgaMint, addr.zgapReserve),
+        lpLockTokenAccount: addr.lpLock,
+        guildTokenAccount: (0, token_1.associatedTokenAddress)(addr.zgapMint, guildAccount.operator),
+        gameManifest: addr.gameManifest(gameId),
+        gameCreatorAccount: addr.gameCreator(creator, gameId),
+        royaltyVault: addr.royaltyVault(creator, gameId),
+        guildAccount: session.guild,
+        payer: payer.publicKey,
+        tokenProgram: token_1.TOKEN_PROGRAM_ID,
+        systemProgram: web3_js_1.SystemProgram.programId,
+        ixSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+    })
+        .instruction();
+    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+    const message = new web3_js_1.TransactionMessage({ payerKey: payer.publicKey, recentBlockhash: blockhash, instructions: [...signatureIxs, billIx] }).compileToV0Message([lookupTable]);
+    const tx = new web3_js_1.VersionedTransaction(message);
+    tx.sign([payer]);
+    if (tx.serialize().length > 1232)
+        throw new Error('The billing transaction does not fit in a packet');
+    const sent = await connection.sendTransaction(tx);
+    await connection.confirmTransaction({ signature: sent, blockhash, lastValidBlockHeight }, 'confirmed');
+    return sent;
+}
+const ATA_PROGRAM_ID = new web3_js_1.PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+async function claimObserverPay(program, connection, observer, session) {
+    const addr = new addresses_1.Addresses(program.programId);
+    const tokenAccount = (0, token_1.associatedTokenAddress)(addr.zgapMint, observer.publicKey);
+    const makeAccount = new web3_js_1.TransactionInstruction({
+        programId: ATA_PROGRAM_ID,
+        keys: [
+            { pubkey: observer.publicKey, isSigner: true, isWritable: true },
+            { pubkey: tokenAccount, isSigner: false, isWritable: true },
+            { pubkey: observer.publicKey, isSigner: false, isWritable: false },
+            { pubkey: addr.zgapMint, isSigner: false, isWritable: false },
+            { pubkey: web3_js_1.SystemProgram.programId, isSigner: false, isWritable: false },
+            { pubkey: token_1.TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        ],
+        data: Buffer.from([1]),
+    });
+    return program.methods
+        .claimObserverPay()
+        .accounts({
+        session,
+        observerVault: (0, exports.observerVaultAddress)(program.programId, session),
+        observerTokenAccount: tokenAccount,
+        observer: observer.publicKey,
+        tokenProgram: token_1.TOKEN_PROGRAM_ID,
+    })
+        .preInstructions([makeAccount])
+        .signers([observer])
+        .rpc();
+}

package/dist/bin/crank.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/crank.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const chain_1 = require("../chain");
+const config_1 = require("../config");
+const gate_1 = require("../crank/gate");
+const prices_1 = require("../crank/prices");
+const runner_1 = require("../crank/runner");
+const shieldFees_1 = require("../crank/shieldFees");
+const lending_1 = require("../crank/lending");
+async function main() {
+    const env = (0, config_1.readEnv)();
+    const connection = new web3_js_1.Connection(env.rpcUrl, 'confirmed');
+    const caller = (0, config_1.loadWallet)(env.walletPath);
+    const program = (0, config_1.makeProgram)(connection, caller, (0, config_1.loadIdl)(env.idlPath));
+    const missing = (0, chain_1.missingFromIdl)(program, ['PriceFeedAccount', 'PriceCacheAccount', 'ShieldAssetConfig', 'LendingVault', 'LendingLoan'], ['updatePriceFeedAggregated', 'updatePriceFeedDlmmAggregated', 'updatePriceFeedFixed', 'crankPriceCache', 'updateMarketCapGate', 'routeShieldFees', 'routeShieldZgapFees', 'routeZnlZgapFees', 'liquidateZnlLoan']);
+    if (missing.length > 0)
+        throw new Error(`the IDL at ${env.idlPath} lacks ${missing.join(', ')}: the crank needs the IDL of the program it talks to`);
+    const log = (message) => console.log(`[crank ${new Date().toISOString()}] ${message}`);
+    log(`caller ${caller.publicKey.toBase58()}, program ${program.programId.toBase58()}`);
+    const liquidate = process.env.ZGA_LIQUIDATE === '1';
+    if (liquidate)
+        log('liquidating loans: the caller must hold the borrowed assets');
+    const postSecs = Math.min(540, Number(process.env.ZGA_PRICE_POST_SECS ?? 450) || 0);
+    if (postSecs > 0)
+        log(`posting a price sample at most every ${postSecs}s`);
+    const tasks = [(0, prices_1.priceFeedsTask)(30000, postSecs), (0, gate_1.marketCapGateTask)(), (0, shieldFees_1.shieldFeesTask)(), (0, lending_1.lendingFeesTask)(), ...(liquidate ? [(0, lending_1.lendingLiquidationTask)()] : [])];
+    await (0, runner_1.runTasks)({ program, connection, caller, log }, tasks, { once: process.argv.includes('--once') });
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/bin/relayer.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/relayer.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const web3_js_1 = require("@solana/web3.js");
+const chain_1 = require("../chain");
+const config_1 = require("../config");
+const limits_1 = require("../relayer/limits");
+const relayer_1 = require("../relayer/relayer");
+const chain_2 = require("../relayer/chain");
+const server_1 = require("../relayer/server");
+const settings_1 = require("../relayer/settings");
+async function main() {
+    const env = (0, config_1.readEnv)();
+    const settings = (0, settings_1.readRelayerSettings)();
+    const connection = new web3_js_1.Connection(env.rpcUrl, 'confirmed');
+    const relayer = (0, config_1.loadWallet)(env.walletPath);
+    const program = (0, config_1.makeProgram)(connection, relayer, (0, config_1.loadIdl)(env.idlPath));
+    const log = (message) => console.log(`[relayer ${new Date().toISOString()}] ${message}`);
+    const missing = (0, chain_1.missingFromIdl)(program, ['ShieldAssetConfig', 'ShieldDirectory', 'NopAccount', 'NopShieldFees'], ['unshield', 'unshieldDrop', 'initNopShieldFees']);
+    if (missing.length > 0)
+        throw new Error(`the IDL at ${env.idlPath} lacks ${missing.join(', ')}: the relayer needs the IDL of the program it talks to`);
+    const chain = new chain_2.SolanaShieldedRelayerChain(program, connection, relayer, settings, log);
+    const info = await chain.prepare();
+    log(`relayer ${info.relayer}, program ${info.programId}, ${info.assets.length} asset(s), ${info.lookupTables.length} lookup table(s)`);
+    const balance = await connection.getBalance(relayer.publicKey);
+    log(`balance ${(balance / 1e9).toFixed(4)} SOL${balance < settings.minBalanceLamports ? ' (below the minimum: it will refuse requests)' : ''}`);
+    const handler = new relayer_1.ShieldedRelayer(chain, new limits_1.RelayerRateLimiter(settings.ratePerMinute), new limits_1.RelayerInFlight(settings.maxInFlight), settings.logRequests ? log : () => { });
+    const server = (0, server_1.createShieldedRelayerServer)(handler, { maxBodyBytes: settings.maxBodyBytes, trustProxy: settings.trustProxy, corsOrigin: settings.corsOrigin });
+    server.listen(settings.port, settings.host, () => log(`listening on ${settings.host}:${settings.port}`));
+    const stop = () => { log('stopping'); server.close(() => process.exit(0)); };
+    process.on('SIGINT', stop);
+    process.on('SIGTERM', stop);
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});

package/dist/chain.d.ts

@@ -0,0 +1,14 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+export declare const ZGA_ASSET_ID = 0;
+export declare const SOL_ASSET_ID = 1;
+export declare const EPOCH_DURATION_SLOTS: bigint;
+export declare function pda(programId: PublicKey, ...seeds: (Buffer | Uint8Array)[]): PublicKey;
+export declare const configPda: (programId: PublicKey) => PublicKey;
+export declare const lpLockPda: (programId: PublicKey) => PublicKey;
+export declare const feedPda: (programId: PublicKey, assetId: number) => PublicKey;
+export declare const cachePda: (programId: PublicKey, assetId: number) => PublicKey;
+export declare function chainTime(connection: Connection): Promise<number>;
+export declare function idlAccountName(program: any, wanted: string): string;
+export declare function decodeAccount(program: any, wanted: string, data: Buffer): any;
+export declare function missingFromIdl(program: any, accounts: string[], methods: string[]): string[];
+export declare function currentEpoch(program: any, connection: Connection): Promise<bigint>;

package/dist/chain.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachePda = exports.feedPda = exports.lpLockPda = exports.configPda = exports.EPOCH_DURATION_SLOTS = exports.SOL_ASSET_ID = exports.ZGA_ASSET_ID = void 0;
+exports.pda = pda;
+exports.chainTime = chainTime;
+exports.idlAccountName = idlAccountName;
+exports.decodeAccount = decodeAccount;
+exports.missingFromIdl = missingFromIdl;
+exports.currentEpoch = currentEpoch;
+const web3_js_1 = require("@solana/web3.js");
+exports.ZGA_ASSET_ID = 0;
+exports.SOL_ASSET_ID = 1;
+exports.EPOCH_DURATION_SLOTS = BigInt(process.env.EPOCH_DURATION_SLOTS ?? '648000');
+function pda(programId, ...seeds) {
+    return web3_js_1.PublicKey.findProgramAddressSync(seeds, programId)[0];
+}
+const configPda = (programId) => pda(programId, Buffer.from('config'));
+exports.configPda = configPda;
+const lpLockPda = (programId) => pda(programId, Buffer.from('lp_lock'));
+exports.lpLockPda = lpLockPda;
+const feedPda = (programId, assetId) => pda(programId, Buffer.from('price_feed'), Buffer.from([assetId]));
+exports.feedPda = feedPda;
+const cachePda = (programId, assetId) => pda(programId, Buffer.from('price_cache'), Buffer.from([assetId]));
+exports.cachePda = cachePda;
+async function chainTime(connection) {
+    const t = await connection.getBlockTime(await connection.getSlot());
+    return t ?? Math.floor(Date.now() / 1000);
+}
+function idlAccountName(program, wanted) {
+    const found = (program.idl?.accounts ?? []).find((a) => String(a.name).toLowerCase() === wanted.toLowerCase());
+    if (!found)
+        throw new Error(`the IDL has no account type ${wanted}: the crank needs the IDL of the program it talks to`);
+    return found.name;
+}
+function decodeAccount(program, wanted, data) {
+    return program.coder.accounts.decode(idlAccountName(program, wanted), data);
+}
+function missingFromIdl(program, accounts, methods) {
+    const have = new Set((program.idl?.accounts ?? []).map((a) => String(a.name).toLowerCase()));
+    const callable = new Set(Object.keys(program.methods ?? {}));
+    return [...accounts.filter((a) => !have.has(a.toLowerCase())), ...methods.filter((m) => !callable.has(m))];
+}
+async function currentEpoch(program, connection) {
+    const config = await program.account.protocolConfig.fetch((0, exports.configPda)(program.programId));
+    const slot = BigInt(await connection.getSlot());
+    const start = BigInt(config.globalZgaEpochStartSlot.toString());
+    return slot > start ? (slot - start) / exports.EPOCH_DURATION_SLOTS : 0n;
+}

package/dist/config.d.ts

@@ -0,0 +1,11 @@
+import * as anchor from '@coral-xyz/anchor';
+import { Connection, Keypair } from '@solana/web3.js';
+export interface ClientEnv {
+    rpcUrl: string;
+    walletPath: string;
+    idlPath: string;
+}
+export declare function readEnv(env?: NodeJS.ProcessEnv): ClientEnv;
+export declare function loadWallet(path: string): Keypair;
+export declare function loadIdl(path: string): any;
+export declare function makeProgram(connection: Connection, wallet: Keypair, idl: any): anchor.Program;

package/dist/config.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readEnv = readEnv;
+exports.loadWallet = loadWallet;
+exports.loadIdl = loadIdl;
+exports.makeProgram = makeProgram;
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const web3_js_1 = require("@solana/web3.js");
+const fs_1 = require("fs");
+function readEnv(env = process.env) {
+    const need = (key) => {
+        const v = env[key];
+        if (!v)
+            throw new Error(`${key} is not set`);
+        return v;
+    };
+    return { rpcUrl: need('RPC_URL'), walletPath: need('WALLET_PATH'), idlPath: env.IDL_PATH ?? './idl/zga_protocol.json' };
+}
+function loadWallet(path) {
+    return web3_js_1.Keypair.fromSecretKey(Uint8Array.from(JSON.parse((0, fs_1.readFileSync)(path, 'utf8'))));
+}
+function loadIdl(path) {
+    return JSON.parse((0, fs_1.readFileSync)(path, 'utf8'));
+}
+function makeProgram(connection, wallet, idl) {
+    const provider = new anchor.AnchorProvider(connection, new anchor.Wallet(wallet), { commitment: 'confirmed' });
+    return new anchor.Program(idl, provider);
+}

package/dist/crank/gate.d.ts

@@ -0,0 +1,2 @@
+import { CrankTask } from './runner';
+export declare function marketCapGateTask(everyMs?: number): CrankTask;

package/dist/crank/gate.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.marketCapGateTask = marketCapGateTask;
+const web3_js_1 = require("@solana/web3.js");
+const chain_1 = require("../chain");
+function marketCapGateTask(everyMs = 600000) {
+    return {
+        name: 'market-cap-gate',
+        everyMs,
+        async run(ctx) {
+            const pid = ctx.program.programId;
+            const lpLock = (0, chain_1.lpLockPda)(pid);
+            const info = await ctx.connection.getAccountInfo(lpLock);
+            if (!info)
+                return;
+            const zgaMint = new web3_js_1.PublicKey(info.data.subarray(0, 32));
+            await ctx.program.methods.updateMarketCapGate().accountsPartial({
+                protocolConfig: (0, chain_1.configPda)(pid),
+                zgaPriceCache: (0, chain_1.cachePda)(pid, chain_1.ZGA_ASSET_ID),
+                lpLockVault: lpLock,
+                zgaMint,
+            }).rpc();
+            ctx.log('market-cap gate recorded');
+        },
+    };
+}

package/dist/crank/lending.d.ts

@@ -0,0 +1,16 @@
+import { CrankTask } from './runner';
+export interface LoanFacts {
+    principal: bigint;
+    collateralAmount: bigint;
+    accruedAt: bigint;
+    dueAt: bigint;
+    rateBps: bigint;
+    thresholdBps: bigint;
+    collateralScaleTo9: bigint;
+    collateralPriceE9: bigint;
+    borrowPriceE9: bigint;
+    now: bigint;
+}
+export declare function isLoanLiquidatable(f: LoanFacts): boolean;
+export declare function lendingFeesTask(everyMs?: number): CrankTask;
+export declare function lendingLiquidationTask(everyMs?: number): CrankTask;