@cogcoin/client 1.1.8 → 1.1.10

package/dist/wallet/tx/register/plan.js

@@ -0,0 +1,168 @@
+import { buildWalletMutationTransactionWithReserveFallback, outpointKey, } from "../common.js";
+function satsToBtcNumber(value) {
+    return Number(value) / 100_000_000;
+}
+function valueToSats(value) {
+    const text = typeof value === "number" ? value.toFixed(8) : value;
+    const match = /^(-?)(\d+)(?:\.(\d{0,8}))?$/.exec(text.trim());
+    if (match == null) {
+        throw new Error(`wallet_register_invalid_amount_${text}`);
+    }
+    const sign = match[1] === "-" ? -1n : 1n;
+    const whole = BigInt(match[2] ?? "0");
+    const fraction = BigInt((match[3] ?? "").padEnd(8, "0"));
+    return sign * ((whole * 100000000n) + fraction);
+}
+function encodeOpReturnScript(payload) {
+    if (payload.length <= 75) {
+        return Buffer.concat([
+            Buffer.from([0x6a, payload.length]),
+            Buffer.from(payload),
+        ]).toString("hex");
+    }
+    return Buffer.concat([
+        Buffer.from([0x6a, 0x4c, payload.length]),
+        Buffer.from(payload),
+    ]).toString("hex");
+}
+export function extractOpReturnPayloadFromScriptHex(scriptHex) {
+    const bytes = Buffer.from(scriptHex, "hex");
+    if (bytes.length < 2 || bytes[0] !== 0x6a) {
+        return null;
+    }
+    const opcode = bytes[1];
+    if (opcode <= 75) {
+        const end = 2 + opcode;
+        return end === bytes.length ? bytes.subarray(2, end) : null;
+    }
+    if (opcode === 0x4c && bytes.length >= 3) {
+        const length = bytes[2];
+        const end = 3 + length;
+        return end === bytes.length ? bytes.subarray(3, end) : null;
+    }
+    return null;
+}
+function isSpendableConfirmedUtxo(entry) {
+    return entry.confirmations >= 1
+        && entry.spendable !== false
+        && entry.safe !== false;
+}
+function sortUtxos(entries) {
+    return entries
+        .slice()
+        .sort((left, right) => right.amount - left.amount
+        || left.txid.localeCompare(right.txid)
+        || left.vout - right.vout);
+}
+function listFundingUtxos(entries, fundingScriptPubKeyHex) {
+    return sortUtxos(entries.filter((entry) => isSpendableConfirmedUtxo(entry) && entry.scriptPubKey === fundingScriptPubKeyHex));
+}
+function buildRootRegisterOutputs(options) {
+    const payload = options.serializeDomainReg(options.domainName).opReturnData;
+    const outputs = [
+        { data: Buffer.from(payload).toString("hex") },
+        { [options.treasuryAddress]: satsToBtcNumber(options.priceSats) },
+    ];
+    return {
+        outputs,
+        changePosition: outputs.length,
+        expectedOpReturnScriptHex: encodeOpReturnScript(payload),
+    };
+}
+function buildSubdomainRegisterOutputs(options) {
+    const payload = options.serializeDomainReg(options.domainName).opReturnData;
+    return {
+        outputs: [{ data: Buffer.from(payload).toString("hex") }],
+        changePosition: 1,
+        expectedOpReturnScriptHex: encodeOpReturnScript(payload),
+    };
+}
+export function validateFundedDraft(decoded, funded, plan) {
+    const inputs = decoded.tx.vin;
+    const outputs = decoded.tx.vout;
+    if (inputs.length === 0) {
+        throw new Error("wallet_register_missing_sender_input");
+    }
+    if (outputs[0]?.scriptPubKey?.hex !== plan.expectedOpReturnScriptHex) {
+        throw new Error("wallet_register_opreturn_mismatch");
+    }
+    if (plan.expectedTreasuryScriptHex !== null && plan.expectedTreasuryOutputIndex !== null) {
+        if (outputs[plan.expectedTreasuryOutputIndex]?.scriptPubKey?.hex !== plan.expectedTreasuryScriptHex) {
+            throw new Error("wallet_register_treasury_output_mismatch");
+        }
+        if (valueToSats(outputs[plan.expectedTreasuryOutputIndex]?.value ?? 0) < (plan.expectedTreasuryValueSats ?? 0n)) {
+            throw new Error("wallet_register_treasury_value_too_small");
+        }
+    }
+    const expectedWithoutChange = 1 + Number(plan.expectedTreasuryOutputIndex !== null);
+    if (funded.changepos === -1) {
+        if (outputs.length !== expectedWithoutChange) {
+            throw new Error("wallet_register_unexpected_output_count");
+        }
+        return;
+    }
+    if (funded.changepos !== plan.changePosition || outputs.length !== expectedWithoutChange + 1) {
+        throw new Error("wallet_register_change_position_mismatch");
+    }
+    if (outputs[funded.changepos]?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex) {
+        throw new Error("wallet_register_change_output_mismatch");
+    }
+}
+export function buildRegisterPlan(options) {
+    void options.context;
+    void options.parentDomainName;
+    const fundingUtxos = listFundingUtxos(options.allUtxos, options.state.funding.scriptPubKeyHex);
+    if (options.registerKind === "root") {
+        const rootOutputs = buildRootRegisterOutputs({
+            domainName: options.domainName,
+            treasuryAddress: options.treasuryAddress,
+            treasuryScriptPubKeyHex: options.treasuryScriptPubKeyHex,
+            priceSats: options.rootPriceSats,
+            serializeDomainReg: options.serializeDomainReg,
+        });
+        return {
+            registerKind: "root",
+            sender: options.sender,
+            changeAddress: options.state.funding.address,
+            fixedInputs: [],
+            outputs: rootOutputs.outputs,
+            changePosition: rootOutputs.changePosition,
+            expectedOpReturnScriptHex: rootOutputs.expectedOpReturnScriptHex,
+            expectedTreasuryOutputIndex: 1,
+            expectedTreasuryScriptHex: options.treasuryScriptPubKeyHex,
+            expectedTreasuryValueSats: options.rootPriceSats,
+            allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+            eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => outpointKey(entry))),
+        };
+    }
+    const subdomainOutputs = buildSubdomainRegisterOutputs({
+        domainName: options.domainName,
+        serializeDomainReg: options.serializeDomainReg,
+    });
+    return {
+        registerKind: "subdomain",
+        sender: options.sender,
+        changeAddress: options.state.funding.address,
+        fixedInputs: [],
+        outputs: subdomainOutputs.outputs,
+        changePosition: subdomainOutputs.changePosition,
+        expectedOpReturnScriptHex: subdomainOutputs.expectedOpReturnScriptHex,
+        expectedTreasuryOutputIndex: null,
+        expectedTreasuryScriptHex: null,
+        expectedTreasuryValueSats: null,
+        allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+        eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => outpointKey(entry))),
+    };
+}
+export async function buildRegisterTransaction(options) {
+    return buildWalletMutationTransactionWithReserveFallback({
+        rpc: options.rpc,
+        walletName: options.walletName,
+        state: options.state,
+        plan: options.plan,
+        validateFundedDraft,
+        finalizeErrorCode: "wallet_register_finalize_failed",
+        mempoolRejectPrefix: "wallet_register_mempool_rejected",
+        feeRate: options.feeRateSatVb,
+    });
+}

package/dist/wallet/tx/register/result.d.ts

@@ -0,0 +1,78 @@
+import type { PendingMutationRecord } from "../../types.js";
+import type { WalletMutationFeeSummary } from "../common.js";
+export declare const SUBDOMAIN_REGISTRATION_FEE_COGTOSHI = 100n;
+export type RegisterEconomicEffectKind = "treasury-payment" | "cog-burn";
+export interface RegisterResolvedSenderSummary {
+    selector: string;
+    localIndex: number;
+    scriptPubKeyHex: string;
+    address: string;
+}
+export interface RegisterResolvedEconomicEffectSummary {
+    kind: RegisterEconomicEffectKind;
+    amount: bigint;
+}
+export interface RegisterResolvedSummary {
+    path: "root" | "subdomain";
+    parentDomainName: string | null;
+    sender: RegisterResolvedSenderSummary;
+    economicEffect: RegisterResolvedEconomicEffectSummary;
+}
+export interface RegisterDomainResult {
+    domainName: string;
+    registerKind: "root" | "subdomain";
+    parentDomainName: string | null;
+    senderSelector: string;
+    senderLocalIndex: number;
+    senderScriptPubKeyHex: string;
+    senderAddress: string;
+    economicEffectKind: RegisterEconomicEffectKind;
+    economicEffectAmount: bigint;
+    resolved: RegisterResolvedSummary;
+    txid: string;
+    status: "live" | "confirmed";
+    reusedExisting: boolean;
+    fees: WalletMutationFeeSummary;
+}
+export declare function createRegisterReuseResult(options: {
+    operation: {
+        normalizedDomainName: string;
+        senderResolution: {
+            registerKind: "root" | "subdomain";
+            parentDomainName: string | null;
+            senderSelector: string;
+            sender: {
+                localIndex: number;
+                scriptPubKeyHex: string;
+                address: string;
+            };
+        };
+        rootPriceSats: bigint;
+        resolvedSummary: RegisterResolvedSummary;
+    };
+    mutation: PendingMutationRecord;
+    resolution: "confirmed" | "live";
+    fees: WalletMutationFeeSummary;
+}): RegisterDomainResult;
+export declare function createRegisterResult(options: {
+    operation: {
+        normalizedDomainName: string;
+        senderResolution: {
+            registerKind: "root" | "subdomain";
+            parentDomainName: string | null;
+            senderSelector: string;
+            sender: {
+                localIndex: number;
+                scriptPubKeyHex: string;
+                address: string;
+            };
+        };
+        rootPriceSats: bigint;
+        resolvedSummary: RegisterResolvedSummary;
+    };
+    mutation: PendingMutationRecord;
+    builtTxid: string | null;
+    status: "live" | "confirmed";
+    reusedExisting: boolean;
+    fees: WalletMutationFeeSummary;
+}): RegisterDomainResult;

package/dist/wallet/tx/register/result.js

@@ -0,0 +1,41 @@
+export const SUBDOMAIN_REGISTRATION_FEE_COGTOSHI = 100n;
+export function createRegisterReuseResult(options) {
+    return {
+        domainName: options.operation.normalizedDomainName,
+        registerKind: options.operation.senderResolution.registerKind,
+        parentDomainName: options.operation.senderResolution.parentDomainName,
+        senderSelector: options.operation.senderResolution.senderSelector,
+        senderLocalIndex: options.operation.senderResolution.sender.localIndex,
+        senderScriptPubKeyHex: options.operation.senderResolution.sender.scriptPubKeyHex,
+        senderAddress: options.operation.senderResolution.sender.address,
+        economicEffectKind: options.operation.senderResolution.registerKind === "root" ? "treasury-payment" : "cog-burn",
+        economicEffectAmount: options.operation.senderResolution.registerKind === "root"
+            ? options.operation.rootPriceSats
+            : SUBDOMAIN_REGISTRATION_FEE_COGTOSHI,
+        resolved: options.operation.resolvedSummary,
+        txid: options.mutation.attemptedTxid ?? "unknown",
+        status: options.resolution,
+        reusedExisting: true,
+        fees: options.fees,
+    };
+}
+export function createRegisterResult(options) {
+    return {
+        domainName: options.operation.normalizedDomainName,
+        registerKind: options.operation.senderResolution.registerKind,
+        parentDomainName: options.operation.senderResolution.parentDomainName,
+        senderSelector: options.operation.senderResolution.senderSelector,
+        senderLocalIndex: options.operation.senderResolution.sender.localIndex,
+        senderScriptPubKeyHex: options.operation.senderResolution.sender.scriptPubKeyHex,
+        senderAddress: options.operation.senderResolution.sender.address,
+        economicEffectKind: options.operation.senderResolution.registerKind === "root" ? "treasury-payment" : "cog-burn",
+        economicEffectAmount: options.operation.senderResolution.registerKind === "root"
+            ? options.operation.rootPriceSats
+            : SUBDOMAIN_REGISTRATION_FEE_COGTOSHI,
+        resolved: options.operation.resolvedSummary,
+        txid: options.mutation.attemptedTxid ?? options.builtTxid ?? "unknown",
+        status: options.status,
+        reusedExisting: options.reusedExisting,
+        fees: options.fees,
+    };
+}

package/dist/wallet/tx/register.d.ts

@@ -1,70 +1 @@
-import { loadBundledGenesisParameters } from "@cogcoin/indexer";
-import { attachOrStartManagedBitcoindService } from "../../bitcoind/service.js";
-import { createRpcClient } from "../../bitcoind/node.js";
-import type { RpcTransaction } from "../../bitcoind/types.js";
-import type { WalletPrompter } from "../lifecycle.js";
-import { type WalletRuntimePaths } from "../runtime.js";
-import { type WalletSecretProvider } from "../state/provider.js";
-import { openWalletReadContext } from "../read/index.js";
-import { type WalletMutationFeeSummary, type WalletMutationRpcClient } from "./common.js";
-interface WalletRegisterRpcClient extends WalletMutationRpcClient {
-    getBlockchainInfo(): Promise<{
-        blocks: number;
-    }>;
-    sendRawTransaction(hex: string): Promise<string>;
-    getRawMempool(): Promise<string[]>;
-    getRawTransaction(txid: string, verbose?: boolean): Promise<RpcTransaction>;
-}
-type RegisterEconomicEffectKind = "treasury-payment" | "cog-burn";
-export interface RegisterResolvedSenderSummary {
-    selector: string;
-    localIndex: number;
-    scriptPubKeyHex: string;
-    address: string;
-}
-export interface RegisterResolvedEconomicEffectSummary {
-    kind: RegisterEconomicEffectKind;
-    amount: bigint;
-}
-export interface RegisterResolvedSummary {
-    path: "root" | "subdomain";
-    parentDomainName: string | null;
-    sender: RegisterResolvedSenderSummary;
-    economicEffect: RegisterResolvedEconomicEffectSummary;
-}
-export interface RegisterDomainResult {
-    domainName: string;
-    registerKind: "root" | "subdomain";
-    parentDomainName: string | null;
-    senderSelector: string;
-    senderLocalIndex: number;
-    senderScriptPubKeyHex: string;
-    senderAddress: string;
-    economicEffectKind: RegisterEconomicEffectKind;
-    economicEffectAmount: bigint;
-    resolved: RegisterResolvedSummary;
-    txid: string;
-    status: "live" | "confirmed";
-    reusedExisting: boolean;
-    fees: WalletMutationFeeSummary;
-}
-export interface RegisterDomainOptions {
-    domainName: string;
-    fromIdentity?: string | null;
-    feeRateSatVb?: number | null;
-    dataDir: string;
-    databasePath: string;
-    forceRace?: boolean;
-    provider?: WalletSecretProvider;
-    prompter: WalletPrompter;
-    assumeYes?: boolean;
-    nowUnixMs?: number;
-    paths?: WalletRuntimePaths;
-    openReadContext?: typeof openWalletReadContext;
-    attachService?: typeof attachOrStartManagedBitcoindService;
-    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => WalletRegisterRpcClient;
-    loadGenesisParameters?: typeof loadBundledGenesisParameters;
-}
-export declare function extractOpReturnPayloadFromScriptHex(scriptHex: string): Uint8Array | null;
-export declare function registerDomain(options: RegisterDomainOptions): Promise<RegisterDomainResult>;
-export {};
+export * from "./register/index.js";