@hazbase/simplicity 0.0.1

package/dist/core/presets.js

@@ -0,0 +1,251 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRESET_MANIFEST = void 0;
+exports.listPresets = listPresets;
+exports.getPresetOrThrow = getPresetOrThrow;
+exports.validatePresetParams = validatePresetParams;
+exports.describePreset = describePreset;
+exports.validateWitnessConfig = validateWitnessConfig;
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+const PRESET_DIR = node_path_1.default.resolve(__dirname, "..", "presets");
+exports.PRESET_MANIFEST = {
+    p2pkLockHeight: {
+        id: "p2pkLockHeight",
+        title: "P2PK + Lock Height",
+        description: "Single signer contract gated by block height.",
+        simfTemplatePath: node_path_1.default.join(PRESET_DIR, "p2pkLockHeight.simf.tmpl"),
+        parameterSchema: {
+            MIN_HEIGHT: "number",
+            SIGNER_XONLY: "string",
+        },
+        witnessSchema: {
+            SIGNER_SIGNATURE: {
+                type: "Signature",
+                description: "Primary signer signature over sig_all_hash.",
+            },
+        },
+        exampleWitness: {
+            values: {
+                SIGNER_SIGNATURE: {
+                    type: "Signature",
+                    value: "${SIGNATURE}",
+                },
+            },
+        },
+        executionProfile: {
+            witnessMode: "inlineSignature",
+            supportsGasless: true,
+            supportsDirectExecute: true,
+            supportsRelayerExecute: true,
+            requiredWitnessFields: ["SIGNER_SIGNATURE"],
+            defaultFeeSat: 100,
+            recommendedUtxoPolicy: "smallest_over",
+        },
+        exampleParams: {
+            MIN_HEIGHT: 2344430,
+            SIGNER_XONLY: "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+        },
+    },
+    p2pk: {
+        id: "p2pk",
+        title: "P2PK",
+        description: "Single key spend preset.",
+        simfTemplatePath: node_path_1.default.join(PRESET_DIR, "p2pk.simf.tmpl"),
+        parameterSchema: {
+            SIGNER_XONLY: "string",
+        },
+        witnessSchema: {
+            SIGNER_SIGNATURE: {
+                type: "Signature",
+                description: "Primary signer signature over sig_all_hash.",
+            },
+        },
+        exampleWitness: {
+            values: {
+                SIGNER_SIGNATURE: {
+                    type: "Signature",
+                    value: "${SIGNATURE}",
+                },
+            },
+        },
+        executionProfile: {
+            witnessMode: "inlineSignature",
+            supportsGasless: true,
+            supportsDirectExecute: true,
+            supportsRelayerExecute: true,
+            requiredWitnessFields: ["SIGNER_SIGNATURE"],
+            defaultFeeSat: 100,
+            recommendedUtxoPolicy: "smallest_over",
+        },
+        exampleParams: {
+            SIGNER_XONLY: "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+        },
+    },
+    htlc: {
+        id: "htlc",
+        title: "HTLC",
+        description: "Template placeholder around upstream HTLC example.",
+        simfTemplatePath: node_path_1.default.join(PRESET_DIR, "htlc.simf.tmpl"),
+        parameterSchema: {
+            EXPECTED_HASH: "string",
+            RECIPIENT_XONLY: "string",
+            SENDER_XONLY: "string",
+            TIMEOUT_HEIGHT: "number",
+        },
+        witnessSchema: {
+            COMPLETE_OR_CANCEL: {
+                type: "Either<(u256, Signature), Signature>",
+                description: "Use Left((preimage, recipient signature)) for claim or Right(sender signature) for timeout.",
+            },
+        },
+        exampleWitness: {
+            values: {
+                COMPLETE_OR_CANCEL: {
+                    type: "Either<(u256, Signature), Signature>",
+                    value: "Left((0x0000000000000000000000000000000000000000000000000000000000000000, ${SIGNATURE}))",
+                },
+            },
+        },
+        executionProfile: {
+            witnessMode: "inlineSignature",
+            supportsGasless: true,
+            supportsDirectExecute: true,
+            supportsRelayerExecute: true,
+            requiredWitnessFields: ["COMPLETE_OR_CANCEL"],
+            defaultFeeSat: 100,
+            recommendedUtxoPolicy: "smallest_over",
+        },
+        exampleParams: {
+            EXPECTED_HASH: "66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925",
+            RECIPIENT_XONLY: "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+            SENDER_XONLY: "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5",
+            TIMEOUT_HEIGHT: 1000,
+        },
+    },
+    transferWithTimeout: {
+        id: "transferWithTimeout",
+        title: "Transfer With Timeout",
+        description: "Cooperative transfer path plus unilateral timeout recovery path.",
+        simfTemplatePath: node_path_1.default.join(PRESET_DIR, "transferWithTimeout.simf.tmpl"),
+        parameterSchema: {
+            SENDER_XONLY: "string",
+            RECIPIENT_XONLY: "string",
+            TIMEOUT_HEIGHT: "number",
+        },
+        witnessSchema: {
+            SENDER_SIG: {
+                type: "Signature",
+                description: "Sender signature over sig_all_hash.",
+            },
+            TRANSFER_OR_TIMEOUT: {
+                type: "Option<Signature>",
+                signerAlias: "RECIPIENT",
+                description: "Use Some(recipient signature) for cooperative spend or None for timeout recovery.",
+            },
+        },
+        exampleWitness: {
+            signers: {
+                RECIPIENT: {
+                    type: "schnorrPrivkeyHex",
+                    privkeyHex: "<recipient-privkey-hex>",
+                },
+            },
+            values: {
+                SENDER_SIG: {
+                    type: "Signature",
+                    value: "${SIGNATURE}",
+                },
+                TRANSFER_OR_TIMEOUT: {
+                    type: "Option<Signature>",
+                    value: "Some(${SIGNATURE:RECIPIENT})",
+                },
+            },
+        },
+        executionProfile: {
+            witnessMode: "inlineSignature",
+            supportsGasless: true,
+            supportsDirectExecute: true,
+            supportsRelayerExecute: true,
+            requiredWitnessFields: ["SENDER_SIG", "TRANSFER_OR_TIMEOUT"],
+            defaultFeeSat: 100,
+            recommendedUtxoPolicy: "smallest_over",
+        },
+        exampleParams: {
+            SENDER_XONLY: "79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798",
+            RECIPIENT_XONLY: "c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5",
+            TIMEOUT_HEIGHT: 1000,
+        },
+    },
+};
+function listPresets() {
+    return Object.values(exports.PRESET_MANIFEST);
+}
+function getPresetOrThrow(preset) {
+    const entry = exports.PRESET_MANIFEST[preset];
+    if (!entry) {
+        throw new errors_1.ValidationError(`Unknown preset: ${preset}`);
+    }
+    return entry;
+}
+function validatePresetParams(preset, params) {
+    const normalized = {};
+    for (const [key, kind] of Object.entries(preset.parameterSchema)) {
+        const value = params[key];
+        if (value === undefined) {
+            throw new errors_1.ValidationError(`Missing preset parameter: ${key}`);
+        }
+        if (kind === "number") {
+            const asNumber = typeof value === "number" ? value : Number(value);
+            if (!Number.isFinite(asNumber)) {
+                throw new errors_1.ValidationError(`Preset parameter ${key} must be a number`);
+            }
+            normalized[key] = asNumber;
+            continue;
+        }
+        normalized[key] = String(value);
+    }
+    return normalized;
+}
+function describePreset(preset) {
+    return {
+        id: preset.id,
+        title: preset.title,
+        description: preset.description,
+        parameterSchema: preset.parameterSchema,
+        witnessSchema: preset.witnessSchema ?? {},
+        exampleParams: preset.exampleParams,
+        exampleWitness: preset.exampleWitness ?? null,
+        executionProfile: preset.executionProfile,
+    };
+}
+function validateWitnessConfig(preset, witness) {
+    const schema = preset.witnessSchema ?? {};
+    const values = witness?.values ?? {};
+    const signers = witness?.signers ?? {};
+    for (const field of preset.executionProfile.requiredWitnessFields) {
+        if (!(field in values) && field !== "SIGNER_SIGNATURE") {
+            throw new errors_1.ValidationError(`Missing witness value for preset '${preset.id}': ${field}`);
+        }
+    }
+    for (const [name, entry] of Object.entries(values)) {
+        const spec = schema[name];
+        if (!spec) {
+            throw new errors_1.ValidationError(`Unexpected witness field for preset '${preset.id}': ${name}`);
+        }
+        if (entry.type !== spec.type) {
+            throw new errors_1.ValidationError(`Witness field '${name}' for preset '${preset.id}' must use type '${spec.type}'`);
+        }
+    }
+    for (const [name, spec] of Object.entries(schema)) {
+        if (!spec.signerAlias)
+            continue;
+        const placeholder = `\${SIGNATURE:${spec.signerAlias}}`;
+        if ((values[name]?.value ?? "").includes(placeholder) && !signers[spec.signerAlias]) {
+            throw new errors_1.ValidationError(`Witness field '${name}' references ${placeholder} but signer '${spec.signerAlias}' was not provided`);
+        }
+    }
+}

package/dist/core/rpc.d.ts

@@ -0,0 +1,7 @@
+import { RpcConfig } from "./types";
+export declare class ElementsRpcClient {
+    private readonly config;
+    constructor(config: RpcConfig);
+    private endpoint;
+    call<T>(method: string, params?: unknown[], wallet?: string): Promise<T>;
+}

package/dist/core/rpc.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElementsRpcClient = void 0;
+const node_buffer_1 = require("node:buffer");
+const errors_1 = require("./errors");
+class ElementsRpcClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    endpoint(wallet) {
+        if (!wallet && !this.config.wallet)
+            return this.config.url;
+        const selectedWallet = wallet ?? this.config.wallet;
+        return `${this.config.url}/wallet/${selectedWallet}`;
+    }
+    async call(method, params = [], wallet) {
+        const basicAuth = node_buffer_1.Buffer.from(`${this.config.username}:${this.config.password}`).toString("base64");
+        const response = await fetch(this.endpoint(wallet), {
+            method: "POST",
+            headers: {
+                "content-type": "application/json",
+                authorization: `Basic ${basicAuth}`,
+            },
+            body: JSON.stringify({ jsonrpc: "1.0", id: method, method, params }),
+        });
+        const payload = (await response.json());
+        if (!response.ok || payload.error) {
+            throw new errors_1.ExecutionError(`RPC ${method} failed`, {
+                status: response.status,
+                error: payload.error,
+            });
+        }
+        return payload.result;
+    }
+}
+exports.ElementsRpcClient = ElementsRpcClient;

package/dist/core/summary.d.ts

@@ -0,0 +1,6 @@
+export declare function stableStringify(value: unknown): string;
+export declare function sha256HexUtf8(value: string): string;
+export declare function summarize(value: unknown): {
+    canonicalJson: string;
+    hash: string;
+};

package/dist/core/summary.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stableStringify = stableStringify;
+exports.sha256HexUtf8 = sha256HexUtf8;
+exports.summarize = summarize;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+function stableStringify(value) {
+    if (value === null || typeof value !== "object")
+        return JSON.stringify(value);
+    if (Array.isArray(value))
+        return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
+    const record = value;
+    return `{${Object.keys(record)
+        .sort()
+        .map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`)
+        .join(",")}}`;
+}
+function sha256HexUtf8(value) {
+    return node_crypto_1.default.createHash("sha256").update(value, "utf8").digest("hex");
+}
+function summarize(value) {
+    const canonicalJson = stableStringify(value);
+    return { canonicalJson, hash: sha256HexUtf8(canonicalJson) };
+}

package/dist/core/templating.d.ts

@@ -0,0 +1,2 @@
+export declare function renderTemplate(source: string, vars: Record<string, string | number>): string;
+export declare function normalizeTemplateVars(vars: Record<string, string | number> | undefined): Record<string, string | number>;

package/dist/core/templating.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderTemplate = renderTemplate;
+exports.normalizeTemplateVars = normalizeTemplateVars;
+const errors_1 = require("./errors");
+function renderTemplate(source, vars) {
+    return source.replace(/\{\{([A-Z0-9_]+)\}\}/g, (_, key) => {
+        const value = vars[key];
+        if (value === undefined) {
+            throw new errors_1.ValidationError(`Template variable not provided: ${key}`);
+        }
+        return String(value);
+    });
+}
+function normalizeTemplateVars(vars) {
+    return vars ?? {};
+}

package/dist/core/toolchain.d.ts

@@ -0,0 +1,14 @@
+export interface CommandResult {
+    stdout: string;
+    stderr: string;
+}
+export declare function runCommand(command: string, args: string[], options?: {
+    cwd?: string;
+}): Promise<CommandResult>;
+export declare function runSimcCompile(simcPath: string, simfPath: string): Promise<string>;
+export declare function runSimcWithWitness(simcPath: string, simfPath: string, witnessPath: string): Promise<string>;
+export declare function runHalInfo(halPath: string, program: string): Promise<unknown>;
+export declare function runHalUpdateInput(halPath: string, pset: string, inputIndex: number, utxoSpec: string, cmr: string, internalKey: string): Promise<unknown>;
+export declare function runHalSighash(halPath: string, pset: string, inputIndex: number, cmr: string, privkeyHex: string): Promise<unknown>;
+export declare function runHalFinalize(halPath: string, pset: string, inputIndex: number, program: string, witness: string): Promise<unknown>;
+export declare function runHalExtract(halPath: string, pset: string): Promise<string>;

package/dist/core/toolchain.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommand = runCommand;
+exports.runSimcCompile = runSimcCompile;
+exports.runSimcWithWitness = runSimcWithWitness;
+exports.runHalInfo = runHalInfo;
+exports.runHalUpdateInput = runHalUpdateInput;
+exports.runHalSighash = runHalSighash;
+exports.runHalFinalize = runHalFinalize;
+exports.runHalExtract = runHalExtract;
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const errors_1 = require("./errors");
+const execFileP = (0, node_util_1.promisify)(node_child_process_1.execFile);
+async function runCommand(command, args, options = {}) {
+    try {
+        const { stdout, stderr } = await execFileP(command, args, {
+            cwd: options.cwd,
+            maxBuffer: 1024 * 1024 * 50,
+        });
+        return { stdout: stdout.trim(), stderr: stderr.trim() };
+    }
+    catch (error) {
+        throw new errors_1.ToolchainError(`Command failed: ${command} ${args.join(" ")}`, error);
+    }
+}
+async function runSimcCompile(simcPath, simfPath) {
+    const result = await runCommand(simcPath, [simfPath]);
+    return result.stdout;
+}
+async function runSimcWithWitness(simcPath, simfPath, witnessPath) {
+    const result = await runCommand(simcPath, [simfPath, witnessPath]);
+    return result.stdout;
+}
+async function runHalInfo(halPath, program) {
+    const result = await runCommand(halPath, ["simplicity", "info", program]);
+    return JSON.parse(result.stdout);
+}
+async function runHalUpdateInput(halPath, pset, inputIndex, utxoSpec, cmr, internalKey) {
+    const result = await runCommand(halPath, [
+        "simplicity",
+        "pset",
+        "update-input",
+        pset,
+        String(inputIndex),
+        "-i",
+        utxoSpec,
+        "-c",
+        cmr,
+        "-p",
+        internalKey,
+    ]);
+    return JSON.parse(result.stdout);
+}
+async function runHalSighash(halPath, pset, inputIndex, cmr, privkeyHex) {
+    const result = await runCommand(halPath, [
+        "simplicity",
+        "sighash",
+        pset,
+        String(inputIndex),
+        cmr,
+        "-x",
+        privkeyHex,
+    ]);
+    return JSON.parse(result.stdout);
+}
+async function runHalFinalize(halPath, pset, inputIndex, program, witness) {
+    const result = await runCommand(halPath, [
+        "simplicity",
+        "pset",
+        "finalize",
+        pset,
+        String(inputIndex),
+        program,
+        witness,
+    ]);
+    return JSON.parse(result.stdout);
+}
+async function runHalExtract(halPath, pset) {
+    const result = await runCommand(halPath, ["simplicity", "pset", "extract", pset]);
+    return result.stdout;
+}