boing-sdk 0.3.0

package/dist/rpcDoctor.js

@@ -0,0 +1,66 @@
+/**
+ * One-shot environment check: preflight HTTP discovery + capability probes + optional required methods.
+ */
+import { explainBoingRpcError } from './errors.js';
+import { explainBoingRpcProbeGaps, probeBoingRpcCapabilities } from './rpcCapabilities.js';
+/**
+ * Run {@link BoingClient.preflightRpc}, {@link probeBoingRpcCapabilities}, and optional required-method checks.
+ * `messages` collects short strings suitable for logs or UI (includes `explainBoingRpcProbeGaps` when probes fail).
+ */
+export async function doctorBoingRpcEnvironment(client, options) {
+    const preflight = await client.preflightRpc();
+    const capabilityProbe = await probeBoingRpcCapabilities(client);
+    const messages = [];
+    if (!preflight.httpLiveOk)
+        messages.push('GET /live did not return HTTP 200.');
+    if (!preflight.httpReadyOk)
+        messages.push('GET /ready did not return HTTP 200 (orchestrator may hold traffic).');
+    if (!preflight.jsonrpcBatchOk)
+        messages.push('JSON-RPC batch probe failed (expect current boing-node).');
+    if (!preflight.httpOpenApiJsonOk)
+        messages.push('GET /openapi.json missing or not OpenAPI JSON (upgrade boing-node for HTTP discovery).');
+    if (!preflight.wellKnownBoingRpcOk)
+        messages.push('GET /.well-known/boing-rpc missing (optional HTTP discovery).');
+    if (!preflight.httpLiveJsonOk)
+        messages.push('GET /live.json did not return { ok: true } (optional JSON probes).');
+    const probeExplain = explainBoingRpcProbeGaps(capabilityProbe);
+    if (probeExplain)
+        messages.push(probeExplain);
+    const supported = new Set(capabilityProbe.supportedMethods ?? []);
+    const required = options?.requiredMethods?.filter(Boolean) ?? [];
+    const missingRequiredMethods = required.filter((m) => !supported.has(m));
+    for (const m of missingRequiredMethods) {
+        messages.push(`Required RPC method not advertised: ${m}`);
+    }
+    const ok = preflight.httpLiveOk &&
+        preflight.httpReadyOk &&
+        preflight.jsonrpcBatchOk &&
+        missingRequiredMethods.length === 0 &&
+        probeExplain == null;
+    return {
+        ok,
+        preflight,
+        capabilityProbe,
+        missingRequiredMethods,
+        messages,
+    };
+}
+/** Format {@link BoingRpcDoctorResult} as a multi-line string for stdout. */
+export function formatBoingRpcDoctorReport(result) {
+    const lines = [
+        `ok: ${result.ok}`,
+        `methods_supported: ${result.preflight.supportedMethodCount}`,
+        `http_openapi_json: ${result.preflight.httpOpenApiJsonOk}`,
+        `well_known: ${result.preflight.wellKnownBoingRpcOk}`,
+        `live_json: ${result.preflight.httpLiveJsonOk}`,
+    ];
+    if (result.messages.length > 0) {
+        lines.push('---');
+        lines.push(...result.messages);
+    }
+    return lines.join('\n');
+}
+/** Map arbitrary errors to a short doctor message (uses {@link explainBoingRpcError} for `BoingRpcError`). */
+export function doctorErrorMessage(e) {
+    return explainBoingRpcError(e);
+}

package/dist/rpcSurfaceUi.d.ts

@@ -0,0 +1,32 @@
+/**
+ * UI-oriented helpers from **`boing_health.rpc_surface`** / **`boing_getNetworkInfo.rpc_surface`**.
+ */
+import type { BoingHealthRpcSurface } from './types.js';
+/** Prefer **`networkInfo.rpc_surface`**, then **`health.rpc_surface`**. */
+export declare function mergeRpcSurface(health: {
+    rpc_surface?: BoingHealthRpcSurface;
+} | null, networkInfo: {
+    rpc_surface?: BoingHealthRpcSurface;
+} | null): BoingHealthRpcSurface | null;
+/**
+ * Clamp an inclusive block span to the node’s **`get_logs_max_block_range`** (inclusive pair length).
+ */
+export declare function clampGetLogsBlockSpan(surface: BoingHealthRpcSurface | null | undefined, fromBlock: number, toBlock: number): {
+    fromBlock: number;
+    toBlock: number;
+    clamped: boolean;
+};
+/**
+ * Suggested minimum delay between steady-state read RPCs when HTTP JSON-RPC rate limiting is enabled (**RPS > 0**).
+ * Returns **`0`** when unlimited.
+ */
+export declare function suggestedReadSpacingMs(surface: BoingHealthRpcSurface | null | undefined): number;
+/**
+ * Short tooltip copy for logs cap (span and max rows).
+ */
+export declare function describeGetLogsLimits(surface: BoingHealthRpcSurface | null | undefined): string;
+/**
+ * Whether the node advertises a finite WebSocket subscriber cap (non-zero).
+ */
+export declare function websocketHasConnectionCap(surface: BoingHealthRpcSurface | null | undefined): boolean;
+//# sourceMappingURL=rpcSurfaceUi.d.ts.map

package/dist/rpcSurfaceUi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rpcSurfaceUi.d.ts","sourceRoot":"","sources":["../src/rpcSurfaceUi.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAExD,2EAA2E;AAC3E,wBAAgB,eAAe,CAC7B,MAAM,EAAE;IAAE,WAAW,CAAC,EAAE,qBAAqB,CAAA;CAAE,GAAG,IAAI,EACtD,WAAW,EAAE;IAAE,WAAW,CAAC,EAAE,qBAAqB,CAAA;CAAE,GAAG,IAAI,GAC1D,qBAAqB,GAAG,IAAI,CAE9B;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,qBAAqB,GAAG,IAAI,GAAG,SAAS,EACjD,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAU1D;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAIhG;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI,GAAG,SAAS,GAAG,MAAM,CAO/F;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,OAAO,EAAE,qBAAqB,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAGpG"}

package/dist/rpcSurfaceUi.js

@@ -0,0 +1,49 @@
+/**
+ * UI-oriented helpers from **`boing_health.rpc_surface`** / **`boing_getNetworkInfo.rpc_surface`**.
+ */
+/** Prefer **`networkInfo.rpc_surface`**, then **`health.rpc_surface`**. */
+export function mergeRpcSurface(health, networkInfo) {
+    return networkInfo?.rpc_surface ?? health?.rpc_surface ?? null;
+}
+/**
+ * Clamp an inclusive block span to the node’s **`get_logs_max_block_range`** (inclusive pair length).
+ */
+export function clampGetLogsBlockSpan(surface, fromBlock, toBlock) {
+    const lo = Math.min(fromBlock, toBlock);
+    const hi = Math.max(fromBlock, toBlock);
+    const span = hi - lo;
+    const max = surface?.get_logs_max_block_range;
+    if (max == null || max <= 0 || span <= max) {
+        return { fromBlock: lo, toBlock: hi, clamped: false };
+    }
+    const newHi = lo + max;
+    return { fromBlock: lo, toBlock: newHi, clamped: true };
+}
+/**
+ * Suggested minimum delay between steady-state read RPCs when HTTP JSON-RPC rate limiting is enabled (**RPS > 0**).
+ * Returns **`0`** when unlimited.
+ */
+export function suggestedReadSpacingMs(surface) {
+    const rps = surface?.http_rate_limit_requests_per_sec ?? 0;
+    if (rps <= 0)
+        return 0;
+    return Math.ceil(1000 / rps);
+}
+/**
+ * Short tooltip copy for logs cap (span and max rows).
+ */
+export function describeGetLogsLimits(surface) {
+    if (surface == null) {
+        return 'Log query limits depend on the node; call boing_health for rpc_surface.';
+    }
+    const span = surface.get_logs_max_block_range;
+    const n = surface.get_logs_max_results;
+    return `This RPC allows up to ${span} blocks per query and up to ${n} log rows per response.`;
+}
+/**
+ * Whether the node advertises a finite WebSocket subscriber cap (non-zero).
+ */
+export function websocketHasConnectionCap(surface) {
+    const n = surface?.websocket_max_connections ?? 0;
+    return n > 0;
+}

package/dist/submitFlow.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Simulate → refine access list → submit flows (roadmap P4).
+ */
+import type { BoingClient } from './client.js';
+import type { SimulateResult } from './types.js';
+import { type Ed25519SecretKey32 } from './transactionBuilder.js';
+/** Thrown when simulation fails and access-list widening cannot proceed (or retries exhausted). */
+export declare class SimulationFailedError extends Error {
+    readonly simulation: SimulateResult;
+    readonly attempt: number;
+    constructor(message: string, simulation: SimulateResult, attempt: number);
+}
+export interface SubmitTransferWithSimulationOptions {
+    client: BoingClient;
+    secretKey32: Ed25519SecretKey32;
+    senderHex: string;
+    toHex: string;
+    amount: bigint;
+    /** Defaults to sender+to on both sides (matches parallel scheduling hint for transfers). */
+    accessList?: {
+        read: string[];
+        write: string[];
+    };
+    /** Default 6. */
+    maxSimulationRetries?: number;
+}
+export interface SubmitContractCallWithSimulationOptions {
+    client: BoingClient;
+    secretKey32: Ed25519SecretKey32;
+    senderHex: string;
+    contractHex: string;
+    calldata: Uint8Array;
+    /** Defaults to sender+contract on both sides. */
+    accessList?: {
+        read: string[];
+        write: string[];
+    };
+    maxSimulationRetries?: number;
+}
+export interface SubmitFlowResult {
+    tx_hash: string;
+    lastSimulation: SimulateResult;
+    attempts: number;
+}
+/**
+ * Sign a transfer, run `boing_simulateTransaction`, widen access lists when the node reports
+ * `access_list_covers_suggestion: false`, then `boing_submitTransaction` after a successful sim.
+ */
+export declare function submitTransferWithSimulationRetry(opts: SubmitTransferWithSimulationOptions): Promise<SubmitFlowResult>;
+/** Same pattern as transfer for `ContractCall` payloads. */
+export declare function submitContractCallWithSimulationRetry(opts: SubmitContractCallWithSimulationOptions): Promise<SubmitFlowResult>;
+/**
+ * Run `boing_qaCheck` (reject stops here), then sign → simulate → submit a purpose-bearing deploy.
+ * Mempool may still return `-32050` / `-32051` / pool caps — catch `BoingRpcError` on submit.
+ */
+export declare function submitDeployWithPurposeFlow(opts: {
+    client: BoingClient;
+    secretKey32: Ed25519SecretKey32;
+    senderHex: string;
+    bytecode: Uint8Array;
+    purposeCategory: string;
+    descriptionHash?: Uint8Array | null;
+    create2Salt?: Uint8Array | null;
+    accessList?: {
+        read: string[];
+        write: string[];
+    };
+    maxSimulationRetries?: number;
+}): Promise<SubmitFlowResult>;
+//# sourceMappingURL=submitFlow.d.ts.map

package/dist/submitFlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"submitFlow.d.ts","sourceRoot":"","sources":["../src/submitFlow.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG/C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAML,KAAK,kBAAkB,EACxB,MAAM,yBAAyB,CAAC;AAEjC,mGAAmG;AACnG,qBAAa,qBAAsB,SAAQ,KAAK;aAG5B,UAAU,EAAE,cAAc;aAC1B,OAAO,EAAE,MAAM;gBAF/B,OAAO,EAAE,MAAM,EACC,UAAU,EAAE,cAAc,EAC1B,OAAO,EAAE,MAAM;CAKlC;AAED,MAAM,WAAW,mCAAmC;IAClD,MAAM,EAAE,WAAW,CAAC;IACpB,WAAW,EAAE,kBAAkB,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,4FAA4F;IAC5F,UAAU,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACjD,iBAAiB;IACjB,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,uCAAuC;IACtD,MAAM,EAAE,WAAW,CAAC;IACpB,WAAW,EAAE,kBAAkB,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,UAAU,CAAC;IACrB,iDAAiD;IACjD,UAAU,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACjD,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,cAAc,CAAC;IAC/B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,wBAAsB,iCAAiC,CACrD,IAAI,EAAE,mCAAmC,GACxC,OAAO,CAAC,gBAAgB,CAAC,CA0C3B;AAED,4DAA4D;AAC5D,wBAAsB,qCAAqC,CACzD,IAAI,EAAE,uCAAuC,GAC5C,OAAO,CAAC,gBAAgB,CAAC,CA0C3B;AAED;;;GAGG;AACH,wBAAsB,2BAA2B,CAAC,IAAI,EAAE;IACtD,MAAM,EAAE,WAAW,CAAC;IACpB,WAAW,EAAE,kBAAkB,CAAC;IAChC,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,UAAU,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IACpC,WAAW,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IAChC,UAAU,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACjD,oBAAoB,CAAC,EAAE,MAAM,CAAC;CAC/B,GAAG,OAAO,CAAC,gBAAgB,CAAC,CA0D5B"}

package/dist/submitFlow.js

@@ -0,0 +1,121 @@
+/**
+ * Simulate → refine access list → submit flows (roadmap P4).
+ */
+import { mergeAccessListWithSimulation } from './accessList.js';
+import { BoingRpcError } from './errors.js';
+import { bytesToHex } from './hex.js';
+import { buildContractCallTransaction, buildDeployWithPurposeTransaction, buildTransferTransaction, fetchNextNonce, signTransactionInput, } from './transactionBuilder.js';
+/** Thrown when simulation fails and access-list widening cannot proceed (or retries exhausted). */
+export class SimulationFailedError extends Error {
+    constructor(message, simulation, attempt) {
+        super(message);
+        this.simulation = simulation;
+        this.attempt = attempt;
+        this.name = 'SimulationFailedError';
+    }
+}
+/**
+ * Sign a transfer, run `boing_simulateTransaction`, widen access lists when the node reports
+ * `access_list_covers_suggestion: false`, then `boing_submitTransaction` after a successful sim.
+ */
+export async function submitTransferWithSimulationRetry(opts) {
+    const max = opts.maxSimulationRetries ?? 6;
+    let read = opts.accessList?.read ?? [opts.senderHex, opts.toHex];
+    let write = opts.accessList?.write ?? [opts.senderHex, opts.toHex];
+    const nonce = await fetchNextNonce(opts.client, opts.senderHex);
+    let lastSim = null;
+    for (let attempt = 0; attempt < max; attempt++) {
+        const tx = buildTransferTransaction({
+            nonce,
+            senderHex: opts.senderHex,
+            toHex: opts.toHex,
+            amount: opts.amount,
+            accessList: { read, write },
+        });
+        const signedHex = await signTransactionInput(tx, opts.secretKey32);
+        lastSim = await opts.client.simulateTransaction(signedHex);
+        if (lastSim.success) {
+            const sub = await opts.client.submitTransaction(signedHex);
+            return { tx_hash: sub.tx_hash, lastSimulation: lastSim, attempts: attempt + 1 };
+        }
+        if (lastSim.access_list_covers_suggestion === false && lastSim.suggested_access_list) {
+            const m = mergeAccessListWithSimulation(read, write, lastSim);
+            read = m.read;
+            write = m.write;
+            continue;
+        }
+        throw new SimulationFailedError(lastSim.error ?? 'Simulation failed', lastSim, attempt);
+    }
+    throw new SimulationFailedError(`Exceeded maxSimulationRetries (${max})`, lastSim, max - 1);
+}
+/** Same pattern as transfer for `ContractCall` payloads. */
+export async function submitContractCallWithSimulationRetry(opts) {
+    const max = opts.maxSimulationRetries ?? 6;
+    let read = opts.accessList?.read ?? [opts.senderHex, opts.contractHex];
+    let write = opts.accessList?.write ?? [opts.senderHex, opts.contractHex];
+    const nonce = await fetchNextNonce(opts.client, opts.senderHex);
+    let lastSim = null;
+    for (let attempt = 0; attempt < max; attempt++) {
+        const tx = buildContractCallTransaction({
+            nonce,
+            senderHex: opts.senderHex,
+            contractHex: opts.contractHex,
+            calldata: opts.calldata,
+            accessList: { read, write },
+        });
+        const signedHex = await signTransactionInput(tx, opts.secretKey32);
+        lastSim = await opts.client.simulateTransaction(signedHex);
+        if (lastSim.success) {
+            const sub = await opts.client.submitTransaction(signedHex);
+            return { tx_hash: sub.tx_hash, lastSimulation: lastSim, attempts: attempt + 1 };
+        }
+        if (lastSim.access_list_covers_suggestion === false && lastSim.suggested_access_list) {
+            const m = mergeAccessListWithSimulation(read, write, lastSim);
+            read = m.read;
+            write = m.write;
+            continue;
+        }
+        throw new SimulationFailedError(lastSim.error ?? 'Simulation failed', lastSim, attempt);
+    }
+    throw new SimulationFailedError(`Exceeded maxSimulationRetries (${max})`, lastSim, max - 1);
+}
+/**
+ * Run `boing_qaCheck` (reject stops here), then sign → simulate → submit a purpose-bearing deploy.
+ * Mempool may still return `-32050` / `-32051` / pool caps — catch `BoingRpcError` on submit.
+ */
+export async function submitDeployWithPurposeFlow(opts) {
+    const qa = await opts.client.qaCheck(bytesToHex(opts.bytecode), opts.purposeCategory, opts.descriptionHash ? bytesToHex(opts.descriptionHash) : undefined);
+    if (qa.result === 'reject') {
+        throw new BoingRpcError(-32050, qa.message ?? 'QA preflight rejected', { rule_id: qa.rule_id, message: qa.message }, 'boing_qaCheck');
+    }
+    const max = opts.maxSimulationRetries ?? 6;
+    let read = opts.accessList?.read ?? [opts.senderHex];
+    let write = opts.accessList?.write ?? [opts.senderHex];
+    const nonce = await fetchNextNonce(opts.client, opts.senderHex);
+    let lastSim = null;
+    for (let attempt = 0; attempt < max; attempt++) {
+        const tx = buildDeployWithPurposeTransaction({
+            nonce,
+            senderHex: opts.senderHex,
+            bytecode: opts.bytecode,
+            purposeCategory: opts.purposeCategory,
+            descriptionHash: opts.descriptionHash ?? null,
+            create2Salt: opts.create2Salt ?? null,
+            accessList: { read, write },
+        });
+        const signedHex = await signTransactionInput(tx, opts.secretKey32);
+        lastSim = await opts.client.simulateTransaction(signedHex);
+        if (lastSim.success) {
+            const sub = await opts.client.submitTransaction(signedHex);
+            return { tx_hash: sub.tx_hash, lastSimulation: lastSim, attempts: attempt + 1 };
+        }
+        if (lastSim.access_list_covers_suggestion === false && lastSim.suggested_access_list) {
+            const m = mergeAccessListWithSimulation(read, write, lastSim);
+            read = m.read;
+            write = m.write;
+            continue;
+        }
+        throw new SimulationFailedError(lastSim.error ?? 'Simulation failed', lastSim, attempt);
+    }
+    throw new SimulationFailedError(`Exceeded maxSimulationRetries (${max})`, lastSim, max - 1);
+}

package/dist/transactionBuilder.d.ts

@@ -0,0 +1,55 @@
+/**
+ * High-level transaction construction + Ed25519 signing (browser/Node).
+ * Produces hex `SignedTransaction` for `boing_submitTransaction`.
+ */
+import type { BoingClient } from './client.js';
+import { type TransactionInput } from './bincode.js';
+/** 32-byte Ed25519 seed / secret key (same format as Rust `SigningKey::from_bytes`). */
+export type Ed25519SecretKey32 = Uint8Array;
+/** Derive Boing `AccountId` hex (0x + 64 hex) from a 32-byte Ed25519 secret seed. */
+export declare function senderHexFromSecretKey(secretKey32: Ed25519SecretKey32): Promise<string>;
+/** Next tx nonce from chain (`boing_getAccount`). */
+export declare function fetchNextNonce(client: BoingClient, senderHex: string): Promise<bigint>;
+export interface BuildTransferInput {
+    nonce: bigint;
+    /** 32-byte account hex (must match public key of signer). */
+    senderHex: string;
+    toHex: string;
+    amount: bigint;
+    accessList?: {
+        read: string[];
+        write: string[];
+    };
+}
+export declare function buildTransferTransaction(input: BuildTransferInput): TransactionInput;
+export interface BuildContractCallInput {
+    nonce: bigint;
+    senderHex: string;
+    contractHex: string;
+    calldata: Uint8Array;
+    accessList?: {
+        read: string[];
+        write: string[];
+    };
+}
+export declare function buildContractCallTransaction(input: BuildContractCallInput): TransactionInput;
+export interface BuildDeployWithPurposeInput {
+    nonce: bigint;
+    senderHex: string;
+    bytecode: Uint8Array;
+    purposeCategory: string;
+    descriptionHash?: Uint8Array | null;
+    create2Salt?: Uint8Array | null;
+    accessList?: {
+        read: string[];
+        write: string[];
+    };
+}
+export declare function buildDeployWithPurposeTransaction(input: BuildDeployWithPurposeInput): TransactionInput;
+export declare function signTransactionInput(tx: TransactionInput, secretKey32: Ed25519SecretKey32): Promise<string>;
+/**
+ * Sign with a custom async signer (e.g. hardware wallet or IPC to Boing Express).
+ * Caller must ensure the signer corresponds to `tx.sender`; no verification here.
+ */
+export declare function signTransactionInputWithSigner(tx: TransactionInput, signHash: (hash32: Uint8Array) => Promise<Uint8Array>): Promise<string>;
+//# sourceMappingURL=transactionBuilder.d.ts.map

package/dist/transactionBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilder.d.ts","sourceRoot":"","sources":["../src/transactionBuilder.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,cAAc,CAAC;AAGtB,wFAAwF;AACxF,MAAM,MAAM,kBAAkB,GAAG,UAAU,CAAC;AAE5C,qFAAqF;AACrF,wBAAsB,sBAAsB,CAAC,WAAW,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC,CAI7F;AAED,qDAAqD;AACrD,wBAAsB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAG5F;AAMD,MAAM,WAAW,kBAAkB;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,6DAA6D;IAC7D,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAClD;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,kBAAkB,GAAG,gBAAgB,CAapF;AAED,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,UAAU,CAAC;IACrB,UAAU,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAClD;AAED,wBAAgB,4BAA4B,CAAC,KAAK,EAAE,sBAAsB,GAAG,gBAAgB,CAa5F;AAED,MAAM,WAAW,2BAA2B;IAC1C,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,UAAU,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IACpC,WAAW,CAAC,EAAE,UAAU,GAAG,IAAI,CAAC;IAChC,UAAU,CAAC,EAAE;QAAE,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAClD;AAED,wBAAgB,iCAAiC,CAC/C,KAAK,EAAE,2BAA2B,GACjC,gBAAgB,CAelB;AAWD,wBAAsB,oBAAoB,CACxC,EAAE,EAAE,gBAAgB,EACpB,WAAW,EAAE,kBAAkB,GAC9B,OAAO,CAAC,MAAM,CAAC,CAUjB;AAED;;;GAGG;AACH,wBAAsB,8BAA8B,CAClD,EAAE,EAAE,gBAAgB,EACpB,QAAQ,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,GACpD,OAAO,CAAC,MAAM,CAAC,CAKjB"}

package/dist/transactionBuilder.js

@@ -0,0 +1,100 @@
+/**
+ * High-level transaction construction + Ed25519 signing (browser/Node).
+ * Produces hex `SignedTransaction` for `boing_submitTransaction`.
+ */
+import * as ed25519 from '@noble/ed25519';
+import { encodeSignedTransaction, signableTransactionHash, } from './bincode.js';
+import { bytesToHex, hexToAccountId, validateHex32 } from './hex.js';
+/** Derive Boing `AccountId` hex (0x + 64 hex) from a 32-byte Ed25519 secret seed. */
+export async function senderHexFromSecretKey(secretKey32) {
+    if (secretKey32.length !== 32)
+        throw new Error('secret key must be 32 bytes');
+    const pub = await ed25519.getPublicKeyAsync(secretKey32);
+    return validateHex32(bytesToHex(pub));
+}
+/** Next tx nonce from chain (`boing_getAccount`). */
+export async function fetchNextNonce(client, senderHex) {
+    const acc = await client.getAccount(validateHex32(senderHex));
+    return BigInt(acc.nonce);
+}
+function accountVec(hexList) {
+    return hexList.map((h) => hexToAccountId(validateHex32(h)));
+}
+export function buildTransferTransaction(input) {
+    const read = input.accessList?.read ?? [];
+    const write = input.accessList?.write ?? [];
+    return {
+        nonce: input.nonce,
+        sender: hexToAccountId(validateHex32(input.senderHex)),
+        payload: {
+            kind: 'transfer',
+            to: hexToAccountId(validateHex32(input.toHex)),
+            amount: input.amount,
+        },
+        accessList: { read: accountVec(read), write: accountVec(write) },
+    };
+}
+export function buildContractCallTransaction(input) {
+    const read = input.accessList?.read ?? [];
+    const write = input.accessList?.write ?? [];
+    return {
+        nonce: input.nonce,
+        sender: hexToAccountId(validateHex32(input.senderHex)),
+        payload: {
+            kind: 'contractCall',
+            contract: hexToAccountId(validateHex32(input.contractHex)),
+            calldata: input.calldata,
+        },
+        accessList: { read: accountVec(read), write: accountVec(write) },
+    };
+}
+export function buildDeployWithPurposeTransaction(input) {
+    const read = input.accessList?.read ?? [];
+    const write = input.accessList?.write ?? [];
+    return {
+        nonce: input.nonce,
+        sender: hexToAccountId(validateHex32(input.senderHex)),
+        payload: {
+            kind: 'contractDeployWithPurpose',
+            bytecode: input.bytecode,
+            purposeCategory: input.purposeCategory,
+            descriptionHash: input.descriptionHash ?? null,
+            create2Salt: input.create2Salt ?? null,
+        },
+        accessList: { read: accountVec(read), write: accountVec(write) },
+    };
+}
+/**
+ * Sign the Boing signable hash with Ed25519 and return bincode `SignedTransaction` as 0x-hex.
+ */
+function bytesEqual(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;
+}
+export async function signTransactionInput(tx, secretKey32) {
+    if (secretKey32.length !== 32)
+        throw new Error('secret key must be 32 bytes');
+    const pub = await ed25519.getPublicKeyAsync(secretKey32);
+    if (!bytesEqual(pub, tx.sender)) {
+        throw new Error('tx.sender must equal the Ed25519 public key derived from the secret key');
+    }
+    const hash = signableTransactionHash(tx);
+    const sig = await ed25519.signAsync(hash, secretKey32);
+    const raw = encodeSignedTransaction(tx, sig);
+    return bytesToHex(raw);
+}
+/**
+ * Sign with a custom async signer (e.g. hardware wallet or IPC to Boing Express).
+ * Caller must ensure the signer corresponds to `tx.sender`; no verification here.
+ */
+export async function signTransactionInputWithSigner(tx, signHash) {
+    const hash = signableTransactionHash(tx);
+    const sig = await signHash(hash);
+    if (sig.length !== 64)
+        throw new Error('Ed25519 signature must be 64 bytes');
+    return bytesToHex(encodeSignedTransaction(tx, sig));
+}