@zga/client 0.0.0-stage → 0.1.1

package/dist/lending.js

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lendingFeeAddress = exports.lendingLoanAddress = exports.lendingLenderAddress = exports.LENDING_PAY_ALL = void 0;
+exports.lendingVaultAddresses = lendingVaultAddresses;
+exports.ensureAssociatedAccountInstruction = ensureAssociatedAccountInstruction;
+exports.createLendingVault = createLendingVault;
+exports.depositLendingLiquidity = depositLendingLiquidity;
+exports.withdrawLendingLiquidity = withdrawLendingLiquidity;
+exports.openLendingLoan = openLendingLoan;
+exports.repayLendingLoan = repayLendingLoan;
+exports.addLendingCollateral = addLendingCollateral;
+exports.extendLendingLoan = extendLendingLoan;
+exports.liquidateLendingLoan = liquidateLendingLoan;
+const web3_js_1 = require("@solana/web3.js");
+const chain_1 = require("./chain");
+const token_1 = require("./token");
+const ASSOCIATED_TOKEN_PROGRAM = new web3_js_1.PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+const text = (s) => Buffer.from(s);
+const le8 = (n) => {
+    const b = Buffer.alloc(8);
+    b.writeBigUInt64LE(BigInt(n));
+    return b;
+};
+exports.LENDING_PAY_ALL = 18446744073709551615n;
+function lendingVaultAddresses(pid, creator, nonce) {
+    const vault = (0, chain_1.pda)(pid, text('znl_vault'), creator.toBuffer(), le8(nonce));
+    return {
+        vault,
+        cash: (0, chain_1.pda)(pid, text('znl_cash'), vault.toBuffer()),
+        collateral: (0, chain_1.pda)(pid, text('znl_collateral'), vault.toBuffer()),
+    };
+}
+const lendingLenderAddress = (pid, vault, lender) => (0, chain_1.pda)(pid, text('znl_lender'), vault.toBuffer(), lender.toBuffer());
+exports.lendingLenderAddress = lendingLenderAddress;
+const lendingLoanAddress = (pid, vault, borrower, nonce) => (0, chain_1.pda)(pid, text('znl_loan'), vault.toBuffer(), borrower.toBuffer(), le8(nonce));
+exports.lendingLoanAddress = lendingLoanAddress;
+const lendingFeeAddress = (pid) => (0, chain_1.pda)(pid, text('znl_fee_zgap'));
+exports.lendingFeeAddress = lendingFeeAddress;
+function common(pid) {
+    return {
+        registry: (0, chain_1.pda)(pid, text('asset_registry')),
+        config: (0, chain_1.pda)(pid, text('config')),
+        zgapAuthority: (0, chain_1.pda)(pid, text('zgap_authority')),
+        zgapMint: (0, chain_1.pda)(pid, text('zgap_mint')),
+        stakingVault: (0, chain_1.pda)(pid, text('staking_vault')),
+        stakingPool: (0, chain_1.pda)(pid, text('staking_pool')),
+        fee: (0, exports.lendingFeeAddress)(pid),
+    };
+}
+function ensureAssociatedAccountInstruction(payer, owner, mint) {
+    return new web3_js_1.TransactionInstruction({
+        programId: ASSOCIATED_TOKEN_PROGRAM,
+        keys: [
+            { pubkey: payer, isSigner: true, isWritable: true },
+            { pubkey: (0, token_1.associatedTokenAddress)(mint, owner), isSigner: false, isWritable: true },
+            { pubkey: owner, isSigner: false, isWritable: false },
+            { pubkey: mint, 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]),
+    });
+}
+function createLendingVault(program, o) {
+    const pid = program.programId;
+    const c = common(pid);
+    const a = lendingVaultAddresses(pid, o.creator, o.nonce);
+    return program.methods
+        .initZnlVault(new (require('bn.js'))(o.nonce.toString()), o.collateralAssetId, o.borrowIsZga, o.collateralRatioBps, o.liquidationThresholdBps, o.interestRateBps, o.originationFeeBps, o.maxLoanDurationDays)
+        .accountsPartial({
+        vault: a.vault, cashAccount: a.cash, collateralAccount: a.collateral, collateralMint: o.collateralMint,
+        borrowMint: o.borrowIsZga ? o.zgaMint : c.zgapMint, registry: c.registry, zgapAuthority: c.zgapAuthority, protocolConfig: c.config,
+        zgaMint: o.zgaMint, zgaCache: (0, chain_1.cachePda)(pid, chain_1.ZGA_ASSET_ID), creator: o.creator, tokenProgram: token_1.TOKEN_PROGRAM_ID, systemProgram: web3_js_1.SystemProgram.programId,
+    });
+}
+function depositLendingLiquidity(program, o) {
+    const pid = program.programId;
+    const c = common(pid);
+    const BN = require('bn.js');
+    return program.methods.depositZnlLiquidity(new BN(o.amount.toString()), new BN(o.minShares.toString())).accountsPartial({
+        vault: o.vault, cashAccount: (0, chain_1.pda)(pid, text('znl_cash'), o.vault.toBuffer()), lenderPosition: (0, exports.lendingLenderAddress)(pid, o.vault, o.lender),
+        lenderTokenAccount: o.lenderTokenAccount, protocolConfig: c.config, lender: o.lender, authority: o.authority ?? o.lender,
+        tokenProgram: token_1.TOKEN_PROGRAM_ID, systemProgram: web3_js_1.SystemProgram.programId,
+    });
+}
+async function withdrawLendingLiquidity(program, o) {
+    const pid = program.programId;
+    const BN = require('bn.js');
+    const v = await program.account.lendingVault.fetch(o.vault);
+    return program.methods.withdrawZnlLiquidity(new BN(o.shares.toString()), new BN(o.minAmount.toString()))
+        .accountsPartial({
+        vault: o.vault, cashAccount: (0, chain_1.pda)(pid, text('znl_cash'), o.vault.toBuffer()), lenderPosition: (0, exports.lendingLenderAddress)(pid, o.vault, o.lender),
+        lenderTokenAccount: o.lenderTokenAccount, collateralAccount: (0, chain_1.pda)(pid, text('znl_collateral'), o.vault.toBuffer()),
+        creator: v.creator, creatorCollateralAccount: (0, token_1.associatedTokenAddress)(v.collateralMint, v.creator),
+        lender: o.lender, authority: o.authority ?? o.lender, tokenProgram: token_1.TOKEN_PROGRAM_ID,
+    })
+        .preInstructions([ensureAssociatedAccountInstruction(o.lender, v.creator, v.collateralMint)]);
+}
+async function openLendingLoan(program, o) {
+    const pid = program.programId;
+    const c = common(pid);
+    const BN = require('bn.js');
+    const v = await program.account.lendingVault.fetch(o.vault);
+    return program.methods
+        .openZnlLoan(new BN(o.loanNonce.toString()), new BN(o.collateralAmount.toString()), new BN(o.principalAmount.toString()), o.durationDays)
+        .accountsPartial({
+        vault: o.vault, cashAccount: (0, chain_1.pda)(pid, text('znl_cash'), o.vault.toBuffer()), collateralAccount: (0, chain_1.pda)(pid, text('znl_collateral'), o.vault.toBuffer()),
+        loan: (0, exports.lendingLoanAddress)(pid, o.vault, o.borrower, o.loanNonce),
+        borrowerCollateralAccount: o.borrowerCollateralAccount, borrowerBorrowAccount: o.borrowerBorrowAccount,
+        collateralCache: (0, chain_1.cachePda)(pid, v.collateralAssetId), zgaCache: (0, chain_1.cachePda)(pid, chain_1.ZGA_ASSET_ID), registry: c.registry,
+        stakingVault: c.stakingVault, stakingPool: c.stakingPool, feeZgapAccount: c.fee, protocolConfig: c.config, zgaMint: o.zgaMint,
+        borrower: o.borrower, authority: o.authority ?? o.borrower, tokenProgram: token_1.TOKEN_PROGRAM_ID, systemProgram: web3_js_1.SystemProgram.programId,
+    });
+}
+function repayLendingLoan(program, o) {
+    const pid = program.programId;
+    const c = common(pid);
+    const BN = require('bn.js');
+    return program.methods.repayZnlLoan(new BN(o.amount.toString())).accountsPartial({
+        vault: o.vault, cashAccount: (0, chain_1.pda)(pid, text('znl_cash'), o.vault.toBuffer()), collateralAccount: (0, chain_1.pda)(pid, text('znl_collateral'), o.vault.toBuffer()),
+        loan: (0, exports.lendingLoanAddress)(pid, o.vault, o.borrower, o.loanNonce),
+        borrowerCollateralAccount: o.borrowerCollateralAccount, borrowerBorrowAccount: o.borrowerBorrowAccount,
+        stakingVault: c.stakingVault, stakingPool: c.stakingPool, feeZgapAccount: c.fee, borrower: o.borrower, authority: o.authority ?? o.borrower, tokenProgram: token_1.TOKEN_PROGRAM_ID,
+    });
+}
+function addLendingCollateral(program, o) {
+    const pid = program.programId;
+    const BN = require('bn.js');
+    return program.methods.addZnlCollateral(new BN(o.amount.toString())).accountsPartial({
+        vault: o.vault, collateralAccount: (0, chain_1.pda)(pid, text('znl_collateral'), o.vault.toBuffer()),
+        loan: (0, exports.lendingLoanAddress)(pid, o.vault, o.borrower, o.loanNonce),
+        borrowerCollateralAccount: o.borrowerCollateralAccount, borrower: o.borrower, authority: o.authority ?? o.borrower, tokenProgram: token_1.TOKEN_PROGRAM_ID,
+    });
+}
+async function extendLendingLoan(program, o) {
+    const pid = program.programId;
+    const c = common(pid);
+    const v = await program.account.lendingVault.fetch(o.vault);
+    return program.methods.extendZnlLoan(o.durationDays).accountsPartial({
+        vault: o.vault, cashAccount: (0, chain_1.pda)(pid, text('znl_cash'), o.vault.toBuffer()),
+        loan: (0, exports.lendingLoanAddress)(pid, o.vault, o.borrower, o.loanNonce), borrowerBorrowAccount: o.borrowerBorrowAccount,
+        collateralCache: (0, chain_1.cachePda)(pid, v.collateralAssetId), zgaCache: (0, chain_1.cachePda)(pid, chain_1.ZGA_ASSET_ID),
+        stakingVault: c.stakingVault, stakingPool: c.stakingPool, feeZgapAccount: c.fee, protocolConfig: c.config,
+        borrower: o.borrower, authority: o.authority ?? o.borrower, tokenProgram: token_1.TOKEN_PROGRAM_ID,
+    });
+}
+async function liquidateLendingLoan(program, o) {
+    const pid = program.programId;
+    const c = common(pid);
+    const loan = await program.account.lendingLoan.fetch(o.loan);
+    const v = await program.account.lendingVault.fetch(loan.vault);
+    return program.methods.liquidateZnlLoan()
+        .accountsPartial({
+        vault: loan.vault, cashAccount: (0, chain_1.pda)(pid, text('znl_cash'), loan.vault.toBuffer()),
+        collateralAccount: (0, chain_1.pda)(pid, text('znl_collateral'), loan.vault.toBuffer()), loan: o.loan,
+        borrowerWallet: loan.borrower, borrowerCollateralAccount: (0, token_1.associatedTokenAddress)(v.collateralMint, loan.borrower), collateralMint: v.collateralMint,
+        liquidatorBorrowAccount: (0, token_1.associatedTokenAddress)(v.borrowMint, o.liquidator),
+        liquidatorCollateralAccount: (0, token_1.associatedTokenAddress)(v.collateralMint, o.liquidator),
+        collateralCache: (0, chain_1.cachePda)(pid, v.collateralAssetId), zgaCache: (0, chain_1.cachePda)(pid, chain_1.ZGA_ASSET_ID),
+        stakingVault: c.stakingVault, stakingPool: c.stakingPool, feeZgapAccount: c.fee,
+        liquidator: o.liquidator, tokenProgram: token_1.TOKEN_PROGRAM_ID, associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM, systemProgram: web3_js_1.SystemProgram.programId,
+    })
+        .preInstructions([ensureAssociatedAccountInstruction(o.liquidator, o.liquidator, v.collateralMint)]);
+}

package/dist/log.d.ts

@@ -0,0 +1,27 @@
+export interface LogEntry {
+    seq: number;
+    player: Uint8Array;
+    action: Uint8Array;
+}
+export declare const MAX_ACTION_BYTES = 65536;
+export declare const MAX_LOG_ENTRIES: number;
+export declare function leafHash(e: LogEntry): Uint8Array;
+export declare function nodeHash(left: Uint8Array, right: Uint8Array): Uint8Array;
+export declare function rootOfLeaves(leaves: Uint8Array[]): Uint8Array;
+export declare function logRoot(entries: LogEntry[]): Uint8Array;
+export declare class LogRecorder {
+    private entries;
+    append(player: Uint8Array, action: Uint8Array): LogEntry;
+    get length(): number;
+    all(): LogEntry[];
+    root(): Uint8Array;
+}
+export interface InclusionProof {
+    index: number;
+    count: number;
+    siblings: Uint8Array[];
+}
+export declare function prove(entries: LogEntry[], index: number): InclusionProof;
+export declare function verifyProof(entry: LogEntry, proof: InclusionProof, root: Uint8Array): boolean;
+export declare function encodeLog(entries: LogEntry[]): Uint8Array;
+export declare function decodeLog(bytes: Uint8Array): LogEntry[];

package/dist/log.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogRecorder = exports.MAX_LOG_ENTRIES = exports.MAX_ACTION_BYTES = void 0;
+exports.leafHash = leafHash;
+exports.nodeHash = nodeHash;
+exports.rootOfLeaves = rootOfLeaves;
+exports.logRoot = logRoot;
+exports.prove = prove;
+exports.verifyProof = verifyProof;
+exports.encodeLog = encodeLog;
+exports.decodeLog = decodeLog;
+const sha256_1 = require("./sha256");
+exports.MAX_ACTION_BYTES = 65536;
+exports.MAX_LOG_ENTRIES = 1 << 20;
+const LEAF_TAG = Uint8Array.of(0x00);
+const NODE_TAG = Uint8Array.of(0x01);
+function u32le(n) {
+    const b = new Uint8Array(4);
+    new DataView(b.buffer).setUint32(0, n, true);
+    return b;
+}
+function equal(a, b) {
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++)
+        if (a[i] !== b[i])
+            return false;
+    return true;
+}
+function checkEntry(e) {
+    if (!Number.isInteger(e.seq) || e.seq < 0 || e.seq > 4294967295)
+        throw new Error('A log entry carries an invalid sequence number');
+    if (e.player.length !== 32)
+        throw new Error('A log entry names its player by a 32-byte key');
+    if (e.action.length > exports.MAX_ACTION_BYTES)
+        throw new Error(`An action is longer than ${exports.MAX_ACTION_BYTES} bytes`);
+}
+function leafHash(e) {
+    checkEntry(e);
+    return (0, sha256_1.sha256)(LEAF_TAG, u32le(e.seq), e.player, u32le(e.action.length), e.action);
+}
+function nodeHash(left, right) {
+    return (0, sha256_1.sha256)(NODE_TAG, left, right);
+}
+function levels(leaves) {
+    if (leaves.length === 0)
+        throw new Error('An empty log has no root');
+    const out = [leaves];
+    let current = leaves;
+    while (current.length > 1) {
+        const next = [];
+        for (let i = 0; i < current.length; i += 2) {
+            next.push(i + 1 < current.length ? nodeHash(current[i], current[i + 1]) : current[i]);
+        }
+        out.push(next);
+        current = next;
+    }
+    return out;
+}
+function leavesOf(entries) {
+    if (entries.length > exports.MAX_LOG_ENTRIES)
+        throw new Error(`A log holds at most ${exports.MAX_LOG_ENTRIES} entries`);
+    entries.forEach((e, i) => {
+        if (e.seq !== i)
+            throw new Error(`Log entry ${i} carries sequence ${e.seq}`);
+    });
+    return entries.map(leafHash);
+}
+function rootOfLeaves(leaves) {
+    const lv = levels(leaves);
+    return lv[lv.length - 1][0];
+}
+function logRoot(entries) {
+    return rootOfLeaves(leavesOf(entries));
+}
+class LogRecorder {
+    constructor() {
+        this.entries = [];
+    }
+    append(player, action) {
+        const entry = { seq: this.entries.length, player: Uint8Array.from(player), action: Uint8Array.from(action) };
+        checkEntry(entry);
+        if (this.entries.length >= exports.MAX_LOG_ENTRIES)
+            throw new Error(`A log holds at most ${exports.MAX_LOG_ENTRIES} entries`);
+        this.entries.push(entry);
+        return entry;
+    }
+    get length() {
+        return this.entries.length;
+    }
+    all() {
+        return this.entries.slice();
+    }
+    root() {
+        return logRoot(this.entries);
+    }
+}
+exports.LogRecorder = LogRecorder;
+function prove(entries, index) {
+    const lv = levels(leavesOf(entries));
+    if (!Number.isInteger(index) || index < 0 || index >= entries.length)
+        throw new Error('The index is outside the log');
+    const siblings = [];
+    let at = index;
+    for (let l = 0; l < lv.length - 1; l++) {
+        const sibling = at ^ 1;
+        if (sibling < lv[l].length)
+            siblings.push(lv[l][sibling]);
+        at >>= 1;
+    }
+    return { index, count: entries.length, siblings };
+}
+function verifyProof(entry, proof, root) {
+    if (entry.seq !== proof.index || proof.index >= proof.count)
+        return false;
+    let hash = leafHash(entry);
+    let at = proof.index;
+    let width = proof.count;
+    let used = 0;
+    while (width > 1) {
+        const sibling = at ^ 1;
+        if (sibling < width) {
+            if (used >= proof.siblings.length)
+                return false;
+            const s = proof.siblings[used++];
+            hash = (at & 1) === 0 ? nodeHash(hash, s) : nodeHash(s, hash);
+        }
+        at >>= 1;
+        width = Math.ceil(width / 2);
+    }
+    return used === proof.siblings.length && equal(hash, root);
+}
+function encodeLog(entries) {
+    leavesOf(entries);
+    const size = entries.reduce((n, e) => n + 4 + 32 + 4 + e.action.length, 0);
+    const out = new Uint8Array(size);
+    const view = new DataView(out.buffer);
+    let at = 0;
+    for (const e of entries) {
+        view.setUint32(at, e.seq, true);
+        out.set(e.player, at + 4);
+        view.setUint32(at + 36, e.action.length, true);
+        out.set(e.action, at + 40);
+        at += 40 + e.action.length;
+    }
+    return out;
+}
+function decodeLog(bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const entries = [];
+    let at = 0;
+    while (at < bytes.length) {
+        if (at + 40 > bytes.length)
+            throw new Error('The log is truncated');
+        const seq = view.getUint32(at, true);
+        const length = view.getUint32(at + 36, true);
+        if (seq !== entries.length)
+            throw new Error(`Log entry ${entries.length} carries sequence ${seq}`);
+        if (length > exports.MAX_ACTION_BYTES)
+            throw new Error(`An action is longer than ${exports.MAX_ACTION_BYTES} bytes`);
+        if (at + 40 + length > bytes.length)
+            throw new Error('The log is truncated');
+        if (entries.length >= exports.MAX_LOG_ENTRIES)
+            throw new Error(`A log holds at most ${exports.MAX_LOG_ENTRIES} entries`);
+        entries.push({
+            seq,
+            player: bytes.slice(at + 4, at + 36),
+            action: bytes.slice(at + 40, at + 40 + length),
+        });
+        at += 40 + length;
+    }
+    return entries;
+}

package/dist/lookupTable.d.ts

@@ -0,0 +1,2 @@
+import { AddressLookupTableAccount, Connection, Keypair, PublicKey } from '@solana/web3.js';
+export declare function ensureLookupTable(connection: Connection, payer: Keypair, wanted: PublicKey[], cachePath: string): Promise<AddressLookupTableAccount>;

package/dist/lookupTable.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureLookupTable = ensureLookupTable;
+const web3_js_1 = require("@solana/web3.js");
+const fs_1 = require("fs");
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function ensureLookupTable(connection, payer, wanted, cachePath) {
+    let address = null;
+    if ((0, fs_1.existsSync)(cachePath)) {
+        try {
+            address = new web3_js_1.PublicKey((0, fs_1.readFileSync)(cachePath, 'utf8').trim());
+        }
+        catch {
+            address = null;
+        }
+    }
+    if (address && !(await connection.getAddressLookupTable(address)).value)
+        address = null;
+    if (!address) {
+        const [createIx, created] = web3_js_1.AddressLookupTableProgram.createLookupTable({
+            authority: payer.publicKey, payer: payer.publicKey, recentSlot: await connection.getSlot('finalized'),
+        });
+        await (0, web3_js_1.sendAndConfirmTransaction)(connection, new web3_js_1.Transaction().add(createIx), [payer]);
+        address = created;
+        (0, fs_1.writeFileSync)(cachePath, address.toBase58());
+    }
+    let table = (await connection.getAddressLookupTable(address)).value;
+    const have = new Set((table?.state.addresses ?? []).map((a) => a.toBase58()));
+    const missing = wanted.filter((a) => !have.has(a.toBase58()));
+    for (let i = 0; i < missing.length; i += 20) {
+        const extend = web3_js_1.AddressLookupTableProgram.extendLookupTable({
+            lookupTable: address, authority: payer.publicKey, payer: payer.publicKey, addresses: missing.slice(i, i + 20),
+        });
+        await (0, web3_js_1.sendAndConfirmTransaction)(connection, new web3_js_1.Transaction().add(extend), [payer]);
+    }
+    for (let tries = 0; tries < 40; tries++) {
+        table = (await connection.getAddressLookupTable(address)).value;
+        if (table && wanted.every((w) => table.state.addresses.some((a) => a.equals(w))))
+            break;
+        await sleep(500);
+    }
+    if (!table)
+        throw new Error('The lookup table was not found');
+    if (missing.length > 0)
+        await sleep(2000);
+    return table;
+}

package/dist/observer.d.ts

@@ -0,0 +1,59 @@
+import { Connection, PublicKey } from '@solana/web3.js';
+import { BillingTerms, UsageReceipt } from './billing';
+import { ExplorerPolicy } from './explorer';
+export declare function ed25519Sign(secretKey: Uint8Array, message: Uint8Array): Uint8Array;
+export declare function ed25519Verify(publicKey: Uint8Array, message: Uint8Array, signature: Uint8Array): boolean;
+export declare function envelopeHeaders(secretKey: Uint8Array, publicKey: PublicKey, id: string, nowSeconds?: number): Record<string, string>;
+export declare class AvailabilityLog {
+    private readonly path;
+    private readonly keepMs;
+    private samples;
+    constructor(path?: string | null, keepMs?: number);
+    record(key: string, up: boolean, atMs?: number): void;
+    count(key: string): number;
+    save(): void;
+    coverage(key: string, fromMs: number, toMs: number, intervalMs: number): {
+        expected: number;
+        samples: number;
+        up: number;
+    };
+}
+export declare function availabilityAcceptable(c: {
+    expected: number;
+    samples: number;
+    up: number;
+}, minCoverage?: number, minUp?: number): boolean;
+export type UrlGuard = (url: string) => Promise<URL>;
+export declare function probeGuild(base: string, guard?: UrlGuard): Promise<boolean>;
+export interface PendingReceipt {
+    session: string;
+    player: string;
+    hours: number;
+    fromSlot: string;
+    toSlot: string;
+    hashHex: string;
+    guildSignature: string;
+}
+export declare function fetchPendingReceipts(base: string, secretKey: Uint8Array, publicKey: PublicKey, guard?: UrlGuard): Promise<PendingReceipt[]>;
+export declare function postAttestation(base: string, secretKey: Uint8Array, publicKey: PublicKey, hashHex: string, signature: Uint8Array, guard?: UrlGuard): Promise<boolean>;
+export declare function checkUsageReceipt(program: any, receipt: UsageReceipt, currentSlot: bigint, terms?: BillingTerms): Promise<string | null>;
+export interface ObserverEnv {
+    program: any;
+    connection: Connection;
+    secretKey: Uint8Array;
+    publicKey: PublicKey;
+    log: AvailabilityLog;
+    guard?: UrlGuard;
+    terms?: BillingTerms;
+    probeIntervalMs?: number;
+    minCoverage?: number;
+    minUp?: number;
+    explorer?: ExplorerPolicy;
+}
+export declare function attestPendingReceipts(env: ObserverEnv, guildKey: PublicKey, base: string): Promise<{
+    attested: string[];
+    declined: Array<{
+        hashHex: string;
+        reason: string;
+    }>;
+}>;