@zga/client 0.0.0-stage → 0.1.1

package/dist/relayer/relayer.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShieldedRelayer = exports.refuse = void 0;
+const relayer_1 = require("@zga/shielded-sdk/dist/relayer");
+const errors_1 = require("./errors");
+const refuse = (status, code, message) => ({ status, body: { code, message } });
+exports.refuse = refuse;
+class ShieldedRelayer {
+    constructor(chain, rate, inflight, log = () => { }) {
+        this.chain = chain;
+        this.rate = rate;
+        this.inflight = inflight;
+        this.log = log;
+    }
+    info() {
+        return { status: 200, body: this.chain.info() };
+    }
+    async unshield(raw, clientKey) {
+        if (!this.rate.allow(clientKey))
+            return (0, exports.refuse)(429, 'rate_limited', 'too many requests: try again in a minute');
+        const check = (0, relayer_1.checkUnshieldRequest)(this.chain.info(), raw);
+        if (!check.ok)
+            return (0, exports.refuse)(422, check.code, check.message);
+        const req = raw;
+        const key = req.nullifiers[0];
+        const entered = this.inflight.tryEnter(key);
+        if (entered === 'duplicate')
+            return (0, exports.refuse)(409, 'in_progress', 'this request is already being handled');
+        if (entered === 'busy')
+            return (0, exports.refuse)(503, 'busy', 'the relayer is handling as many requests as it takes: try again shortly');
+        try {
+            if (await this.chain.lowBalance()) {
+                this.log('refused: the relayer is short of SOL');
+                return (0, exports.refuse)(503, 'relayer_unavailable', 'the relayer cannot take requests at the moment');
+            }
+            if (await this.chain.anySpent(req.nullifiers))
+                return (0, exports.refuse)(422, 'already_spent', 'a note that this transaction spends has been spent');
+            const current = await this.chain.currentPool();
+            const { signature } = await this.chain.submit(req, current);
+            this.log(`relayed an exit of asset ${req.assetId}: ${signature}`);
+            return { status: 200, body: { signature } };
+        }
+        catch (e) {
+            if (e instanceof errors_1.RelayRefused)
+                return (0, exports.refuse)(422, e.code, e.message);
+            this.log(`submission failed: ${String(e?.message ?? e).slice(0, 160)}`);
+            return (0, exports.refuse)(502, 'submission_failed', 'the transaction could not be sent or confirmed: try again');
+        }
+        finally {
+            this.inflight.leave(key);
+        }
+    }
+}
+exports.ShieldedRelayer = ShieldedRelayer;

package/dist/relayer/server.d.ts

@@ -0,0 +1,8 @@
+import * as http from 'http';
+import { ShieldedRelayer } from './relayer';
+export interface RelayerServerOptions {
+    maxBodyBytes: number;
+    trustProxy: boolean;
+    corsOrigin: string;
+}
+export declare function createShieldedRelayerServer(relayer: ShieldedRelayer, opts: RelayerServerOptions): http.Server;

package/dist/relayer/server.js

@@ -0,0 +1,101 @@
+"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.createShieldedRelayerServer = createShieldedRelayerServer;
+const http = __importStar(require("http"));
+const relayer_1 = require("./relayer");
+class BodyTooLarge extends Error {
+}
+function readBody(req, limit) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        let size = 0;
+        let tooLarge = false;
+        req.on('data', (chunk) => {
+            size += chunk.length;
+            if (size > limit) {
+                tooLarge = true;
+                return;
+            }
+            chunks.push(chunk);
+        });
+        req.on('end', () => (tooLarge ? reject(new BodyTooLarge()) : resolve(Buffer.concat(chunks).toString('utf8'))));
+        req.on('error', reject);
+    });
+}
+function createShieldedRelayerServer(relayer, opts) {
+    const server = http.createServer(async (req, res) => {
+        const send = (r) => {
+            res.writeHead(r.status, {
+                'content-type': 'application/json',
+                'cache-control': 'no-store',
+                'access-control-allow-origin': opts.corsOrigin,
+                'access-control-allow-methods': 'GET, POST, OPTIONS',
+                'access-control-allow-headers': 'content-type',
+            });
+            res.end(JSON.stringify(r.body));
+        };
+        try {
+            const url = (req.url ?? '').split('?')[0];
+            if (req.method === 'OPTIONS')
+                return send({ status: 204, body: {} });
+            if (req.method === 'GET' && url === '/v1/info')
+                return send(relayer.info());
+            if (req.method === 'GET' && url === '/healthz')
+                return send({ status: 200, body: { ok: true } });
+            if (req.method === 'POST' && url === '/v1/unshield') {
+                const text = await readBody(req, opts.maxBodyBytes);
+                let json;
+                try {
+                    json = JSON.parse(text);
+                }
+                catch {
+                    return send((0, relayer_1.refuse)(400, 'malformed', 'the body is not JSON'));
+                }
+                const forwarded = String(req.headers['x-forwarded-for'] ?? '').split(',')[0].trim();
+                const caller = opts.trustProxy && forwarded ? forwarded : req.socket.remoteAddress ?? 'unknown';
+                return send(await relayer.unshield(json, caller));
+            }
+            return send((0, relayer_1.refuse)(404, 'not_found', 'there is nothing at that address'));
+        }
+        catch (e) {
+            if (e instanceof BodyTooLarge)
+                return send((0, relayer_1.refuse)(413, 'too_large', 'the request is larger than this relayer takes'));
+            return send((0, relayer_1.refuse)(500, 'internal', 'the relayer failed to handle the request'));
+        }
+    });
+    server.setTimeout(30000);
+    return server;
+}

package/dist/relayer/settings.d.ts

@@ -0,0 +1,23 @@
+export interface RelayerAssetSetting {
+    assetId: number;
+    minFee: string;
+    feeBps: number;
+}
+export interface RelayerSettings {
+    host: string;
+    port: number;
+    assets: RelayerAssetSetting[];
+    lookupTables: string[];
+    operator: string | null;
+    priorityMicroLamports: number;
+    computeUnitLimit: number;
+    maxBodyBytes: number;
+    maxInFlight: number;
+    ratePerMinute: number;
+    minBalanceLamports: number;
+    trustProxy: boolean;
+    corsOrigin: string;
+    logRequests: boolean;
+}
+export declare function parseAssets(text: string): RelayerAssetSetting[];
+export declare function readRelayerSettings(env?: NodeJS.ProcessEnv): RelayerSettings;

package/dist/relayer/settings.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAssets = parseAssets;
+exports.readRelayerSettings = readRelayerSettings;
+const fs_1 = require("fs");
+const U64_MAX = (1n << 64n) - 1n;
+function intFrom(env, key, fallback, lo, hi) {
+    const v = env[key];
+    if (v === undefined || v === '')
+        return fallback;
+    const n = Number(v);
+    if (!Number.isInteger(n) || n < lo || n > hi)
+        throw new Error(`${key} must be an integer from ${lo} to ${hi}`);
+    return n;
+}
+function parseAssets(text) {
+    let list;
+    try {
+        list = JSON.parse(text);
+    }
+    catch {
+        throw new Error('RELAYER_ASSETS is not valid JSON');
+    }
+    if (!Array.isArray(list) || list.length === 0)
+        throw new Error('RELAYER_ASSETS must list at least one asset');
+    const seen = new Set();
+    return list.map((a, i) => {
+        if (!a || !Number.isInteger(a.assetId) || a.assetId < 0 || a.assetId > 255)
+            throw new Error(`RELAYER_ASSETS[${i}].assetId must be an integer from 0 to 255`);
+        if (seen.has(a.assetId))
+            throw new Error(`RELAYER_ASSETS lists asset ${a.assetId} twice`);
+        seen.add(a.assetId);
+        if (typeof a.minFee !== 'string' || !/^[0-9]{1,20}$/.test(a.minFee) || BigInt(a.minFee) > U64_MAX)
+            throw new Error(`RELAYER_ASSETS[${i}].minFee must be a decimal string of a 64-bit amount`);
+        if (!Number.isInteger(a.feeBps) || a.feeBps < 0 || a.feeBps > 10000)
+            throw new Error(`RELAYER_ASSETS[${i}].feeBps must be an integer from 0 to 10000`);
+        return { assetId: a.assetId, minFee: a.minFee, feeBps: a.feeBps };
+    });
+}
+function parseOperator(v) {
+    const s = (v ?? '').trim();
+    if (!s)
+        return null;
+    if (!/^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(s))
+        throw new Error('RELAYER_OPERATOR must be the NOP operator\'s public key, in base58');
+    return s;
+}
+function readRelayerSettings(env = process.env) {
+    const raw = env.RELAYER_ASSETS;
+    if (!raw)
+        throw new Error('RELAYER_ASSETS is not set: a JSON list of {assetId, minFee, feeBps}, or the path of a file that holds it');
+    const text = raw.trim().startsWith('[') ? raw : (0, fs_1.readFileSync)(raw, 'utf8');
+    return {
+        host: env.RELAYER_HOST ?? '127.0.0.1',
+        operator: parseOperator(env.RELAYER_OPERATOR),
+        port: intFrom(env, 'RELAYER_PORT', 8787, 1, 65535),
+        assets: parseAssets(text),
+        lookupTables: (env.RELAYER_LOOKUP_TABLES ?? '').split(',').map((s) => s.trim()).filter(Boolean),
+        priorityMicroLamports: intFrom(env, 'RELAYER_PRIORITY_MICROLAMPORTS', 0, 0, 10000000),
+        computeUnitLimit: intFrom(env, 'RELAYER_COMPUTE_UNITS', 400000, 200000, 1400000),
+        maxBodyBytes: intFrom(env, 'RELAYER_MAX_BODY_BYTES', 16384, 1024, 1048576),
+        maxInFlight: intFrom(env, 'RELAYER_MAX_IN_FLIGHT', 4, 1, 64),
+        ratePerMinute: intFrom(env, 'RELAYER_RATE_PER_MINUTE', 20, 1, 6000),
+        minBalanceLamports: intFrom(env, 'RELAYER_MIN_BALANCE_LAMPORTS', 50000000, 0, 1000000000000),
+        trustProxy: env.RELAYER_TRUST_PROXY === '1',
+        corsOrigin: env.RELAYER_CORS_ORIGIN ?? '*',
+        logRequests: env.RELAYER_LOG_REQUESTS === '1',
+    };
+}

package/dist/replay.d.ts

@@ -0,0 +1,13 @@
+import { LogEntry } from './log';
+export declare const MAX_MODULE_PAGES = 1024;
+export declare const MAX_PLACES = 3;
+export type ReplayResult = {
+    ok: true;
+    ranking: Uint8Array[] | null;
+} | {
+    ok: false;
+    reason: string;
+    at?: number;
+};
+export declare function replay(moduleBytes: Uint8Array, sessionId: Uint8Array, players: Uint8Array[], entries: LogEntry[]): Promise<ReplayResult>;
+export declare function orderPlayers(players: Uint8Array[]): Uint8Array[];

package/dist/replay.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_PLACES = exports.MAX_MODULE_PAGES = void 0;
+exports.replay = replay;
+exports.orderPlayers = orderPlayers;
+const sha256_1 = require("./sha256");
+exports.MAX_MODULE_PAGES = 1024;
+exports.MAX_PLACES = 3;
+const OUTCOME_CAPACITY = 4 + 32 * exports.MAX_PLACES;
+const fail = (reason, at) => ({ ok: false, reason, at });
+function wasm() {
+    const w = globalThis.WebAssembly;
+    if (!w)
+        throw new Error('WebAssembly is not available');
+    return w;
+}
+function u32le(n) {
+    const b = new Uint8Array(4);
+    new DataView(b.buffer).setUint32(0, n, true);
+    return b;
+}
+const hex = sha256_1.toHex;
+async function replay(moduleBytes, sessionId, players, entries) {
+    const W = wasm();
+    if (sessionId.length !== 32)
+        return fail('The session id is not 32 bytes');
+    if (players.some((p) => p.length !== 32))
+        return fail('A player key is not 32 bytes');
+    let module;
+    try {
+        module = await W.compile(moduleBytes);
+    }
+    catch (e) {
+        return fail(`The module does not compile: ${e.message}`);
+    }
+    if (W.Module.imports(module).length > 0)
+        return fail('The module imports host functions');
+    const exported = new Set(W.Module.exports(module).map((e) => e.name));
+    for (const name of ['memory', 'alloc', 'init', 'apply', 'outcome']) {
+        if (!exported.has(name))
+            return fail(`The module does not export ${name}`);
+    }
+    let instance;
+    try {
+        instance = await W.instantiate(module, {});
+    }
+    catch (e) {
+        return fail(`The module does not instantiate: ${e.message}`);
+    }
+    const ex = instance.exports;
+    const within = () => ex.memory.buffer.byteLength <= exports.MAX_MODULE_PAGES * 65536;
+    const put = (bytes) => {
+        const ptr = ex.alloc(bytes.length) >>> 0;
+        if (!within() || ptr + bytes.length > ex.memory.buffer.byteLength)
+            throw new Error('The module returned a region outside its memory');
+        new Uint8Array(ex.memory.buffer, ptr, bytes.length).set(bytes);
+        return ptr;
+    };
+    const known = new Set(players.map(hex));
+    try {
+        const initInput = new Uint8Array(32 + 4 + 32 * players.length);
+        initInput.set(sessionId, 0);
+        initInput.set(u32le(players.length), 32);
+        players.forEach((p, i) => initInput.set(p, 36 + 32 * i));
+        const rc = ex.init(put(initInput), initInput.length);
+        if (rc !== 0)
+            return fail(`The module refused the session (${rc})`);
+        for (let i = 0; i < entries.length; i++) {
+            const e = entries[i];
+            if (e.seq !== i)
+                return fail(`Log entry ${i} carries sequence ${e.seq}`, i);
+            if (!known.has(hex(e.player)))
+                return fail('An action names a player who is not in the session', i);
+            const input = new Uint8Array(32 + e.action.length);
+            input.set(e.player, 0);
+            input.set(e.action, 32);
+            const accepted = ex.apply(put(input), input.length);
+            if (accepted !== 0)
+                return fail(`The module rejected the action (${accepted})`, i);
+            if (!within())
+                return fail('The module grew its memory past the limit', i);
+        }
+        const out = ex.alloc(OUTCOME_CAPACITY) >>> 0;
+        if (!within() || out + OUTCOME_CAPACITY > ex.memory.buffer.byteLength)
+            return fail('The module returned a region outside its memory');
+        const written = ex.outcome(out);
+        if (written < 0)
+            return fail('The module has no outcome for this log');
+        if (written < 4 || written > OUTCOME_CAPACITY)
+            return fail('The module wrote an outcome of an invalid length');
+        const bytes = new Uint8Array(ex.memory.buffer, out, written);
+        const places = new DataView(bytes.buffer, bytes.byteOffset, written).getUint32(0, true);
+        if (places > exports.MAX_PLACES || written !== 4 + 32 * places)
+            return fail('The module wrote a malformed outcome');
+        if (places === 0)
+            return { ok: true, ranking: null };
+        const ranking = [];
+        for (let p = 0; p < places; p++)
+            ranking.push(bytes.slice(4 + 32 * p, 36 + 32 * p));
+        if (!ranking.every((k) => known.has(hex(k))))
+            return fail('The outcome names a player who is not in the session');
+        if (new Set(ranking.map(hex)).size !== places)
+            return fail('The outcome names a player twice');
+        return { ok: true, ranking };
+    }
+    catch (e) {
+        return fail(`The module trapped: ${e.message}`);
+    }
+}
+function orderPlayers(players) {
+    return [...players].sort((a, b) => {
+        const n = Math.min(a.length, b.length);
+        for (let i = 0; i < n; i++)
+            if (a[i] !== b[i])
+                return a[i] - b[i];
+        return a.length - b.length;
+    });
+}

package/dist/session.d.ts

@@ -0,0 +1,29 @@
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+export interface CreateSessionArgs {
+    gameId: Uint8Array;
+    entryFee: bigint;
+    maxPlayers: number;
+    minPlayers: number;
+    prizeSplitBps?: number[];
+    fundingTimeoutSlots?: bigint;
+    sessionId?: Uint8Array;
+}
+export declare function createSession(env: {
+    program: any;
+    connection: Connection;
+    host: Keypair;
+    guild: PublicKey;
+}, a: CreateSessionArgs): Promise<{
+    session: PublicKey;
+    sessionId: Uint8Array;
+    signature: string;
+}>;
+export declare function depositEntry(env: {
+    program: any;
+    player: Keypair;
+}, args: {
+    session: PublicKey;
+    gameId: Uint8Array;
+    entryFee: bigint;
+    zgaMint: PublicKey;
+}): Promise<string>;

package/dist/session.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSession = createSession;
+exports.depositEntry = depositEntry;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@coral-xyz/anchor");
+const crypto_1 = require("crypto");
+const addresses_1 = require("./addresses");
+const token_1 = require("./token");
+async function createSession(env, a) {
+    const addr = new addresses_1.Addresses(env.program.programId);
+    const sessionId = a.sessionId ?? (0, crypto_1.randomBytes)(32);
+    const session = addr.session(sessionId);
+    const signature = await env.program.methods.createSession(Array.from(sessionId), Array.from(a.gameId), new anchor_1.BN(a.entryFee.toString()), a.maxPlayers, a.minPlayers, env.guild, { minimum: {} }, new anchor_1.BN((a.fundingTimeoutSlots ?? 999999999n).toString()), a.prizeSplitBps ?? []).accounts({
+        session, vault: addr.vault(session), zgapAuthority: addr.zgapAuthority, mint: addr.zgapMint,
+        gameManifest: addr.gameManifest(a.gameId), rateLimit: addr.rateLimit(env.guild), protocolConfig: addr.config,
+        validatorRegistry: null, subsidyPool: null, guildAccount: env.guild, prizeVault: addr.prizeVault(session),
+        host: env.host.publicKey, tokenProgram: token_1.TOKEN_PROGRAM_ID, systemProgram: web3_js_1.SystemProgram.programId, rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+    }).signers([env.host]).rpc();
+    return { session, sessionId, signature };
+}
+async function depositEntry(env, args) {
+    const addr = new addresses_1.Addresses(env.program.programId);
+    const user = env.player.publicKey;
+    return env.program.methods.depositEntry(new anchor_1.BN(args.entryFee.toString())).accounts({
+        user, session: args.session, playerAccount: addr.player(args.session, user), vault: addr.vault(args.session),
+        userTokenAccount: (0, token_1.associatedTokenAddress)(addr.zgapMint, user), gameManifest: addr.gameManifest(args.gameId),
+        playerZgaAccount: (0, token_1.associatedTokenAddress)(args.zgaMint, user), agentBond: addr.agentBond(user),
+        tokenProgram: token_1.TOKEN_PROGRAM_ID, systemProgram: web3_js_1.SystemProgram.programId,
+    }).signers([env.player]).rpc();
+}

package/dist/settlement.d.ts

@@ -0,0 +1,17 @@
+import { AddressLookupTableAccount, Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { Addresses } from './addresses';
+import { EnclaveSigner } from './signer';
+export interface SettleEnv {
+    program: any;
+    connection: Connection;
+    payer: Keypair;
+    enclave: EnclaveSigner;
+    lookupTable: AddressLookupTableAccount;
+}
+export interface SettleArgs {
+    session: PublicKey;
+    ranking: PublicKey[] | null;
+    logRoot?: Uint8Array | null;
+}
+export declare function settlementStaticAccounts(connection: Connection, addresses: Addresses, guild: PublicKey, enclave: PublicKey, operator: PublicKey): Promise<PublicKey[]>;
+export declare function settleSession(env: SettleEnv, args: SettleArgs): Promise<string>;

package/dist/settlement.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.settlementStaticAccounts = settlementStaticAccounts;
+exports.settleSession = settleSession;
+const web3_js_1 = require("@solana/web3.js");
+const anchor_1 = require("@coral-xyz/anchor");
+const addresses_1 = require("./addresses");
+const receipt_1 = require("./receipt");
+const token_1 = require("./token");
+async function settlementStaticAccounts(connection, addresses, guild, enclave, operator) {
+    const zgaMint = await (0, addresses_1.zgaMintOf)(connection, addresses);
+    return [
+        addresses.priceCache(0), addresses.priceCache(1), addresses.zgapSolVault, addresses.zgapReserveSol,
+        addresses.config, addresses.zgapAuthority, addresses.zgapMint, zgaMint, addresses.zgapCollateralVault, addresses.zgapReserve,
+        (0, token_1.associatedTokenAddress)(zgaMint, addresses.zgapReserve), addresses.lpLock, addresses.yieldVault, addresses.rewardDistributor,
+        (0, token_1.associatedTokenAddress)(addresses.zgapMint, operator), guild, addresses.rateLimit(guild), addresses.attestationCert(enclave),
+    ];
+}
+async function settleSession(env, args) {
+    const { program, connection, payer, enclave, lookupTable } = env;
+    const addr = new addresses_1.Addresses(program.programId);
+    const session = await program.account.session.fetch(args.session);
+    const config = await program.account.protocolConfig.fetch(addr.config);
+    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 places = session.prizePlaces;
+    const draw = args.ranking === null;
+    if (!draw) {
+        const ranking = args.ranking;
+        if (ranking.length !== places)
+            throw new Error(`The session has ${places} prize place(s)`);
+        if (new Set(ranking.map((k) => k.toBase58())).size !== places)
+            throw new Error('A prize place is named twice');
+    }
+    const vault = addr.vault(args.session);
+    const entryFees = BigInt((await connection.getTokenAccountBalance(vault)).value.amount);
+    const terms = (0, receipt_1.settlementTerms)({
+        entryFees,
+        protocolTaxBps: BigInt(config.protocolTaxBps.toString()),
+        guildFeeBps: BigInt(session.guildFeeBps.toString()),
+        royaltyBps: BigInt(session.hostRoyaltyBps.toString()),
+        draw,
+    });
+    const slot = await connection.getSlot();
+    const blockTime = (await connection.getBlockTime(slot)) ?? Math.floor(Date.now() / 1000);
+    const ranking = args.ranking ?? [];
+    const receipt = {
+        sessionId: Uint8Array.from(session.sessionId),
+        guild: session.guild, host: session.host,
+        entryFees, ...terms,
+        timestamp: BigInt(blockTime),
+        winner: ranking[0] ?? null, second: ranking[1] ?? null, third: ranking[2] ?? null,
+        logRoot: args.logRoot ?? null,
+    };
+    const hash = (0, receipt_1.receiptHash)(receipt);
+    const signature = await enclave.sign(hash);
+    const signatureIx = web3_js_1.Ed25519Program.createInstructionWithPublicKey({ publicKey: enclave.publicKey, message: hash, signature });
+    const argument = {
+        sessionId: Array.from(receipt.sessionId), guild: receipt.guild, host: receipt.host,
+        entryFees: new anchor_1.BN(receipt.entryFees.toString()), prizePool: new anchor_1.BN(receipt.prizePool.toString()),
+        guildFee: new anchor_1.BN(receipt.guildFee.toString()), hostRoyalty: new anchor_1.BN(receipt.hostRoyalty.toString()),
+        protocolTax: new anchor_1.BN(receipt.protocolTax.toString()), timestamp: new anchor_1.BN(receipt.timestamp.toString()),
+        second: receipt.second, third: receipt.third, winner: receipt.winner,
+        logRoot: receipt.logRoot ? Array.from(receipt.logRoot) : null,
+    };
+    const zgaMint = await (0, addresses_1.zgaMintOf)(connection, addr);
+    const creator = manifest.creator;
+    const gameManifest = addr.gameManifest(gameId);
+    const settleIx = await program.methods.settleSession(argument).accounts({
+        protocolRedeem: {
+            zgaPriceCache: addr.priceCache(0), solPriceCache: addr.priceCache(1),
+            solVault: addr.zgapSolVault, reserveSolAccount: addr.zgapReserveSol,
+        },
+        session: args.session, vault, yieldVault: addr.yieldVault, rewardDistributor: addr.rewardDistributor, protocolConfig: addr.config,
+        zgapAuthority: addr.zgapAuthority, zgapMint: addr.zgapMint, zgaMint, 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, gameCreatorAccount: addr.gameCreator(creator, gameId), royaltyVault: addr.royaltyVault(creator, gameId),
+        prizeVault: addr.prizeVault(args.session), guildAccount: session.guild,
+        tokenProgram: token_1.TOKEN_PROGRAM_ID, ixSysvar: web3_js_1.SYSVAR_INSTRUCTIONS_PUBKEY,
+    }).remainingAccounts([
+        { pubkey: gameManifest, isSigner: false, isWritable: false },
+        { pubkey: addr.rateLimit(session.guild), isSigner: false, isWritable: true },
+        { pubkey: addr.attestationCert(new web3_js_1.PublicKey(enclave.publicKey)), isSigner: false, isWritable: false },
+    ]).instruction();
+    const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+    const message = new web3_js_1.TransactionMessage({
+        payerKey: payer.publicKey, recentBlockhash: blockhash, instructions: [signatureIx, settleIx],
+    }).compileToV0Message([lookupTable]);
+    const tx = new web3_js_1.VersionedTransaction(message);
+    tx.sign([payer]);
+    const sent = await connection.sendTransaction(tx);
+    await connection.confirmTransaction({ signature: sent, blockhash, lastValidBlockHeight }, 'confirmed');
+    return sent;
+}

package/dist/sha256.d.ts

@@ -0,0 +1,3 @@
+export declare function sha256(...parts: Uint8Array[]): Uint8Array;
+export declare function toHex(bytes: Uint8Array): string;
+export declare function fromHex(hex: string): Uint8Array;

package/dist/sha256.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256 = sha256;
+exports.toHex = toHex;
+exports.fromHex = fromHex;
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+function sha256(...parts) {
+    const length = parts.reduce((n, p) => n + p.length, 0);
+    const padded = new Uint8Array(Math.ceil((length + 9) / 64) * 64);
+    let at = 0;
+    for (const p of parts) {
+        padded.set(p, at);
+        at += p.length;
+    }
+    padded[length] = 0x80;
+    const view = new DataView(padded.buffer);
+    view.setUint32(padded.length - 8, Math.floor(length / 536870912), false);
+    view.setUint32(padded.length - 4, (length << 3) >>> 0, false);
+    const h = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]);
+    const w = new Uint32Array(64);
+    for (let block = 0; block < padded.length; block += 64) {
+        for (let i = 0; i < 16; i++)
+            w[i] = view.getUint32(block + i * 4, false);
+        for (let i = 16; i < 64; i++) {
+            const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+            const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+            w[i] = (w[i - 16] + s0 + w[i - 7] + s1) >>> 0;
+        }
+        let [a, b, c, d, e, f, g, hh] = h;
+        for (let i = 0; i < 64; i++) {
+            const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+            const ch = (e & f) ^ (~e & g);
+            const t1 = (hh + S1 + ch + K[i] + w[i]) >>> 0;
+            const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+            const maj = (a & b) ^ (a & c) ^ (b & c);
+            const t2 = (S0 + maj) >>> 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        h[0] = (h[0] + a) >>> 0;
+        h[1] = (h[1] + b) >>> 0;
+        h[2] = (h[2] + c) >>> 0;
+        h[3] = (h[3] + d) >>> 0;
+        h[4] = (h[4] + e) >>> 0;
+        h[5] = (h[5] + f) >>> 0;
+        h[6] = (h[6] + g) >>> 0;
+        h[7] = (h[7] + hh) >>> 0;
+    }
+    const out = new Uint8Array(32);
+    const o = new DataView(out.buffer);
+    h.forEach((v, i) => o.setUint32(i * 4, v, false));
+    return out;
+}
+function toHex(bytes) {
+    let s = '';
+    for (const b of bytes)
+        s += b.toString(16).padStart(2, '0');
+    return s;
+}
+function fromHex(hex) {
+    if (hex.length % 2 !== 0 || /[^0-9a-fA-F]/.test(hex))
+        throw new Error('Malformed hex');
+    const out = new Uint8Array(hex.length / 2);
+    for (let i = 0; i < out.length; i++)
+        out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    return out;
+}