@zga/client 0.0.0-stage → 0.1.1

package/dist/epoch-root.js

@@ -0,0 +1,98 @@
+"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.epochSlotRange = epochSlotRange;
+exports.epochRoot = epochRoot;
+exports.collectProgramTxs = collectProgramTxs;
+exports.indexerRoot = indexerRoot;
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const sha256_1 = require("./sha256");
+const log_1 = require("./log");
+const chain_1 = require("./chain");
+const ROOT_TAG = new TextEncoder().encode('zga-indexer-root-v1');
+const LEAF_TAG = Uint8Array.of(0x00);
+const PAGE = 1000;
+function u64le(n) {
+    const b = new Uint8Array(8);
+    new DataView(b.buffer).setBigUint64(0, n, true);
+    return b;
+}
+function epochSlotRange(configStartSlot, epoch, epochSlots = chain_1.EPOCH_DURATION_SLOTS) {
+    const start = configStartSlot + epoch * epochSlots;
+    return { start, end: start + epochSlots };
+}
+function epochRoot(committedEpoch, txs) {
+    const unique = new Map();
+    for (const t of txs) {
+        if (!Number.isInteger(t.slot) || t.slot < 0)
+            throw new Error('A transaction carries an invalid slot');
+        const sig = anchor.utils.bytes.bs58.decode(t.signature);
+        if (sig.length !== 64)
+            throw new Error('A transaction signature is not 64 bytes');
+        unique.set(t.signature, { slot: t.slot, sig });
+    }
+    const ordered = [...unique.values()].sort((a, b) => a.slot - b.slot || Buffer.compare(a.sig, b.sig));
+    const tree = ordered.length === 0
+        ? new Uint8Array(32)
+        : (0, log_1.rootOfLeaves)(ordered.map((t) => (0, sha256_1.sha256)(LEAF_TAG, u64le(BigInt(t.slot)), t.sig)));
+    return { root: (0, sha256_1.sha256)(ROOT_TAG, u64le(committedEpoch), u64le(BigInt(ordered.length)), tree), count: ordered.length };
+}
+async function collectProgramTxs(connection, programId, startSlot, endSlot) {
+    const found = new Map();
+    let before;
+    for (;;) {
+        const page = await connection.getSignaturesForAddress(programId, { before, limit: PAGE }, 'finalized');
+        for (const s of page) {
+            if (s.err === null && s.slot >= startSlot && s.slot < endSlot)
+                found.set(s.signature, { slot: s.slot, signature: s.signature });
+        }
+        if (page.length < PAGE || page[page.length - 1].slot < startSlot)
+            break;
+        before = page[page.length - 1].signature;
+    }
+    return [...found.values()];
+}
+async function indexerRoot(program, connection, submissionEpoch) {
+    if (submissionEpoch < 1n)
+        throw new Error('There is no epoch before the first for a root to commit to');
+    const committedEpoch = submissionEpoch - 1n;
+    const config = await program.account.protocolConfig.fetch((0, chain_1.configPda)(program.programId));
+    const { start, end } = epochSlotRange(BigInt(config.globalZgaEpochStartSlot.toString()), committedEpoch);
+    if (BigInt(await connection.getSlot('finalized')) < end)
+        throw new Error('The last slot of the epoch is not finalized yet');
+    const txs = await collectProgramTxs(connection, program.programId, Number(start), Number(end));
+    const { root, count } = epochRoot(committedEpoch, txs);
+    return { submissionEpoch, committedEpoch, root, entries: count, startSlot: start, endSlot: end };
+}

package/dist/explorer.d.ts

@@ -0,0 +1,41 @@
+export type ExplorerStatus = 'match' | 'mismatch' | 'unreachable' | 'undeclared' | 'none-published';
+export interface ExplorerVerdict {
+    status: ExplorerStatus;
+    detail: string;
+    files?: number;
+    bad?: string[];
+}
+export interface CachedVerdict extends ExplorerVerdict {
+    consecutiveUnreachable: number;
+}
+export interface ExplorerCheckOptions {
+    guard?: (url: string) => Promise<unknown>;
+    timeoutMs?: number;
+    maxManifestBytes?: number;
+    maxFiles?: number;
+    maxFileBytes?: number;
+    concurrency?: number;
+}
+export declare function verifyExplorer(baseUrl: string, expectedHex: string, opts?: ExplorerCheckOptions): Promise<ExplorerVerdict>;
+export declare class ExplorerCheckCache {
+    private readonly settings;
+    private readonly entries;
+    private readonly pending;
+    constructor(settings?: {
+        matchTtlMs?: number;
+        otherTtlMs?: number;
+        now?: () => number;
+    });
+    check(key: string, baseUrl: string | null | undefined, expectedHex: string, opts?: ExplorerCheckOptions): Promise<CachedVerdict>;
+}
+export declare function explorerRefusal(v: ExplorerVerdict & {
+    consecutiveUnreachable?: number;
+}, unreachableLimit?: number): string | null;
+export interface ExplorerPolicy {
+    cache: ExplorerCheckCache;
+    expectedHex: () => Promise<string>;
+    unreachableLimit?: number;
+}
+export declare function canonicalExplorerHashReader(program: any, ttlMs?: number, now?: () => number): () => Promise<string>;
+export declare function fetchExplorerUrl(guildBase: string, guard?: (url: string) => Promise<unknown>): Promise<string | null>;
+export declare function explorerGate(policy: ExplorerPolicy, guildKey: string, guildBase: string, guard?: (url: string) => Promise<unknown>): Promise<string | null>;

package/dist/explorer.js

@@ -0,0 +1,222 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExplorerCheckCache = void 0;
+exports.verifyExplorer = verifyExplorer;
+exports.explorerRefusal = explorerRefusal;
+exports.canonicalExplorerHashReader = canonicalExplorerHashReader;
+exports.fetchExplorerUrl = fetchExplorerUrl;
+exports.explorerGate = explorerGate;
+const crypto_1 = require("crypto");
+const web3_js_1 = require("@solana/web3.js");
+const HEX64 = /^[0-9a-f]{64}$/;
+const sha256 = (bytes) => (0, crypto_1.createHash)('sha256').update(bytes).digest('hex');
+class NetworkError extends Error {
+}
+async function read(url, max, opts) {
+    let target = url;
+    if (opts.guard) {
+        try {
+            const checked = await opts.guard(url);
+            if (typeof checked === 'string')
+                target = checked;
+            else if (checked instanceof URL)
+                target = checked.toString();
+        }
+        catch (err) {
+            throw new NetworkError(`refused: ${err.message}`);
+        }
+    }
+    let res;
+    try {
+        res = await fetch(target, { redirect: 'error', signal: AbortSignal.timeout(opts.timeoutMs ?? 20000) });
+    }
+    catch (err) {
+        const why = String(err?.cause?.message ?? err.message);
+        if (/redirect/i.test(why))
+            throw new Error('the host redirects');
+        throw new NetworkError(why);
+    }
+    if (!res.ok)
+        throw new Error(`HTTP ${res.status}`);
+    if (Number(res.headers.get('content-length') ?? 0) > max)
+        throw new Error(`larger than ${max} bytes`);
+    if (!res.body)
+        return Buffer.alloc(0);
+    const reader = res.body.getReader();
+    const chunks = [];
+    let size = 0;
+    for (;;) {
+        let step;
+        try {
+            step = await reader.read();
+        }
+        catch (err) {
+            throw new NetworkError(err.message);
+        }
+        if (step.done)
+            break;
+        size += step.value.length;
+        if (size > max) {
+            await reader.cancel();
+            throw new Error(`larger than ${max} bytes`);
+        }
+        chunks.push(Buffer.from(step.value));
+    }
+    return Buffer.concat(chunks);
+}
+function parseManifest(text, maxFiles) {
+    const lines = text.split('\n');
+    if (lines.pop() !== '')
+        throw new Error('the manifest does not end with a newline');
+    if (lines.length === 0 || lines.length > maxFiles)
+        throw new Error(`the manifest lists ${lines.length} files`);
+    const seen = new Set();
+    return lines.map((line) => {
+        const m = /^(.+)  ([0-9a-f]{64})$/.exec(line);
+        if (!m)
+            throw new Error('an unusable manifest line');
+        const path = m[1];
+        if (path.length > 300 || path.startsWith('/') || path.includes('\\') || /[?#\u0000-\u001f]/.test(path) || path.split('/').some((s) => s === '' || s === '.' || s === '..')) {
+            throw new Error(`an unusable path: ${path.slice(0, 60)}`);
+        }
+        if (seen.has(path))
+            throw new Error('a path is listed twice');
+        seen.add(path);
+        return { path, hash: m[2] };
+    });
+}
+async function verifyExplorer(baseUrl, expectedHex, opts = {}) {
+    const expected = expectedHex.toLowerCase();
+    if (!HEX64.test(expected))
+        throw new TypeError('the expected hash is not 64 hex characters');
+    if (/^0+$/.test(expected))
+        return { status: 'none-published', detail: 'no canonical explorer is published on chain' };
+    let base;
+    try {
+        base = new URL(baseUrl);
+    }
+    catch {
+        return { status: 'unreachable', detail: 'the explorer address is not a URL' };
+    }
+    if (base.protocol !== 'http:' && base.protocol !== 'https:')
+        return { status: 'unreachable', detail: 'the explorer address is not an http address' };
+    const root = `${base.origin}${base.pathname.replace(/\/*$/, '/')}`;
+    const at = (path) => root + path.split('/').map(encodeURIComponent).join('/');
+    let manifest;
+    try {
+        manifest = await read(at('build-manifest.txt'), opts.maxManifestBytes ?? 1048576, opts);
+    }
+    catch (err) {
+        if (err instanceof NetworkError)
+            return { status: 'unreachable', detail: err.message };
+        return { status: 'mismatch', detail: `no usable manifest: ${err.message}` };
+    }
+    if (sha256(manifest) !== expected)
+        return { status: 'mismatch', detail: 'the manifest is not the canonical one' };
+    let entries;
+    try {
+        entries = parseManifest(manifest.toString('utf8'), opts.maxFiles ?? 500);
+    }
+    catch (err) {
+        return { status: 'mismatch', detail: err.message };
+    }
+    const bad = [];
+    let network = 0;
+    let next = 0;
+    await Promise.all(Array.from({ length: opts.concurrency ?? 8 }, async () => {
+        for (;;) {
+            const entry = entries[next++];
+            if (!entry)
+                return;
+            try {
+                if (sha256(await read(at(entry.path), opts.maxFileBytes ?? 52428800, opts)) !== entry.hash)
+                    bad.push(`${entry.path}: the content differs`);
+            }
+            catch (err) {
+                bad.push(`${entry.path}: ${err.message}`);
+                if (err instanceof NetworkError)
+                    network++;
+            }
+        }
+    }));
+    bad.sort();
+    if (bad.length === 0)
+        return { status: 'match', detail: `all ${entries.length} files match`, files: entries.length };
+    const status = network === bad.length ? 'unreachable' : 'mismatch';
+    return { status, detail: `${bad.length} of ${entries.length} files failed`, files: entries.length, bad: bad.slice(0, 20) };
+}
+class ExplorerCheckCache {
+    constructor(settings = {}) {
+        this.settings = settings;
+        this.entries = new Map();
+        this.pending = new Map();
+    }
+    async check(key, baseUrl, expectedHex, opts = {}) {
+        const clock = this.settings.now ?? Date.now;
+        const expected = expectedHex.toLowerCase();
+        const url = baseUrl ?? '';
+        const have = this.entries.get(key);
+        const same = have !== undefined && have.expected === expected && have.url === url;
+        if (same) {
+            const ttl = have.verdict.status === 'match' ? (this.settings.matchTtlMs ?? 3600000) : (this.settings.otherTtlMs ?? 600000);
+            if (clock() - have.at < ttl)
+                return have.verdict;
+        }
+        const running = this.pending.get(key);
+        if (running)
+            return running;
+        const job = (async () => {
+            const verdict = url === '' ? { status: 'undeclared', detail: 'the guild declares no explorer' } : await verifyExplorer(url, expected, opts);
+            const previous = same ? have.verdict.consecutiveUnreachable : 0;
+            const cached = { ...verdict, consecutiveUnreachable: verdict.status === 'unreachable' ? previous + 1 : 0 };
+            this.entries.set(key, { at: clock(), expected, url, verdict: cached });
+            return cached;
+        })().finally(() => this.pending.delete(key));
+        this.pending.set(key, job);
+        return job;
+    }
+}
+exports.ExplorerCheckCache = ExplorerCheckCache;
+function explorerRefusal(v, unreachableLimit = 3) {
+    switch (v.status) {
+        case 'match':
+        case 'none-published':
+            return null;
+        case 'mismatch':
+            return `the guild does not serve the canonical explorer: ${v.detail}`;
+        case 'undeclared':
+            return 'the guild declares no explorer';
+        case 'unreachable':
+            return (v.consecutiveUnreachable ?? 1) >= unreachableLimit ? `the guild's explorer has been unreachable for ${v.consecutiveUnreachable} checks: ${v.detail}` : null;
+    }
+}
+function canonicalExplorerHashReader(program, ttlMs = 60000, now = Date.now) {
+    const config = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from('config')], program.programId)[0];
+    let at = -Infinity;
+    let value = '';
+    return async () => {
+        if (value !== '' && now() - at < ttlMs)
+            return value;
+        const account = await program.account.protocolConfig.fetch(config);
+        value = Buffer.from(account.canonicalExplorerHash).toString('hex');
+        at = now();
+        return value;
+    };
+}
+async function fetchExplorerUrl(guildBase, guard) {
+    try {
+        const body = JSON.parse((await read(`${guildBase.replace(/\/+$/, '')}/v1/info`, 4096, { guard, timeoutMs: 8000 })).toString('utf8'));
+        const url = body?.explorerUrl;
+        return typeof url === 'string' && url.length > 0 && url.length <= 300 ? url : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function explorerGate(policy, guildKey, guildBase, guard) {
+    const expected = await policy.expectedHex();
+    if (/^0+$/.test(expected))
+        return null;
+    const url = await fetchExplorerUrl(guildBase, guard);
+    return explorerRefusal(await policy.cache.check(guildKey, url, expected, { guard }), policy.unreachableLimit);
+}

package/dist/gossip.d.ts

@@ -0,0 +1,4 @@
+export declare const GOSSIP_SEAL_OVERHEAD = 48;
+export declare function x25519PublicFromEd25519(publicKey: Uint8Array): Buffer;
+export declare function sealGossipPayload(plaintext: Uint8Array, recipientWallet: Uint8Array): Buffer;
+export declare function openGossipPayload(sealed: Uint8Array, walletSecretKey: Uint8Array): Buffer;

package/dist/gossip.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GOSSIP_SEAL_OVERHEAD = void 0;
+exports.x25519PublicFromEd25519 = x25519PublicFromEd25519;
+exports.sealGossipPayload = sealGossipPayload;
+exports.openGossipPayload = openGossipPayload;
+const crypto_1 = require("crypto");
+exports.GOSSIP_SEAL_OVERHEAD = 48;
+const P = (1n << 255n) - 19n;
+const mod = (a) => ((a % P) + P) % P;
+function pow(base, exponent) {
+    let result = 1n;
+    let b = mod(base);
+    let e = exponent;
+    while (e > 0n) {
+        if (e & 1n)
+            result = mod(result * b);
+        b = mod(b * b);
+        e >>= 1n;
+    }
+    return result;
+}
+const inverse = (a) => pow(a, P - 2n);
+const SPKI_PREFIX = Buffer.from('302a300506032b656e032100', 'hex');
+const PKCS8_PREFIX = Buffer.from('302e020100300506032b656e04220420', 'hex');
+const ZERO_NONCE = Buffer.alloc(12);
+const publicKeyObject = (raw) => (0, crypto_1.createPublicKey)({ key: Buffer.concat([SPKI_PREFIX, raw]), format: 'der', type: 'spki' });
+const privateKeyObject = (raw) => (0, crypto_1.createPrivateKey)({ key: Buffer.concat([PKCS8_PREFIX, raw]), format: 'der', type: 'pkcs8' });
+function symmetricKey(shared, ephemeralPublic, recipientPublic) {
+    return Buffer.from((0, crypto_1.hkdfSync)('sha256', shared, Buffer.concat([ephemeralPublic, recipientPublic]), 'zga-gossip-sealed-v1', 32));
+}
+function x25519PublicFromEd25519(publicKey) {
+    const bytes = Buffer.from(publicKey);
+    bytes[31] &= 0x7f;
+    let y = 0n;
+    for (let i = 31; i >= 0; i--)
+        y = (y << 8n) | BigInt(bytes[i]);
+    let u = mod((1n + y) * inverse(mod(1n - y)));
+    const out = Buffer.alloc(32);
+    for (let i = 0; i < 32; i++) {
+        out[i] = Number(u & 0xffn);
+        u >>= 8n;
+    }
+    return out;
+}
+function x25519SecretFromEd25519Seed(seed) {
+    const h = (0, crypto_1.createHash)('sha512').update(seed).digest().subarray(0, 32);
+    h[0] &= 248;
+    h[31] &= 127;
+    h[31] |= 64;
+    return Buffer.from(h);
+}
+function sealGossipPayload(plaintext, recipientWallet) {
+    const recipientPublic = x25519PublicFromEd25519(recipientWallet);
+    const ephemeral = (0, crypto_1.generateKeyPairSync)('x25519');
+    const ephemeralPublic = ephemeral.publicKey.export({ format: 'der', type: 'spki' }).subarray(-32);
+    const shared = (0, crypto_1.diffieHellman)({ privateKey: ephemeral.privateKey, publicKey: publicKeyObject(recipientPublic) });
+    const cipher = (0, crypto_1.createCipheriv)('chacha20-poly1305', symmetricKey(shared, ephemeralPublic, recipientPublic), ZERO_NONCE, { authTagLength: 16 });
+    const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+    return Buffer.concat([ephemeralPublic, ciphertext, cipher.getAuthTag()]);
+}
+function openGossipPayload(sealed, walletSecretKey) {
+    if (sealed.length < exports.GOSSIP_SEAL_OVERHEAD)
+        throw new Error('A sealed payload is at least 48 bytes');
+    if (walletSecretKey.length !== 64)
+        throw new Error('The wallet secret key is the 64 bytes of a keypair');
+    const bytes = Buffer.from(sealed);
+    const ephemeralPublic = bytes.subarray(0, 32);
+    const tag = bytes.subarray(bytes.length - 16);
+    const ciphertext = bytes.subarray(32, bytes.length - 16);
+    const secret = x25519SecretFromEd25519Seed(walletSecretKey.subarray(0, 32));
+    const recipientPublic = x25519PublicFromEd25519(walletSecretKey.subarray(32, 64));
+    const shared = (0, crypto_1.diffieHellman)({ privateKey: privateKeyObject(secret), publicKey: publicKeyObject(ephemeralPublic) });
+    const decipher = (0, crypto_1.createDecipheriv)('chacha20-poly1305', symmetricKey(shared, ephemeralPublic, recipientPublic), ZERO_NONCE, { authTagLength: 16 });
+    decipher.setAuthTag(tag);
+    return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}

package/dist/idl.d.ts

@@ -0,0 +1,2 @@
+export declare function fieldOffset(idl: any, account: string, field: string): number;
+export declare function variantIndex(idl: any, enumName: string, variant: string): number;

package/dist/idl.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldOffset = fieldOffset;
+exports.variantIndex = variantIndex;
+const FIXED = {
+    bool: 1, u8: 1, i8: 1, u16: 2, i16: 2, u32: 4, i32: 4, f32: 4, u64: 8, i64: 8, f64: 8, u128: 16, i128: 16, pubkey: 32,
+};
+function typeDef(idl, name) {
+    const def = (idl.types ?? []).find((t) => t.name === name);
+    if (!def)
+        throw new Error(`The IDL has no type ${name}`);
+    return def;
+}
+function sizeOf(idl, type) {
+    if (typeof type === 'string') {
+        if (type in FIXED)
+            return FIXED[type];
+        throw new Error(`The size of ${type} is not fixed`);
+    }
+    if (type.array)
+        return sizeOf(idl, type.array[0]) * type.array[1];
+    if (type.defined) {
+        const def = typeDef(idl, type.defined.name);
+        if (def.type.kind === 'enum') {
+            if (def.type.variants.some((v) => v.fields && v.fields.length > 0)) {
+                throw new Error(`${def.name} carries data, so its size is not fixed`);
+            }
+            return 1;
+        }
+        return (def.type.fields ?? []).reduce((n, f) => n + sizeOf(idl, f.type), 0);
+    }
+    throw new Error('The size of this type is not fixed');
+}
+function fieldOffset(idl, account, field) {
+    const def = typeDef(idl, account);
+    if (def.type.kind !== 'struct')
+        throw new Error(`${account} is not a struct`);
+    let offset = 8;
+    for (const f of def.type.fields ?? []) {
+        if (f.name === field)
+            return offset;
+        offset += sizeOf(idl, f.type);
+    }
+    throw new Error(`${account} has no field ${field}`);
+}
+function variantIndex(idl, enumName, variant) {
+    const def = typeDef(idl, enumName);
+    const index = (def.type.variants ?? []).findIndex((v) => v.name.toLowerCase() === variant.toLowerCase());
+    if (index < 0)
+        throw new Error(`${enumName} has no variant ${variant}`);
+    return index;
+}

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+export * from './config';
+export * from './chain';
+export * from './addresses';
+export * from './token';
+export * from './receipt';
+export * from './signer';
+export * from './lookupTable';
+export * from './settlement';
+export * from './session';
+export * from './idl';
+export * from './sha256';
+export * from './log';
+export * from './epoch-root';
+export * from './replay';
+export * from './crank/runner';
+export * from './crank/prices';
+export * from './crank/gate';
+export * from './crank/shieldFees';
+export * from './crank/lending';
+export * from './lending';
+export * from './gossip';
+export * from './relayer/settings';
+export * from './relayer/limits';
+export * from './relayer/errors';
+export * from './relayer/relayer';
+export * from './relayer/chain';
+export * from './relayer/server';
+export * from './billing';
+export * from './observer';
+export * from './explorer';
+export * from './shieldLimits';

package/dist/index.js

@@ -0,0 +1,47 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./config"), exports);
+__exportStar(require("./chain"), exports);
+__exportStar(require("./addresses"), exports);
+__exportStar(require("./token"), exports);
+__exportStar(require("./receipt"), exports);
+__exportStar(require("./signer"), exports);
+__exportStar(require("./lookupTable"), exports);
+__exportStar(require("./settlement"), exports);
+__exportStar(require("./session"), exports);
+__exportStar(require("./idl"), exports);
+__exportStar(require("./sha256"), exports);
+__exportStar(require("./log"), exports);
+__exportStar(require("./epoch-root"), exports);
+__exportStar(require("./replay"), exports);
+__exportStar(require("./crank/runner"), exports);
+__exportStar(require("./crank/prices"), exports);
+__exportStar(require("./crank/gate"), exports);
+__exportStar(require("./crank/shieldFees"), exports);
+__exportStar(require("./crank/lending"), exports);
+__exportStar(require("./lending"), exports);
+__exportStar(require("./gossip"), exports);
+__exportStar(require("./relayer/settings"), exports);
+__exportStar(require("./relayer/limits"), exports);
+__exportStar(require("./relayer/errors"), exports);
+__exportStar(require("./relayer/relayer"), exports);
+__exportStar(require("./relayer/chain"), exports);
+__exportStar(require("./relayer/server"), exports);
+__exportStar(require("./billing"), exports);
+__exportStar(require("./observer"), exports);
+__exportStar(require("./explorer"), exports);
+__exportStar(require("./shieldLimits"), exports);

package/dist/lending.d.ts

@@ -0,0 +1,82 @@
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+export declare const LENDING_PAY_ALL = 18446744073709551615n;
+export declare function lendingVaultAddresses(pid: PublicKey, creator: PublicKey, nonce: bigint | number): {
+    vault: PublicKey;
+    cash: PublicKey;
+    collateral: PublicKey;
+};
+export declare const lendingLenderAddress: (pid: PublicKey, vault: PublicKey, lender: PublicKey) => PublicKey;
+export declare const lendingLoanAddress: (pid: PublicKey, vault: PublicKey, borrower: PublicKey, nonce: bigint | number) => PublicKey;
+export declare const lendingFeeAddress: (pid: PublicKey) => PublicKey;
+export declare function ensureAssociatedAccountInstruction(payer: PublicKey, owner: PublicKey, mint: PublicKey): TransactionInstruction;
+export interface CreateVaultOptions {
+    creator: PublicKey;
+    nonce: bigint;
+    collateralAssetId: number;
+    collateralMint: PublicKey;
+    borrowIsZga: boolean;
+    zgaMint: PublicKey;
+    collateralRatioBps: number;
+    liquidationThresholdBps: number;
+    interestRateBps: number;
+    originationFeeBps: number;
+    maxLoanDurationDays: number;
+}
+export declare function createLendingVault(program: any, o: CreateVaultOptions): any;
+export declare function depositLendingLiquidity(program: any, o: {
+    vault: PublicKey;
+    lender: PublicKey;
+    lenderTokenAccount: PublicKey;
+    amount: bigint;
+    minShares: bigint;
+    authority?: PublicKey;
+}): any;
+export declare function withdrawLendingLiquidity(program: any, o: {
+    vault: PublicKey;
+    lender: PublicKey;
+    lenderTokenAccount: PublicKey;
+    shares: bigint;
+    minAmount: bigint;
+    authority?: PublicKey;
+}): Promise<any>;
+export declare function openLendingLoan(program: any, o: {
+    vault: PublicKey;
+    borrower: PublicKey;
+    loanNonce: bigint;
+    collateralAmount: bigint;
+    principalAmount: bigint;
+    durationDays: number;
+    borrowerCollateralAccount: PublicKey;
+    borrowerBorrowAccount: PublicKey;
+    zgaMint: PublicKey;
+    authority?: PublicKey;
+}): Promise<any>;
+export declare function repayLendingLoan(program: any, o: {
+    vault: PublicKey;
+    borrower: PublicKey;
+    loanNonce: bigint;
+    amount: bigint;
+    borrowerCollateralAccount: PublicKey;
+    borrowerBorrowAccount: PublicKey;
+    authority?: PublicKey;
+}): any;
+export declare function addLendingCollateral(program: any, o: {
+    vault: PublicKey;
+    borrower: PublicKey;
+    loanNonce: bigint;
+    amount: bigint;
+    borrowerCollateralAccount: PublicKey;
+    authority?: PublicKey;
+}): any;
+export declare function extendLendingLoan(program: any, o: {
+    vault: PublicKey;
+    borrower: PublicKey;
+    loanNonce: bigint;
+    durationDays: number;
+    borrowerBorrowAccount: PublicKey;
+    authority?: PublicKey;
+}): Promise<any>;
+export declare function liquidateLendingLoan(program: any, o: {
+    loan: PublicKey;
+    liquidator: PublicKey;
+}): Promise<any>;