@infantmen-labs/harbor-sdk 0.3.0

package/dist/src/accounts.d.ts

@@ -0,0 +1,33 @@
+import { PublicKey } from "@solana/web3.js";
+/**
+ * Zero-dependency account decoders (Uint8Array in, typed structs out).
+ * Layouts must match programs/harbor/src/state.rs exactly; the LiteSVM
+ * suites and web coder test pin both sides.
+ */
+export interface Bond {
+    merchant: PublicKey;
+    mint: PublicKey;
+    amount: bigint;
+    slaBps: number;
+    challengeSlots: bigint;
+    openDisputes: bigint;
+    lastChangeSlot: bigint;
+    reserved: bigint;
+}
+export interface Dispute {
+    binding: PublicKey;
+    nonce: bigint;
+    reason: number;
+    claimant: PublicKey;
+    deadlineSlot: bigint;
+    stakeLamports: bigint;
+    claimSpend: bigint;
+}
+/** MerchantBond layout: disc(8) + merchant(32) + mint(32) + amount(8) +
+ * slaBps(2) + challengeSlots(8) + openDisputes(8) + lastChangeSlot(8) +
+ * reserved(8) + bump(1). */
+export declare function decodeBond(data: Uint8Array): Bond;
+/** Dispute layout: disc(8) + binding(32) + nonce(8) + reason(1) +
+ * claimant(32) + deadlineSlot(8) + stakeLamports(8) + claimSpend(8) +
+ * bump(1). */
+export declare function decodeDispute(data: Uint8Array): Dispute;

package/dist/src/accounts.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeBond = decodeBond;
+exports.decodeDispute = decodeDispute;
+const web3_js_1 = require("@solana/web3.js");
+function u64(d, o) {
+    return (BigInt(d[o]) |
+        (BigInt(d[o + 1]) << 8n) |
+        (BigInt(d[o + 2]) << 16n) |
+        (BigInt(d[o + 3]) << 24n) |
+        (BigInt(d[o + 4]) << 32n) |
+        (BigInt(d[o + 5]) << 40n) |
+        (BigInt(d[o + 6]) << 48n) |
+        (BigInt(d[o + 7]) << 56n));
+}
+function u16(d, o) {
+    return d[o] | (d[o + 1] << 8);
+}
+function pk(d, o) {
+    return new web3_js_1.PublicKey(d.slice(o, o + 32));
+}
+/** MerchantBond layout: disc(8) + merchant(32) + mint(32) + amount(8) +
+ * slaBps(2) + challengeSlots(8) + openDisputes(8) + lastChangeSlot(8) +
+ * reserved(8) + bump(1). */
+function decodeBond(data) {
+    return {
+        merchant: pk(data, 8),
+        mint: pk(data, 40),
+        amount: u64(data, 72),
+        slaBps: u16(data, 80),
+        challengeSlots: u64(data, 82),
+        openDisputes: u64(data, 90),
+        lastChangeSlot: u64(data, 98),
+        reserved: u64(data, 106),
+    };
+}
+/** Dispute layout: disc(8) + binding(32) + nonce(8) + reason(1) +
+ * claimant(32) + deadlineSlot(8) + stakeLamports(8) + claimSpend(8) +
+ * bump(1). */
+function decodeDispute(data) {
+    return {
+        binding: pk(data, 8),
+        nonce: u64(data, 40),
+        reason: data[48],
+        claimant: pk(data, 49),
+        deadlineSlot: u64(data, 81),
+        stakeLamports: u64(data, 89),
+        claimSpend: u64(data, 97),
+    };
+}

package/dist/src/ed25519.d.ts

@@ -0,0 +1,10 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+/**
+ * Canonical single-signature Ed25519 precompile ix. Offsets point into this
+ * ix's own data (indices u16::MAX). Layout: header(16) | pubkey(32) |
+ * signature(64) | message(n).
+ */
+export declare function buildEd25519Ix(pubkey: PublicKey, signature: Uint8Array, message: Uint8Array): TransactionInstruction;
+/** Upstream channel voucher payload: magic || channel || cumulative || expires. */
+export declare function channelVoucherBytes(channel: PublicKey, cumulative: bigint, expiresAt: bigint): Buffer;
+export declare const VOUCHER_LEN = 50;

package/dist/src/ed25519.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VOUCHER_LEN = void 0;
+exports.buildEd25519Ix = buildEd25519Ix;
+exports.channelVoucherBytes = channelVoucherBytes;
+const web3_js_1 = require("@solana/web3.js");
+const ids_1 = require("./ids");
+/**
+ * Canonical single-signature Ed25519 precompile ix. Offsets point into this
+ * ix's own data (indices u16::MAX). Layout: header(16) | pubkey(32) |
+ * signature(64) | message(n).
+ */
+function buildEd25519Ix(pubkey, signature, message) {
+    if (signature.length !== 64)
+        throw new Error("signature must be 64 bytes");
+    const header = Buffer.alloc(16);
+    header.writeUInt8(1, 0);
+    header.writeUInt8(0, 1);
+    header.writeUInt16LE(48, 2);
+    header.writeUInt16LE(0xffff, 4);
+    header.writeUInt16LE(16, 6);
+    header.writeUInt16LE(0xffff, 8);
+    header.writeUInt16LE(112, 10);
+    header.writeUInt16LE(message.length, 12);
+    header.writeUInt16LE(0xffff, 14);
+    return new web3_js_1.TransactionInstruction({
+        programId: ids_1.ED25519_PROGRAM_ID,
+        keys: [],
+        data: Buffer.concat([
+            header,
+            pubkey.toBuffer(),
+            Buffer.from(signature),
+            Buffer.from(message),
+        ]),
+    });
+}
+/** Upstream channel voucher payload: magic || channel || cumulative || expires. */
+function channelVoucherBytes(channel, cumulative, expiresAt) {
+    const out = Buffer.alloc(50);
+    out.writeUInt8(0x56, 0);
+    out.writeUInt8(0x01, 1);
+    channel.toBuffer().copy(out, 2);
+    out.writeBigUInt64LE(cumulative, 34);
+    out.writeBigInt64LE(expiresAt, 42);
+    return out;
+}
+exports.VOUCHER_LEN = 50;

package/dist/src/harbor-ix.d.ts

@@ -0,0 +1,20 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+export declare function registerMerchantIx(programId: PublicKey, merchant: PublicKey, bond: PublicKey, mint: PublicKey, slaBps: number, challengeSlots: bigint): TransactionInstruction;
+export declare function postBondIx(programId: PublicKey, merchant: PublicKey, bond: PublicKey, mint: PublicKey, merchantAta: PublicKey, vault: PublicKey, amount: bigint): TransactionInstruction;
+export declare function topUpBondIx(programId: PublicKey, merchant: PublicKey, bond: PublicKey, mint: PublicKey, merchantAta: PublicKey, vault: PublicKey, amount: bigint): TransactionInstruction;
+export declare function withdrawBondIx(programId: PublicKey, merchant: PublicKey, bond: PublicKey, mint: PublicKey, merchantAta: PublicKey, vault: PublicKey, amount: bigint): TransactionInstruction;
+export declare function withdrawTreasuryIx(programId: PublicKey, authority: PublicKey, programdata: PublicKey, treasury: PublicKey, treasuryAta: PublicKey, destinationAta: PublicKey, mint: PublicKey, amount: bigint): TransactionInstruction;
+export declare function bindChannelIx(programId: PublicKey, merchant: PublicKey, bond: PublicKey, binding: PublicKey, channel: PublicKey, channelProgram: PublicKey, maxSpend: bigint): TransactionInstruction;
+export interface SubmitReceiptArgs {
+    cumulativeSpend: bigint;
+    meterHash: Uint8Array;
+    outputHash: Uint8Array;
+    status: number;
+    nonce: bigint;
+    expirySlot: bigint;
+    signer: PublicKey;
+}
+export declare function submitReceiptIx(programId: PublicKey, merchant: PublicKey, bond: PublicKey, binding: PublicKey, receipt: PublicKey, args: SubmitReceiptArgs): TransactionInstruction;
+export declare function openDisputeIx(programId: PublicKey, claimant: PublicKey, bond: PublicKey, binding: PublicKey, channel: PublicKey, dispute: PublicKey, mint: PublicKey, claimantAta: PublicKey, vault: PublicKey, nonce: bigint, reason: number, claimSpend: bigint): TransactionInstruction;
+export declare function haltBindingIx(programId: PublicKey, merchant: PublicKey, binding: PublicKey): TransactionInstruction;
+export declare function resolveTimeoutIx(programId: PublicKey, resolver: PublicKey, bond: PublicKey, mint: PublicKey, binding: PublicKey, dispute: PublicKey, claimant: PublicKey, treasury: PublicKey, vault: PublicKey, treasuryAta: PublicKey, claimantAta: PublicKey, nonce: bigint): TransactionInstruction;

package/dist/src/harbor-ix.js

@@ -0,0 +1,176 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerMerchantIx = registerMerchantIx;
+exports.postBondIx = postBondIx;
+exports.topUpBondIx = topUpBondIx;
+exports.withdrawBondIx = withdrawBondIx;
+exports.withdrawTreasuryIx = withdrawTreasuryIx;
+exports.bindChannelIx = bindChannelIx;
+exports.submitReceiptIx = submitReceiptIx;
+exports.openDisputeIx = openDisputeIx;
+exports.haltBindingIx = haltBindingIx;
+exports.resolveTimeoutIx = resolveTimeoutIx;
+const web3_js_1 = require("@solana/web3.js");
+const ids_1 = require("./ids");
+const D = {
+    registerMerchant: [238, 245, 77, 132, 161, 88, 216, 248],
+    postBond: [168, 151, 202, 119, 163, 58, 147, 247],
+    topUpBond: [110, 37, 8, 119, 210, 231, 202, 197],
+    withdrawBond: [222, 199, 141, 31, 188, 93, 155, 40],
+    bindChannel: [56, 13, 116, 192, 54, 234, 8, 201],
+    haltBinding: [253, 79, 175, 71, 63, 49, 108, 135],
+    submitReceipt: [172, 84, 119, 35, 195, 154, 214, 176],
+    openDispute: [137, 25, 99, 119, 23, 223, 161, 42],
+    resolveTimeout: [149, 55, 89, 144, 121, 143, 48, 210],
+    refundUnused: [239, 108, 1, 110, 2, 81, 44, 174],
+    withdrawTreasury: [40, 63, 122, 158, 144, 216, 83, 96],
+};
+function u8(v) {
+    const b = Buffer.alloc(1);
+    b.writeUInt8(v);
+    return b;
+}
+function u16(v) {
+    const b = Buffer.alloc(2);
+    b.writeUInt16LE(v);
+    return b;
+}
+function u64(v) {
+    const b = Buffer.alloc(8);
+    b.writeBigUInt64LE(v);
+    return b;
+}
+function pk(k) {
+    return k.toBuffer();
+}
+function bytes32(b) {
+    if (b.length !== 32)
+        throw new Error("expected 32 bytes");
+    return Buffer.from(b);
+}
+function keys(programId, disc, data, metas) {
+    return new web3_js_1.TransactionInstruction({
+        programId,
+        keys: metas.map((m) => ({
+            pubkey: m.key,
+            isWritable: m.w ?? false,
+            isSigner: m.s ?? false,
+        })),
+        data: Buffer.concat([Buffer.from(disc), data]),
+    });
+}
+function registerMerchantIx(programId, merchant, bond, mint, slaBps, challengeSlots) {
+    return keys(programId, D.registerMerchant, Buffer.concat([u16(slaBps), u64(challengeSlots)]), [
+        { key: merchant, w: true, s: true },
+        { key: bond, w: true },
+        { key: mint },
+        { key: ids_1.SYSTEM_PROGRAM_ID },
+    ]);
+}
+function postBondIx(programId, merchant, bond, mint, merchantAta, vault, amount) {
+    return keys(programId, D.postBond, u64(amount), [
+        { key: merchant, w: true, s: true },
+        { key: bond, w: true },
+        { key: mint },
+        { key: merchantAta, w: true },
+        { key: vault, w: true },
+        { key: ids_1.TOKEN_PROGRAM_ID },
+        { key: ids_1.ATA_PROGRAM_ID },
+        { key: ids_1.SYSTEM_PROGRAM_ID },
+    ]);
+}
+function topUpBondIx(programId, merchant, bond, mint, merchantAta, vault, amount) {
+    return keys(programId, D.topUpBond, u64(amount), [
+        { key: merchant, w: true, s: true },
+        { key: bond, w: true },
+        { key: mint },
+        { key: merchantAta, w: true },
+        { key: vault, w: true },
+        { key: ids_1.TOKEN_PROGRAM_ID },
+    ]);
+}
+function withdrawBondIx(programId, merchant, bond, mint, merchantAta, vault, amount) {
+    return keys(programId, D.withdrawBond, u64(amount), [
+        { key: merchant, w: true, s: true },
+        { key: bond, w: true },
+        { key: mint },
+        { key: merchantAta, w: true },
+        { key: vault, w: true },
+        { key: ids_1.TOKEN_PROGRAM_ID },
+    ]);
+}
+function withdrawTreasuryIx(programId, authority, programdata, treasury, treasuryAta, destinationAta, mint, amount) {
+    return keys(programId, D.withdrawTreasury, u64(amount), [
+        { key: authority, s: true },
+        { key: programdata },
+        { key: treasury },
+        { key: treasuryAta, w: true },
+        { key: destinationAta, w: true },
+        { key: mint },
+        { key: ids_1.TOKEN_PROGRAM_ID },
+    ]);
+}
+function bindChannelIx(programId, merchant, bond, binding, channel, channelProgram, maxSpend) {
+    return keys(programId, D.bindChannel, Buffer.concat([pk(channelProgram), u64(maxSpend)]), [
+        { key: merchant, w: true, s: true },
+        { key: bond },
+        { key: binding, w: true },
+        { key: channel },
+        { key: ids_1.SYSTEM_PROGRAM_ID },
+    ]);
+}
+function submitReceiptIx(programId, merchant, bond, binding, receipt, args) {
+    return keys(programId, D.submitReceipt, Buffer.concat([
+        u64(args.cumulativeSpend),
+        bytes32(args.meterHash),
+        bytes32(args.outputHash),
+        u8(args.status),
+        u64(args.nonce),
+        u64(args.expirySlot),
+        pk(args.signer),
+    ]), [
+        { key: merchant, w: true, s: true },
+        { key: bond },
+        { key: binding, w: true },
+        { key: receipt, w: true },
+        { key: ids_1.IX_SYSVAR_ID },
+        { key: ids_1.SYSTEM_PROGRAM_ID },
+    ]);
+}
+function openDisputeIx(programId, claimant, bond, binding, channel, dispute, mint, claimantAta, vault, nonce, reason, claimSpend) {
+    return keys(programId, D.openDispute, Buffer.concat([u64(nonce), u8(reason), u64(claimSpend)]), [
+        { key: claimant, w: true, s: true },
+        { key: bond, w: true },
+        { key: binding },
+        { key: channel },
+        { key: dispute, w: true },
+        { key: mint },
+        { key: claimantAta, w: true },
+        { key: vault, w: true },
+        { key: ids_1.TOKEN_PROGRAM_ID },
+        { key: ids_1.SYSTEM_PROGRAM_ID },
+    ]);
+}
+function haltBindingIx(programId, merchant, binding) {
+    return keys(programId, D.haltBinding, Buffer.alloc(0), [
+        { key: merchant, w: true, s: true },
+        { key: binding, w: true },
+    ]);
+}
+function resolveTimeoutIx(programId, resolver, bond, mint, binding, dispute, claimant, treasury, vault, treasuryAta, claimantAta, nonce) {
+    return keys(programId, D.resolveTimeout, u64(nonce), [
+        { key: resolver, w: true, s: true },
+        { key: bond, w: true },
+        { key: mint },
+        { key: binding },
+        { key: dispute, w: true },
+        { key: claimant, w: true },
+        { key: treasury },
+        { key: vault, w: true },
+        { key: treasuryAta, w: true },
+        { key: claimantAta, w: true },
+        { key: ids_1.ATA_PROGRAM_ID },
+        { key: ids_1.TOKEN_PROGRAM_ID },
+        { key: ids_1.SYSTEM_PROGRAM_ID },
+    ]);
+}

package/dist/src/ids.d.ts

@@ -0,0 +1,9 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const HARBOR_PROGRAM_ID: PublicKey;
+export declare const CHANNEL_PROGRAM_ID: PublicKey;
+export declare const ED25519_PROGRAM_ID: PublicKey;
+export declare const IX_SYSVAR_ID: PublicKey;
+export declare const SYSTEM_PROGRAM_ID: PublicKey;
+export declare const TOKEN_PROGRAM_ID: PublicKey;
+export declare const ATA_PROGRAM_ID: PublicKey;
+export declare const RENT_SYSVAR_ID: PublicKey;

package/dist/src/ids.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RENT_SYSVAR_ID = exports.ATA_PROGRAM_ID = exports.TOKEN_PROGRAM_ID = exports.SYSTEM_PROGRAM_ID = exports.IX_SYSVAR_ID = exports.ED25519_PROGRAM_ID = exports.CHANNEL_PROGRAM_ID = exports.HARBOR_PROGRAM_ID = void 0;
+const web3_js_1 = require("@solana/web3.js");
+exports.HARBOR_PROGRAM_ID = new web3_js_1.PublicKey("BuRyKLqCsTLcyLVFEjxTjmF4DryCT3LmVDjwqhduvB4H");
+exports.CHANNEL_PROGRAM_ID = new web3_js_1.PublicKey("CHNLxYvVA28MJP9PrFuDXccuoGXAx7jBacfLEkahyGsX");
+exports.ED25519_PROGRAM_ID = new web3_js_1.PublicKey("Ed25519SigVerify111111111111111111111111111");
+exports.IX_SYSVAR_ID = new web3_js_1.PublicKey("Sysvar1nstructions1111111111111111111111111");
+exports.SYSTEM_PROGRAM_ID = new web3_js_1.PublicKey("11111111111111111111111111111111");
+exports.TOKEN_PROGRAM_ID = new web3_js_1.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+exports.ATA_PROGRAM_ID = new web3_js_1.PublicKey("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+exports.RENT_SYSVAR_ID = new web3_js_1.PublicKey("SysvarRent111111111111111111111111111111111");

package/dist/src/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./ids";
+export * from "./pda";
+export * from "./accounts";
+export * from "./receipt";
+export * from "./ed25519";
+export * from "./verify";
+export * from "./harbor-ix";

package/dist/src/index.js

@@ -0,0 +1,23 @@
+"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("./ids"), exports);
+__exportStar(require("./pda"), exports);
+__exportStar(require("./accounts"), exports);
+__exportStar(require("./receipt"), exports);
+__exportStar(require("./ed25519"), exports);
+__exportStar(require("./verify"), exports);
+__exportStar(require("./harbor-ix"), exports);

package/dist/src/jsonl.d.ts

@@ -0,0 +1,5 @@
+export declare class JsonlLogger {
+    private readonly path;
+    constructor(path: string);
+    log(record: Record<string, unknown>): void;
+}

package/dist/src/jsonl.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonlLogger = void 0;
+const node_fs_1 = require("node:fs");
+class JsonlLogger {
+    path;
+    constructor(path) {
+        this.path = path;
+    }
+    log(record) {
+        (0, node_fs_1.appendFileSync)(this.path, JSON.stringify(record) + "\n");
+    }
+}
+exports.JsonlLogger = JsonlLogger;

package/dist/src/pda.d.ts

@@ -0,0 +1,8 @@
+import { PublicKey } from "@solana/web3.js";
+export declare function bondPda(merchant: PublicKey, mint: PublicKey): [PublicKey, number];
+export declare function bindingPda(channel: PublicKey): [PublicKey, number];
+export declare function receiptPda(binding: PublicKey, nonce: bigint): [PublicKey, number];
+export declare function disputePda(binding: PublicKey, nonce: bigint): [PublicKey, number];
+export declare function treasuryPda(mint: PublicKey): [PublicKey, number];
+export declare function channelPda(channelProgram: PublicKey, payer: PublicKey, payee: PublicKey, mint: PublicKey, authorizedSigner: PublicKey, salt: bigint, openSlot: bigint): [PublicKey, number];
+export declare function channelAta(channel: PublicKey, tokenProgram: PublicKey, mint: PublicKey, ataProgram: PublicKey): [PublicKey, number];

package/dist/src/pda.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bondPda = bondPda;
+exports.bindingPda = bindingPda;
+exports.receiptPda = receiptPda;
+exports.disputePda = disputePda;
+exports.treasuryPda = treasuryPda;
+exports.channelPda = channelPda;
+exports.channelAta = channelAta;
+const web3_js_1 = require("@solana/web3.js");
+const ids_1 = require("./ids");
+function bondPda(merchant, mint) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("bond"), merchant.toBuffer(), mint.toBuffer()], ids_1.HARBOR_PROGRAM_ID);
+}
+function bindingPda(channel) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("binding"), channel.toBuffer()], ids_1.HARBOR_PROGRAM_ID);
+}
+function receiptPda(binding, nonce) {
+    const nonceBuf = Buffer.alloc(8);
+    nonceBuf.writeBigUInt64LE(nonce);
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("receipt"), binding.toBuffer(), nonceBuf], ids_1.HARBOR_PROGRAM_ID);
+}
+function disputePda(binding, nonce) {
+    const nonceBuf = Buffer.alloc(8);
+    nonceBuf.writeBigUInt64LE(nonce);
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("dispute"), binding.toBuffer(), nonceBuf], ids_1.HARBOR_PROGRAM_ID);
+}
+function treasuryPda(mint) {
+    return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("treasury"), mint.toBuffer()], ids_1.HARBOR_PROGRAM_ID);
+}
+function channelPda(channelProgram, payer, payee, mint, authorizedSigner, salt, openSlot) {
+    const saltBuf = Buffer.alloc(8);
+    saltBuf.writeBigUInt64LE(salt);
+    const slotBuf = Buffer.alloc(8);
+    slotBuf.writeBigUInt64LE(openSlot);
+    return web3_js_1.PublicKey.findProgramAddressSync([
+        Buffer.from("channel"),
+        payer.toBuffer(),
+        payee.toBuffer(),
+        mint.toBuffer(),
+        authorizedSigner.toBuffer(),
+        saltBuf,
+        slotBuf,
+    ], channelProgram);
+}
+function channelAta(channel, tokenProgram, mint, ataProgram) {
+    return web3_js_1.PublicKey.findProgramAddressSync([channel.toBuffer(), tokenProgram.toBuffer(), mint.toBuffer()], ataProgram);
+}

package/dist/src/receipt.d.ts

@@ -0,0 +1,15 @@
+import { PublicKey } from "@solana/web3.js";
+export interface ReceiptFields {
+    merchant: PublicKey;
+    binding: PublicKey;
+    cumulativeSpend: bigint;
+    meterHash: Uint8Array;
+    outputHash: Uint8Array;
+    status: number;
+    nonce: bigint;
+    expirySlot: bigint;
+    signer: PublicKey;
+}
+/** Borsh encoding of the onchain ReceiptMessage. Field order is consensus. */
+export declare function receiptMessageBytes(f: ReceiptFields): Buffer;
+export declare const RECEIPT_MESSAGE_LEN = 185;

package/dist/src/receipt.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RECEIPT_MESSAGE_LEN = void 0;
+exports.receiptMessageBytes = receiptMessageBytes;
+function assertLen(b, n, name) {
+    if (b.length !== n)
+        throw new Error(`${name} must be ${n} bytes`);
+}
+/** Borsh encoding of the onchain ReceiptMessage. Field order is consensus. */
+function receiptMessageBytes(f) {
+    assertLen(f.meterHash, 32, "meterHash");
+    assertLen(f.outputHash, 32, "outputHash");
+    const out = Buffer.alloc(185);
+    let o = 0;
+    f.merchant.toBuffer().copy(out, o);
+    o += 32;
+    f.binding.toBuffer().copy(out, o);
+    o += 32;
+    out.writeBigUInt64LE(f.cumulativeSpend, o);
+    o += 8;
+    Buffer.from(f.meterHash).copy(out, o);
+    o += 32;
+    Buffer.from(f.outputHash).copy(out, o);
+    o += 32;
+    out.writeUInt8(f.status, o);
+    o += 1;
+    out.writeBigUInt64LE(f.nonce, o);
+    o += 8;
+    out.writeBigUInt64LE(f.expirySlot, o);
+    o += 8;
+    f.signer.toBuffer().copy(out, o);
+    o += 32;
+    return out;
+}
+exports.RECEIPT_MESSAGE_LEN = 185;

package/dist/src/verify.d.ts

@@ -0,0 +1,3 @@
+import { PublicKey } from "@solana/web3.js";
+export declare function verifyEd25519(pubkey: PublicKey, message: Uint8Array, signature: Uint8Array): boolean;
+export declare function signEd25519(secretKey: Uint8Array, message: Uint8Array): Uint8Array;

package/dist/src/verify.js

@@ -0,0 +1,16 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyEd25519 = verifyEd25519;
+exports.signEd25519 = signEd25519;
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+function verifyEd25519(pubkey, message, signature) {
+    if (signature.length !== 64)
+        return false;
+    return tweetnacl_1.default.sign.detached.verify(message, signature, pubkey.toBytes());
+}
+function signEd25519(secretKey, message) {
+    return tweetnacl_1.default.sign.detached(message, secretKey);
+}

package/dist/test/vectors.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test/vectors.test.js

@@ -0,0 +1,143 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_test_1 = require("node:test");
+const strict_1 = __importDefault(require("node:assert/strict"));
+const web3_js_1 = require("@solana/web3.js");
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const index_1 = require("../src/index");
+const P = (n) => new web3_js_1.PublicKey(Buffer.alloc(32, n));
+(0, node_test_1.describe)("receipt layout", () => {
+    (0, node_test_1.it)("encodes fields in consensus order with exact length", () => {
+        const f = {
+            merchant: P(1),
+            binding: P(2),
+            cumulativeSpend: 10000n,
+            meterHash: new Uint8Array(32).fill(3),
+            outputHash: new Uint8Array(32).fill(4),
+            status: 0,
+            nonce: 7n,
+            expirySlot: 999n,
+            signer: P(1),
+        };
+        const got = (0, index_1.receiptMessageBytes)(f);
+        strict_1.default.equal(got.length, index_1.RECEIPT_MESSAGE_LEN);
+        // Independently rebuild the expectation part by part.
+        const exp = Buffer.concat([
+            Buffer.alloc(32, 1),
+            Buffer.alloc(32, 2),
+            (() => {
+                const b = Buffer.alloc(8);
+                b.writeBigUInt64LE(10000n);
+                return b;
+            })(),
+            Buffer.alloc(32, 3),
+            Buffer.alloc(32, 4),
+            Buffer.from([0]),
+            (() => {
+                const b = Buffer.alloc(8);
+                b.writeBigUInt64LE(7n);
+                return b;
+            })(),
+            (() => {
+                const b = Buffer.alloc(8);
+                b.writeBigUInt64LE(999n);
+                return b;
+            })(),
+            Buffer.alloc(32, 1),
+        ]);
+        strict_1.default.ok(got.equals(exp));
+    });
+    (0, node_test_1.it)("round-trips through tweetnacl sign/verify", () => {
+        const kp = tweetnacl_1.default.sign.keyPair();
+        const msg = (0, index_1.receiptMessageBytes)({
+            merchant: new web3_js_1.PublicKey(kp.publicKey),
+            binding: P(2),
+            cumulativeSpend: 1n,
+            meterHash: new Uint8Array(32),
+            outputHash: new Uint8Array(32),
+            status: 0,
+            nonce: 1n,
+            expirySlot: 100n,
+            signer: new web3_js_1.PublicKey(kp.publicKey),
+        });
+        const sig = (0, index_1.signEd25519)(kp.secretKey, msg);
+        strict_1.default.ok((0, index_1.verifyEd25519)(new web3_js_1.PublicKey(kp.publicKey), msg, sig));
+        const tampered = Buffer.from(msg);
+        tampered[0] ^= 0xff;
+        strict_1.default.ok(!(0, index_1.verifyEd25519)(new web3_js_1.PublicKey(kp.publicKey), tampered, sig));
+    });
+});
+(0, node_test_1.describe)("ed25519 ix layout", () => {
+    (0, node_test_1.it)("places pubkey/sig/message at 16/48/112 with pinned indices", () => {
+        const ix = (0, index_1.buildEd25519Ix)(P(9), new Uint8Array(64).fill(7), new Uint8Array([1, 2, 3]));
+        const d = Buffer.from(ix.data);
+        strict_1.default.equal(d.length, 16 + 32 + 64 + 3);
+        strict_1.default.equal(d.readUInt8(0), 1);
+        strict_1.default.equal(d.readUInt16LE(2), 48);
+        strict_1.default.equal(d.readUInt16LE(6), 16);
+        strict_1.default.equal(d.readUInt16LE(10), 112);
+        strict_1.default.equal(d.readUInt16LE(12), 3);
+        strict_1.default.ok(d.subarray(16, 48).equals(Buffer.alloc(32, 9)));
+    });
+});
+(0, node_test_1.describe)("channel voucher layout", () => {
+    (0, node_test_1.it)("is magic || channel || cumulative || expires, 50 bytes", () => {
+        const v = (0, index_1.channelVoucherBytes)(P(5), 2000000n, 0n);
+        strict_1.default.equal(v.length, index_1.VOUCHER_LEN);
+        strict_1.default.equal(v.readUInt8(0), 0x56);
+        strict_1.default.equal(v.readUInt8(1), 0x01);
+        strict_1.default.ok(v.subarray(2, 34).equals(Buffer.alloc(32, 5)));
+        strict_1.default.equal(v.readBigUInt64LE(34), 2000000n);
+        strict_1.default.equal(v.readBigInt64LE(42), 0n);
+    });
+});
+(0, node_test_1.describe)("account decoders", () => {
+    function layout(parts, size) {
+        const buf = Buffer.alloc(size);
+        for (const [off, v] of parts) {
+            if (typeof v === "bigint")
+                buf.writeBigUInt64LE(v, off);
+            else
+                buf.writeUInt16LE(v, off);
+        }
+        return buf;
+    }
+    (0, node_test_1.it)("decodes MerchantBond with reserved", () => {
+        const buf = layout([
+            [72, 500000n],
+            [80, 50],
+            [82, 150n],
+            [90, 2n],
+            [98, 7n],
+            [106, 11010n],
+        ], 115);
+        P(3).toBuffer().copy(buf, 8);
+        P(4).toBuffer().copy(buf, 40);
+        const b = (0, index_1.decodeBond)(buf);
+        strict_1.default.ok(b.merchant.equals(P(3)));
+        strict_1.default.ok(b.mint.equals(P(4)));
+        strict_1.default.equal(b.amount, 500000n);
+        strict_1.default.equal(b.slaBps, 50);
+        strict_1.default.equal(b.openDisputes, 2n);
+        strict_1.default.equal(b.reserved, 11010n);
+    });
+    (0, node_test_1.it)("decodes Dispute with claimSpend", () => {
+        const buf = layout([
+            [40, 9n],
+            [81, 1000n],
+            [89, 10000000n],
+            [97, 3670n],
+        ], 106);
+        P(1).toBuffer().copy(buf, 8);
+        buf.writeUInt8(2, 48);
+        P(2).toBuffer().copy(buf, 49);
+        const d = (0, index_1.decodeDispute)(buf);
+        strict_1.default.equal(d.nonce, 9n);
+        strict_1.default.equal(d.reason, 2);
+        strict_1.default.ok(d.claimant.equals(P(2)));
+        strict_1.default.equal(d.claimSpend, 3670n);
+    });
+});

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@infantmen-labs/harbor-sdk",
+  "version": "0.3.0",
+  "description": "TypeScript SDK for Harbor bonded refunds on Solana: PDA helpers, instruction builders, receipt codec, ed25519 verify, account decoders.",
+  "license": "MIT",
+  "keywords": [
+    "solana",
+    "payments",
+    "metered-api",
+    "bond",
+    "anchor"
+  ],
+  "files": [
+    "dist"
+  ],
+  "main": "dist/src/index.js",
+  "types": "dist/src/index.d.ts",
+  "scripts": {
+    "build": "tsc -p .",
+    "test": "node --test dist/test/vectors.test.js"
+  },
+  "dependencies": {
+    "@solana/web3.js": "^1.98.0",
+    "tweetnacl": "^1.0.3"
+  }
+}