@hazbase/simplicity 0.0.1

package/dist/client/ContractFactory.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompiledContract = void 0;
+const artifact_1 = require("../core/artifact");
+const DeployedContract_1 = require("./DeployedContract");
+class CompiledContract {
+    config;
+    artifact;
+    constructor(config, artifact) {
+        this.config = config;
+        this.artifact = artifact;
+    }
+    get contractAddress() {
+        return this.artifact.compiled.contractAddress;
+    }
+    get cmr() {
+        return this.artifact.compiled.cmr;
+    }
+    get program() {
+        return this.artifact.compiled.program;
+    }
+    deployment() {
+        return {
+            contractAddress: this.artifact.compiled.contractAddress,
+            internalKey: this.artifact.compiled.internalKey,
+            cmr: this.artifact.compiled.cmr,
+            network: this.artifact.network,
+            instructions: [
+                `Fund the contract by sending L-BTC to ${this.artifact.compiled.contractAddress}`,
+                "Wait for the contract UTXO to appear before calling inspect/execute.",
+            ],
+        };
+    }
+    async saveArtifact(path) {
+        await (0, artifact_1.saveArtifact)(path, this.artifact);
+    }
+    at(addressOverride) {
+        const artifact = addressOverride && addressOverride !== this.artifact.compiled.contractAddress
+            ? {
+                ...this.artifact,
+                compiled: {
+                    ...this.artifact.compiled,
+                    contractAddress: addressOverride,
+                },
+            }
+            : this.artifact;
+        return new DeployedContract_1.DeployedContract(this.config, artifact, artifact.compiled.contractAddress);
+    }
+}
+exports.CompiledContract = CompiledContract;

package/dist/client/DeployedContract.d.ts

@@ -0,0 +1,12 @@
+import { ContractUtxo, ExecuteCallInput, ExecuteResult, GaslessExecuteInput, GaslessExecuteResult, InspectCallInput, InspectResult, SimplicityArtifact, SimplicityClientConfig, WaitForFundingInput } from "../core/types";
+export declare class DeployedContract {
+    private readonly config;
+    readonly artifact: SimplicityArtifact;
+    readonly contractAddress: string;
+    constructor(config: SimplicityClientConfig, artifact: SimplicityArtifact, contractAddress?: string);
+    findUtxos(): Promise<ContractUtxo[]>;
+    waitForFunding(input?: WaitForFundingInput): Promise<ContractUtxo[]>;
+    inspectCall(input: InspectCallInput): Promise<InspectResult>;
+    execute(input: ExecuteCallInput): Promise<ExecuteResult>;
+    executeGasless(input: GaslessExecuteInput): Promise<GaslessExecuteResult>;
+}

package/dist/client/DeployedContract.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeployedContract = void 0;
+const executor_1 = require("../core/executor");
+const executor_2 = require("../core/executor");
+class DeployedContract {
+    config;
+    artifact;
+    contractAddress;
+    constructor(config, artifact, contractAddress = artifact.compiled.contractAddress) {
+        this.config = config;
+        this.artifact = artifact;
+        this.contractAddress = contractAddress;
+    }
+    async findUtxos() {
+        return (0, executor_1.findContractUtxos)(this.config, this.artifact);
+    }
+    async waitForFunding(input = {}) {
+        const minAmountSat = input.minAmountSat ?? 1;
+        const pollIntervalMs = input.pollIntervalMs ?? 10_000;
+        const timeoutMs = input.timeoutMs ?? 120_000;
+        const start = Date.now();
+        while (Date.now() - start < timeoutMs) {
+            const utxos = await this.findUtxos();
+            const filtered = utxos.filter((utxo) => utxo.sat >= minAmountSat);
+            if (filtered.length > 0) {
+                return filtered;
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        }
+        throw new Error(`Timed out waiting for funding at ${this.contractAddress}`);
+    }
+    async inspectCall(input) {
+        return (0, executor_1.inspectContractCall)(this.config, this.artifact, input);
+    }
+    async execute(input) {
+        return (0, executor_1.executeContractCall)(this.config, this.artifact, input);
+    }
+    async executeGasless(input) {
+        return (0, executor_2.executeGaslessContractCall)(this.config, this.artifact, input);
+    }
+}
+exports.DeployedContract = DeployedContract;

package/dist/client/SimplicityClient.d.ts

@@ -0,0 +1,21 @@
+import { ElementsRpcClient } from "../core/rpc";
+import { CompileFromFileInput, CompileFromPresetInput, SimplicityArtifact, SimplicityClientConfig } from "../core/types";
+import { RelayerClient } from "../gasless/RelayerClient";
+import { GaslessTransferInput, GaslessTransferResult, RelayerClientConfig } from "../gasless/types";
+import { CompiledContract } from "./ContractFactory";
+import { DeployedContract } from "./DeployedContract";
+export declare class SimplicityClient {
+    readonly config: SimplicityClientConfig;
+    readonly rpc: ElementsRpcClient;
+    readonly payments: {
+        gaslessTransfer: (input: GaslessTransferInput) => Promise<GaslessTransferResult>;
+    };
+    constructor(config: SimplicityClientConfig);
+    compileFromFile(input: CompileFromFileInput): Promise<CompiledContract>;
+    compileFromPreset(input: CompileFromPresetInput): Promise<CompiledContract>;
+    loadArtifact(path: string): Promise<CompiledContract>;
+    fromArtifact(artifact: SimplicityArtifact): DeployedContract;
+    relayer(config: RelayerClientConfig): RelayerClient;
+    private gaslessTransfer;
+}
+export declare function createSimplicityClient(config: SimplicityClientConfig): SimplicityClient;

package/dist/client/SimplicityClient.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimplicityClient = void 0;
+exports.createSimplicityClient = createSimplicityClient;
+const artifact_1 = require("../core/artifact");
+const compiler_1 = require("../core/compiler");
+const rpc_1 = require("../core/rpc");
+const RelayerClient_1 = require("../gasless/RelayerClient");
+const ContractFactory_1 = require("./ContractFactory");
+const DeployedContract_1 = require("./DeployedContract");
+class SimplicityClient {
+    config;
+    rpc;
+    payments;
+    constructor(config) {
+        this.config = config;
+        this.rpc = new rpc_1.ElementsRpcClient(config.rpc);
+        this.payments = {
+            gaslessTransfer: async (input) => this.gaslessTransfer(input),
+        };
+    }
+    async compileFromFile(input) {
+        const artifact = await (0, compiler_1.compileFromFile)(this.config, input);
+        return new ContractFactory_1.CompiledContract(this.config, artifact);
+    }
+    async compileFromPreset(input) {
+        const artifact = await (0, compiler_1.compileFromPreset)(this.config, input);
+        return new ContractFactory_1.CompiledContract(this.config, artifact);
+    }
+    async loadArtifact(path) {
+        const artifact = await (0, artifact_1.loadArtifact)(path, this.config.network);
+        return new ContractFactory_1.CompiledContract(this.config, artifact);
+    }
+    fromArtifact(artifact) {
+        return new DeployedContract_1.DeployedContract(this.config, artifact);
+    }
+    relayer(config) {
+        return new RelayerClient_1.RelayerClient(config);
+    }
+    async gaslessTransfer(input) {
+        const relayer = input.relayer ?? (this.config.relayer ? new RelayerClient_1.RelayerClient({
+            baseUrl: this.config.relayer.baseUrl,
+            apiKey: this.config.relayer.apiKey ?? "",
+        }) : null);
+        if (!relayer) {
+            throw new Error("Relayer config is required for gaslessTransfer");
+        }
+        const request = await relayer.requestPset({
+            amount: input.amount,
+            toAddress: input.toAddress,
+            fromLabel: input.fromLabel,
+        });
+        const walletResult = await this.rpc.call("walletprocesspsbt", [request.psetBase64, true, "ALL", true], input.userWallet);
+        const signedPsetBase64 = walletResult.psbt;
+        const submit = await relayer.submitSignedPset({
+            psetId: request.psetId,
+            signedPsetBase64,
+        });
+        return { request, signedPsetBase64, submit };
+    }
+}
+exports.SimplicityClient = SimplicityClient;
+function createSimplicityClient(config) {
+    return new SimplicityClient(config);
+}

package/dist/core/artifact.d.ts

@@ -0,0 +1,6 @@
+import { AnyArtifact, SimplicityArtifact } from "./types";
+export declare const SDK_ARTIFACT_VERSION = 6;
+export declare const SDK_PACKAGE_VERSION = "0.1.0";
+export declare function normalizeArtifact(artifact: AnyArtifact, networkDefault?: SimplicityArtifact["network"]): SimplicityArtifact;
+export declare function loadArtifact(artifactPath: string, networkDefault?: SimplicityArtifact["network"]): Promise<SimplicityArtifact>;
+export declare function saveArtifact(artifactPath: string, artifact: SimplicityArtifact): Promise<void>;

package/dist/core/artifact.js

@@ -0,0 +1,100 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDK_PACKAGE_VERSION = exports.SDK_ARTIFACT_VERSION = void 0;
+exports.normalizeArtifact = normalizeArtifact;
+exports.loadArtifact = loadArtifact;
+exports.saveArtifact = saveArtifact;
+const promises_1 = require("node:fs/promises");
+const node_path_1 = __importDefault(require("node:path"));
+const errors_1 = require("./errors");
+exports.SDK_ARTIFACT_VERSION = 6;
+exports.SDK_PACKAGE_VERSION = "0.1.0";
+function isArtifactV5(value) {
+    return value.version === 5;
+}
+function normalizeArtifact(artifact, networkDefault = "liquidtestnet") {
+    if (artifact.version === exports.SDK_ARTIFACT_VERSION) {
+        return artifact;
+    }
+    if (!isArtifactV5(artifact)) {
+        throw new errors_1.ArtifactError("Unsupported artifact version", artifact);
+    }
+    const compiled = artifact.compiled ?? {};
+    if (!compiled.program || !compiled.cmr || !compiled.internalKey || !compiled.contractAddress) {
+        throw new errors_1.ArtifactError("Artifact v5 is missing compiled fields", artifact);
+    }
+    return {
+        version: exports.SDK_ARTIFACT_VERSION,
+        kind: "simplicity-artifact",
+        createdAt: artifact.createdAt,
+        network: networkDefault,
+        source: {
+            mode: "file",
+            simfPath: artifact.simfTemplatePath,
+            templateVars: artifact.params
+                ? {
+                    MIN_HEIGHT: artifact.params.minHeight ?? "",
+                    SIGNER_XONLY: artifact.params.signerXonly ?? "",
+                }
+                : undefined,
+        },
+        compiled: {
+            program: compiled.program,
+            cmr: compiled.cmr,
+            internalKey: compiled.internalKey,
+            contractAddress: compiled.contractAddress,
+        },
+        toolchain: {
+            simcPath: artifact.toolchain?.simcPath ?? "simc",
+            halSimplicity: artifact.toolchain?.halSimplicity ?? "hal-simplicity",
+        },
+        metadata: {
+            sdkVersion: exports.SDK_PACKAGE_VERSION,
+            notes: null,
+        },
+        legacy: {
+            simfTemplatePath: artifact.simfTemplatePath,
+            params: artifact.params,
+        },
+    };
+}
+async function loadArtifact(artifactPath, networkDefault = "liquidtestnet") {
+    const raw = await (0, promises_1.readFile)(artifactPath, "utf8");
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        throw new errors_1.ArtifactError(`Failed to parse artifact JSON at ${artifactPath}`, error);
+    }
+    const normalized = normalizeArtifact(parsed, networkDefault);
+    const artifactDir = node_path_1.default.dirname(node_path_1.default.resolve(artifactPath));
+    const sourceSimfPath = normalized.source.simfPath
+        ? node_path_1.default.resolve(artifactDir, normalized.source.simfPath)
+        : normalized.source.simfPath;
+    const legacySimfTemplatePath = normalized.legacy?.simfTemplatePath
+        ? node_path_1.default.resolve(artifactDir, normalized.legacy.simfTemplatePath)
+        : normalized.legacy?.simfTemplatePath;
+    return {
+        ...normalized,
+        source: {
+            ...normalized.source,
+            simfPath: sourceSimfPath,
+        },
+        legacy: normalized.legacy
+            ? {
+                ...normalized.legacy,
+                simfTemplatePath: legacySimfTemplatePath,
+            }
+            : undefined,
+    };
+}
+async function saveArtifact(artifactPath, artifact) {
+    if (!node_path_1.default.isAbsolute(artifactPath) && artifactPath.trim().length === 0) {
+        throw new errors_1.ValidationError("artifactPath must not be empty");
+    }
+    await (0, promises_1.writeFile)(artifactPath, JSON.stringify(artifact, null, 2), "utf8");
+}

package/dist/core/compiler.d.ts

@@ -0,0 +1,3 @@
+import { CompileFromFileInput, CompileFromPresetInput, SimplicityArtifact, SimplicityClientConfig } from "./types";
+export declare function compileFromFile(config: SimplicityClientConfig, input: CompileFromFileInput): Promise<SimplicityArtifact>;
+export declare function compileFromPreset(config: SimplicityClientConfig, input: CompileFromPresetInput): Promise<SimplicityArtifact>;

package/dist/core/compiler.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compileFromFile = compileFromFile;
+exports.compileFromPreset = compileFromPreset;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = __importDefault(require("node:path"));
+const artifact_1 = require("./artifact");
+const errors_1 = require("./errors");
+const presets_1 = require("./presets");
+const templating_1 = require("./templating");
+const toolchain_1 = require("./toolchain");
+function parseSimcProgram(output) {
+    const lines = output
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+    for (const line of lines) {
+        if (line.startsWith("Program:")) {
+            const rest = line.slice("Program:".length).trim();
+            if (rest)
+                return rest;
+        }
+    }
+    const nextLineIndex = lines.findIndex((line) => line === "Program:");
+    if (nextLineIndex >= 0 && lines[nextLineIndex + 1]) {
+        return lines[nextLineIndex + 1];
+    }
+    throw new errors_1.CompilerError("Could not parse Program from simc output", { output });
+}
+async function buildArtifact(input) {
+    const compileOutput = await (0, toolchain_1.runSimcCompile)(input.config.toolchain.simcPath, input.renderedSimfPath);
+    const program = parseSimcProgram(compileOutput);
+    const info = (await (0, toolchain_1.runHalInfo)(input.config.toolchain.halSimplicityPath, program));
+    const cmr = info.cmr;
+    const contractAddress = info.liquid_testnet_address_unconf ?? info.liquid_address_unconf;
+    const internalKey = info.internal_key ?? "50929b74c1a04954b78b4b6035e97a5e078a5a0f28ec96d547bfee9ace803ac0";
+    if (!cmr || !contractAddress || !internalKey) {
+        throw new errors_1.CompilerError("Missing fields in hal-simplicity info response", info);
+    }
+    const halVersion = await (0, toolchain_1.runCommand)(input.config.toolchain.halSimplicityPath, ["--version"]);
+    return (0, artifact_1.normalizeArtifact)({
+        version: 6,
+        kind: "simplicity-artifact",
+        createdAt: new Date().toISOString(),
+        network: input.config.network,
+        source: {
+            mode: input.sourceMode,
+            simfPath: input.sourceSimfPath,
+            preset: input.preset,
+            templateVars: input.templateVars,
+        },
+        compiled: {
+            program,
+            cmr,
+            internalKey,
+            contractAddress,
+        },
+        toolchain: {
+            simcPath: input.config.toolchain.simcPath,
+            halSimplicity: halVersion.stdout || input.config.toolchain.halSimplicityPath,
+        },
+        metadata: {
+            sdkVersion: artifact_1.SDK_PACKAGE_VERSION,
+            notes: null,
+        },
+        legacy: {
+            simfTemplatePath: input.sourceSimfPath,
+            params: {
+                minHeight: typeof input.templateVars?.MIN_HEIGHT === "number" ? input.templateVars.MIN_HEIGHT : undefined,
+                signerXonly: typeof input.templateVars?.SIGNER_XONLY === "string" ? input.templateVars.SIGNER_XONLY : undefined,
+            },
+        },
+    }, input.config.network);
+}
+async function compileFromFile(config, input) {
+    const rawSource = await (0, promises_1.readFile)(input.simfPath, "utf8");
+    const rendered = (0, templating_1.renderTemplate)(rawSource, input.templateVars ?? {});
+    const workDir = await (0, promises_1.mkdtemp)(node_path_1.default.join((0, node_os_1.tmpdir)(), "simplicity-sdk-compile-"));
+    const renderedPath = node_path_1.default.join(workDir, node_path_1.default.basename(input.simfPath));
+    await (0, promises_1.writeFile)(renderedPath, rendered, "utf8");
+    const artifact = await buildArtifact({
+        config,
+        renderedSimfPath: renderedPath,
+        sourceMode: "file",
+        sourceSimfPath: input.simfPath,
+        templateVars: input.templateVars,
+    });
+    if (input.artifactPath) {
+        await (0, artifact_1.saveArtifact)(input.artifactPath, artifact);
+    }
+    return artifact;
+}
+async function compileFromPreset(config, input) {
+    const preset = (0, presets_1.getPresetOrThrow)(input.preset);
+    const params = (0, presets_1.validatePresetParams)(preset, input.params);
+    const rawSource = await (0, promises_1.readFile)(preset.simfTemplatePath, "utf8");
+    const rendered = (0, templating_1.renderTemplate)(rawSource, params);
+    const workDir = await (0, promises_1.mkdtemp)(node_path_1.default.join((0, node_os_1.tmpdir)(), "simplicity-sdk-preset-"));
+    const renderedPath = node_path_1.default.join(workDir, `${preset.id}.simf`);
+    await (0, promises_1.writeFile)(renderedPath, rendered, "utf8");
+    const artifact = await buildArtifact({
+        config,
+        renderedSimfPath: renderedPath,
+        sourceMode: "preset",
+        sourceSimfPath: preset.simfTemplatePath,
+        preset: preset.id,
+        templateVars: params,
+    });
+    if (input.artifactPath) {
+        await (0, artifact_1.saveArtifact)(input.artifactPath, artifact);
+    }
+    return artifact;
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,33 @@
+export declare class SimplicitySdkError extends Error {
+    readonly code: string;
+    readonly details?: unknown | undefined;
+    constructor(code: string, message: string, details?: unknown | undefined);
+}
+export declare class ToolchainError extends SimplicitySdkError {
+    constructor(message: string, details?: unknown);
+}
+export declare class CompilerError extends SimplicitySdkError {
+    constructor(message: string, details?: unknown);
+}
+export declare class ArtifactError extends SimplicitySdkError {
+    constructor(message: string, details?: unknown);
+}
+export declare class ExecutionError extends SimplicitySdkError {
+    constructor(message: string, details?: unknown);
+}
+export declare class UtxoNotFoundError extends SimplicitySdkError {
+    constructor(message: string, details?: unknown);
+}
+export declare class RelayerError extends SimplicitySdkError {
+    readonly status?: number | undefined;
+    constructor(message: string, details?: unknown, status?: number | undefined);
+}
+export declare class UnsupportedFeatureError extends SimplicitySdkError {
+    constructor(message: string, details?: unknown);
+}
+export declare class ValidationError extends SimplicitySdkError {
+    constructor(message: string, details?: unknown);
+}
+export declare class PresetExecutionError extends SimplicitySdkError {
+    constructor(message: string, details?: unknown);
+}

package/dist/core/errors.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PresetExecutionError = exports.ValidationError = exports.UnsupportedFeatureError = exports.RelayerError = exports.UtxoNotFoundError = exports.ExecutionError = exports.ArtifactError = exports.CompilerError = exports.ToolchainError = exports.SimplicitySdkError = void 0;
+class SimplicitySdkError extends Error {
+    code;
+    details;
+    constructor(code, message, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = new.target.name;
+    }
+}
+exports.SimplicitySdkError = SimplicitySdkError;
+class ToolchainError extends SimplicitySdkError {
+    constructor(message, details) {
+        super("TOOLCHAIN_ERROR", message, details);
+    }
+}
+exports.ToolchainError = ToolchainError;
+class CompilerError extends SimplicitySdkError {
+    constructor(message, details) {
+        super("COMPILER_ERROR", message, details);
+    }
+}
+exports.CompilerError = CompilerError;
+class ArtifactError extends SimplicitySdkError {
+    constructor(message, details) {
+        super("ARTIFACT_ERROR", message, details);
+    }
+}
+exports.ArtifactError = ArtifactError;
+class ExecutionError extends SimplicitySdkError {
+    constructor(message, details) {
+        super("EXECUTION_ERROR", message, details);
+    }
+}
+exports.ExecutionError = ExecutionError;
+class UtxoNotFoundError extends SimplicitySdkError {
+    constructor(message, details) {
+        super("UTXO_NOT_FOUND", message, details);
+    }
+}
+exports.UtxoNotFoundError = UtxoNotFoundError;
+class RelayerError extends SimplicitySdkError {
+    status;
+    constructor(message, details, status) {
+        super("RELAYER_ERROR", message, details);
+        this.status = status;
+    }
+}
+exports.RelayerError = RelayerError;
+class UnsupportedFeatureError extends SimplicitySdkError {
+    constructor(message, details) {
+        super("UNSUPPORTED_FEATURE", message, details);
+    }
+}
+exports.UnsupportedFeatureError = UnsupportedFeatureError;
+class ValidationError extends SimplicitySdkError {
+    constructor(message, details) {
+        super("VALIDATION_ERROR", message, details);
+    }
+}
+exports.ValidationError = ValidationError;
+class PresetExecutionError extends SimplicitySdkError {
+    constructor(message, details) {
+        super("PRESET_EXECUTION_UNSUPPORTED", message, details);
+    }
+}
+exports.PresetExecutionError = PresetExecutionError;

package/dist/core/executor.d.ts

@@ -0,0 +1,5 @@
+import { ContractUtxo, ExecuteCallInput, ExecuteResult, GaslessExecuteInput, GaslessExecuteResult, InspectCallInput, InspectResult, SimplicityArtifact, SimplicityClientConfig } from "./types";
+export declare function inspectContractCall(config: SimplicityClientConfig, artifact: SimplicityArtifact, input: InspectCallInput): Promise<InspectResult>;
+export declare function executeContractCall(config: SimplicityClientConfig, artifact: SimplicityArtifact, input: ExecuteCallInput): Promise<ExecuteResult>;
+export declare function findContractUtxos(config: SimplicityClientConfig, artifact: SimplicityArtifact): Promise<ContractUtxo[]>;
+export declare function executeGaslessContractCall(config: SimplicityClientConfig, artifact: SimplicityArtifact, input: GaslessExecuteInput): Promise<GaslessExecuteResult>;