@zga/client 0.1.0 → 0.1.2

package/dist/billing.js

@@ -89,7 +89,7 @@ async function billSubscription(env, receipt, guildSignature, attestations) {
         zgapReserve: addr.zgapReserve,
         zgapReserveZgaAccount: (0, token_1.associatedTokenAddress)(zgaMint, addr.zgapReserve),
         lpLockTokenAccount: addr.lpLock,
-        guildTokenAccount: (0, token_1.associatedTokenAddress)(addr.zgapMint, guildAccount.operator),
+        guildTokenAccount: (0, token_1.associatedTokenAddress)(addr.zgapMint, guildAccount.authority),
         gameManifest: addr.gameManifest(gameId),
         gameCreatorAccount: addr.gameCreator(creator, gameId),
         royaltyVault: addr.royaltyVault(creator, gameId),

package/dist/explorer.js

@@ -26,16 +26,23 @@ async function read(url, max, opts) {
             throw new NetworkError(`refused: ${err.message}`);
         }
     }
+    const pinned = opts.guard?.fetch;
     let res;
     try {
-        res = await fetch(target, { redirect: 'error', signal: AbortSignal.timeout(opts.timeoutMs ?? 20000) });
+        res = pinned
+            ? await pinned(target, { signal: AbortSignal.timeout(opts.timeoutMs ?? 20000), maxBytes: max })
+            : 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');
+        if (pinned && /larger than the limit/.test(why))
+            throw new Error(`larger than ${max} bytes`);
         throw new NetworkError(why);
     }
+    if (pinned && res.status >= 300 && res.status < 400)
+        throw new Error('the host redirects');
     if (!res.ok)
         throw new Error(`HTTP ${res.status}`);
     if (Number(res.headers.get('content-length') ?? 0) > max)

package/dist/idl.js

@@ -5,8 +5,13 @@ 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,
 };
+// A Program built by Anchor carries its IDL with every name in camelCase (Session becomes session, game_id becomes gameId).
+// These helpers accept either spelling, so they work on that IDL and on the file as written.
+const camel = (s) => s.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase()).replace(/^[A-Z]/, (c) => c.toLowerCase());
+const plain = (s) => s.replace(/_/g, '').toLowerCase();
 function typeDef(idl, name) {
-    const def = (idl.types ?? []).find((t) => t.name === name);
+    const wanted = camel(name);
+    const def = (idl.types ?? []).find((t) => t.name === name || camel(t.name) === wanted);
     if (!def)
         throw new Error(`The IDL has no type ${name}`);
     return def;
@@ -37,7 +42,7 @@ function fieldOffset(idl, account, field) {
         throw new Error(`${account} is not a struct`);
     let offset = 8;
     for (const f of def.type.fields ?? []) {
-        if (f.name === field)
+        if (f.name === field || camel(f.name) === camel(field))
             return offset;
         offset += sizeOf(idl, f.type);
     }
@@ -45,7 +50,7 @@ function fieldOffset(idl, account, field) {
 }
 function variantIndex(idl, enumName, variant) {
     const def = typeDef(idl, enumName);
-    const index = (def.type.variants ?? []).findIndex((v) => v.name.toLowerCase() === variant.toLowerCase());
+    const index = (def.type.variants ?? []).findIndex((v) => plain(v.name) === plain(variant));
     if (index < 0)
         throw new Error(`${enumName} has no variant ${variant}`);
     return index;

package/dist/index.d.ts

@@ -29,3 +29,4 @@ export * from './billing';
 export * from './observer';
 export * from './explorer';
 export * from './shieldLimits';
+export * from './onion';

package/dist/index.js

@@ -45,3 +45,4 @@ __exportStar(require("./billing"), exports);
 __exportStar(require("./observer"), exports);
 __exportStar(require("./explorer"), exports);
 __exportStar(require("./shieldLimits"), exports);
+__exportStar(require("./onion"), exports);

package/dist/observer.d.ts

@@ -23,7 +23,10 @@ export declare function availabilityAcceptable(c: {
     samples: number;
     up: number;
 }, minCoverage?: number, minUp?: number): boolean;
-export type UrlGuard = (url: string) => Promise<URL>;
+export type PinnedFetch = (url: string, init?: any) => Promise<Response>;
+export type UrlGuard = ((url: string) => Promise<URL>) & {
+    fetch?: PinnedFetch;
+};
 export declare function probeGuild(base: string, guard?: UrlGuard): Promise<boolean>;
 export interface PendingReceipt {
     session: string;

package/dist/observer.js

@@ -114,6 +114,8 @@ function availabilityAcceptable(c, minCoverage = 0.9, minUp = 0.9) {
 }
 const anyUrl = async (url) => new URL(url);
 async function guarded(guard, url, init = {}) {
+    if (guard.fetch)
+        return guard.fetch(url, { signal: AbortSignal.timeout(20000), ...init });
     const target = await guard(url);
     return fetch(target, { redirect: 'manual', signal: AbortSignal.timeout(20000), ...init });
 }

package/dist/onion.d.ts

@@ -0,0 +1,42 @@
+export declare const ONION_PACKET_SIZE = 4096;
+export declare const ONION_MIN_HOPS = 3;
+export declare const ONION_MAX_HOPS = 5;
+export declare const ONION_VALID_MINUTES = 10;
+export declare const ONION_IDENTITY_TAG = "zga-nop-onion-key-v1";
+export declare const ONION_LAYER_OVERHEAD: number;
+export declare function onionMaxPayload(hops: number): number;
+export declare function buildOnionPacket(relayKeys: Uint8Array[], payload: Uint8Array, nowMin?: number): Promise<Uint8Array>;
+export interface OnionIdentity {
+    operator: string;
+    onion_pubkey: string;
+    signature: string;
+}
+export declare function onionIdentityMessage(onionPub: Uint8Array, operator: Uint8Array): Uint8Array;
+/** The relay's onion key, if the document is signed by the operator it names and that operator is the one expected. */
+export declare function verifyOnionIdentity(doc: OnionIdentity, expectedOperator: string): Uint8Array | null;
+export interface RelayCandidate {
+    operator: string;
+    endpoint: string;
+}
+export interface OnionRelay extends RelayCandidate {
+    onionKey: Uint8Array;
+}
+type Fetch = (url: string, init?: any) => Promise<{
+    ok: boolean;
+    status: number;
+    json(): Promise<any>;
+}>;
+/** Fetches each candidate's signed onion identity and keeps the ones that verify against the operator the caller took from the chain. */
+export declare function loadOnionRelays(candidates: RelayCandidate[], fetchFn?: Fetch, timeoutMs?: number): Promise<OnionRelay[]>;
+/** A random circuit of distinct relays run by distinct operators. */
+export declare function chooseCircuit(relays: OnionRelay[], hops?: number, random?: () => number): OnionRelay[];
+export interface OnionSendRequest {
+    recipient_view_pubkey: string;
+    payload_b64: string;
+}
+/** Wraps the request in a circuit and submits it to the first relay. The last relay delivers it as a /stealth/send request. */
+export declare function sendOnion(circuit: OnionRelay[], request: OnionSendRequest, fetchFn?: Fetch): Promise<{
+    firstRelay: string;
+    status: number;
+}>;
+export {};

package/dist/onion.js

@@ -0,0 +1,159 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ONION_LAYER_OVERHEAD = exports.ONION_IDENTITY_TAG = exports.ONION_VALID_MINUTES = exports.ONION_MAX_HOPS = exports.ONION_MIN_HOPS = exports.ONION_PACKET_SIZE = void 0;
+exports.onionMaxPayload = onionMaxPayload;
+exports.buildOnionPacket = buildOnionPacket;
+exports.onionIdentityMessage = onionIdentityMessage;
+exports.verifyOnionIdentity = verifyOnionIdentity;
+exports.loadOnionRelays = loadOnionRelays;
+exports.chooseCircuit = chooseCircuit;
+exports.sendOnion = sendOnion;
+const core_1 = require("@hpke/core");
+const dhkem_x25519_1 = require("@hpke/dhkem-x25519");
+const chacha20poly1305_1 = require("@hpke/chacha20poly1305");
+const web3_js_1 = require("@solana/web3.js");
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+exports.ONION_PACKET_SIZE = 4096;
+exports.ONION_MIN_HOPS = 3;
+exports.ONION_MAX_HOPS = 5;
+exports.ONION_VALID_MINUTES = 10;
+exports.ONION_IDENTITY_TAG = 'zga-nop-onion-key-v1';
+const ENC_LEN = 32;
+const TAG_LEN = 16;
+const HEADER_LEN = 1 + 4 + 32 + 2;
+exports.ONION_LAYER_OVERHEAD = ENC_LEN + TAG_LEN + HEADER_LEN;
+const FORWARD = 0;
+const DELIVER = 1;
+const INFO = new TextEncoder().encode('zga-context');
+const suite = new core_1.CipherSuite({ kem: new dhkem_x25519_1.DhkemX25519HkdfSha256(), kdf: new core_1.HkdfSha256(), aead: new chacha20poly1305_1.Chacha20Poly1305() });
+const toBuffer = (u8) => u8.buffer.slice(u8.byteOffset, u8.byteOffset + u8.byteLength);
+const nowMinutes = () => Math.floor(Date.now() / 60000);
+const isZero = (k) => k.every((b) => b === 0);
+const same = (a, b) => a.length === b.length && a.every((x, i) => x === b[i]);
+function onionMaxPayload(hops) {
+    return Math.max(0, exports.ONION_PACKET_SIZE - exports.ONION_LAYER_OVERHEAD * hops - 2);
+}
+async function buildOnionPacket(relayKeys, payload, nowMin = nowMinutes()) {
+    const n = relayKeys.length;
+    if (n < exports.ONION_MIN_HOPS)
+        throw new Error(`An onion circuit needs at least ${exports.ONION_MIN_HOPS} relays`);
+    if (n > exports.ONION_MAX_HOPS)
+        throw new Error(`An onion circuit takes at most ${exports.ONION_MAX_HOPS} relays`);
+    relayKeys.forEach((key, i) => {
+        if (key.length !== 32)
+            throw new Error('A relay key must be 32 bytes');
+        if (isZero(key))
+            throw new Error('A relay key must not be all zeros');
+        if (relayKeys.slice(0, i).some((other) => same(other, key)))
+            throw new Error('Every relay in a circuit must be distinct');
+    });
+    if (payload.length > onionMaxPayload(n)) {
+        throw new Error(`The payload is ${payload.length} bytes and a ${n}-relay circuit carries at most ${onionMaxPayload(n)}`);
+    }
+    let current = new Uint8Array(exports.ONION_PACKET_SIZE - exports.ONION_LAYER_OVERHEAD * n);
+    globalThis.crypto.getRandomValues(current);
+    new DataView(current.buffer).setUint16(0, payload.length);
+    current.set(payload, 2);
+    const validUntil = nowMin + exports.ONION_VALID_MINUTES;
+    for (let i = n - 1; i >= 0; i--) {
+        const last = i === n - 1;
+        const plain = new Uint8Array(HEADER_LEN + current.length);
+        const view = new DataView(plain.buffer);
+        plain[0] = last ? DELIVER : FORWARD;
+        view.setUint32(1, validUntil);
+        if (!last)
+            plain.set(relayKeys[i + 1], 5);
+        view.setUint16(37, current.length);
+        plain.set(current, HEADER_LEN);
+        const recipientPublicKey = await suite.kem.deserializePublicKey(toBuffer(relayKeys[i]));
+        const sender = await suite.createSenderContext({ recipientPublicKey, info: toBuffer(INFO) });
+        const ciphertext = new Uint8Array(await sender.seal(toBuffer(plain)));
+        const enc = new Uint8Array(sender.enc);
+        if (enc.length !== ENC_LEN)
+            throw new Error('Unexpected encapsulated key length');
+        const layer = new Uint8Array(enc.length + ciphertext.length);
+        layer.set(enc, 0);
+        layer.set(ciphertext, enc.length);
+        current = layer;
+    }
+    if (current.length !== exports.ONION_PACKET_SIZE)
+        throw new Error('The onion packet has the wrong size');
+    return current;
+}
+const hexBytes = (hex, length) => {
+    if (typeof hex !== 'string' || !/^[0-9a-fA-F]+$/.test(hex) || hex.length !== length * 2)
+        return null;
+    return Uint8Array.from(Buffer.from(hex, 'hex'));
+};
+function onionIdentityMessage(onionPub, operator) {
+    const tag = new TextEncoder().encode(exports.ONION_IDENTITY_TAG);
+    const message = new Uint8Array(tag.length + onionPub.length + operator.length);
+    message.set(tag, 0);
+    message.set(onionPub, tag.length);
+    message.set(operator, tag.length + onionPub.length);
+    return message;
+}
+/** The relay's onion key, if the document is signed by the operator it names and that operator is the one expected. */
+function verifyOnionIdentity(doc, expectedOperator) {
+    try {
+        if (!doc || doc.operator !== expectedOperator)
+            return null;
+        const operator = new web3_js_1.PublicKey(doc.operator).toBytes();
+        const onionPub = hexBytes(doc.onion_pubkey, 32);
+        const signature = hexBytes(doc.signature, 64);
+        if (!onionPub || !signature || isZero(onionPub))
+            return null;
+        return tweetnacl_1.default.sign.detached.verify(onionIdentityMessage(onionPub, operator), signature, operator) ? onionPub : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Fetches each candidate's signed onion identity and keeps the ones that verify against the operator the caller took from the chain. */
+async function loadOnionRelays(candidates, fetchFn = fetch, timeoutMs = 4000) {
+    const found = await Promise.all(candidates.map(async (c) => {
+        try {
+            const res = await fetchFn(`${c.endpoint.replace(/\/+$/, '')}/onion/identity`, { signal: AbortSignal.timeout(timeoutMs), redirect: 'error' });
+            if (!res.ok)
+                return null;
+            const key = verifyOnionIdentity(await res.json(), c.operator);
+            return key ? { ...c, onionKey: key } : null;
+        }
+        catch {
+            return null;
+        }
+    }));
+    return found.filter((r) => r !== null);
+}
+/** A random circuit of distinct relays run by distinct operators. */
+function chooseCircuit(relays, hops = exports.ONION_MIN_HOPS, random = Math.random) {
+    if (hops < exports.ONION_MIN_HOPS || hops > exports.ONION_MAX_HOPS)
+        throw new Error(`A circuit has ${exports.ONION_MIN_HOPS} to ${exports.ONION_MAX_HOPS} relays`);
+    const pool = relays.filter((r, i) => relays.findIndex((o) => o.operator === r.operator) === i);
+    if (pool.length < hops)
+        throw new Error(`${pool.length} relays with verified keys are known and a circuit needs ${hops}`);
+    for (let i = pool.length - 1; i > 0; i--) {
+        const j = Math.floor(random() * (i + 1));
+        [pool[i], pool[j]] = [pool[j], pool[i]];
+    }
+    return pool.slice(0, hops);
+}
+/** Wraps the request in a circuit and submits it to the first relay. The last relay delivers it as a /stealth/send request. */
+async function sendOnion(circuit, request, fetchFn = fetch) {
+    if (!hexBytes(request.recipient_view_pubkey, 32))
+        throw new Error('recipient_view_pubkey must be 32 bytes of hex');
+    const payload = new TextEncoder().encode(JSON.stringify(request));
+    const packet = await buildOnionPacket(circuit.map((r) => r.onionKey), payload);
+    const res = await fetchFn(`${circuit[0].endpoint.replace(/\/+$/, '')}/onion/relay`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/octet-stream' },
+        body: packet,
+        redirect: 'error',
+    });
+    if (!res.ok)
+        throw new Error(`The first relay answered ${res.status}`);
+    return { firstRelay: circuit[0].operator, status: res.status };
+}

package/dist/settlement.js

@@ -75,7 +75,7 @@ async function settleSession(env, args) {
         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),
+        lpLockTokenAccount: addr.lpLock, guildTokenAccount: (0, token_1.associatedTokenAddress)(addr.zgapMint, guildAccount.authority),
         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,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zga/client",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "files": ["dist"],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -10,6 +10,9 @@
     "test": "node --test test/*.test.mjs"
   },
   "dependencies": {
+    "@hpke/chacha20poly1305": "1.8.0",
+    "@hpke/core": "1.9.0",
+    "@hpke/dhkem-x25519": "1.8.0",
     "@zga/shielded-sdk": "*",
     "tweetnacl": "^1.0.3"
   },