@cogcoin/client 1.1.8 → 1.1.9

package/dist/wallet/tx/reputation/confirm.d.ts

@@ -0,0 +1,11 @@
+import type { WalletPrompter } from "../../lifecycle.js";
+import type { ReputationResolvedSummary } from "./types.js";
+export declare function confirmReputationMutation(prompter: WalletPrompter, options: {
+    kind: "give" | "revoke";
+    sourceDomainName: string;
+    targetDomainName: string;
+    amountCogtoshi: bigint;
+    reviewText: string | null;
+    resolved: ReputationResolvedSummary;
+    assumeYes?: boolean;
+}): Promise<void>;

package/dist/wallet/tx/reputation/confirm.js

@@ -0,0 +1,51 @@
+import { formatCogAmount } from "../common.js";
+import { confirmTypedAcknowledgement as confirmSharedTypedAcknowledgement, confirmYesNo as confirmSharedYesNo, } from "../confirm.js";
+import { describeReputationEffect, describeReputationReview, } from "./intent.js";
+async function confirmYesNo(prompter, message, errorCode, options) {
+    await confirmSharedYesNo(prompter, message, {
+        assumeYes: options.assumeYes,
+        errorCode,
+        requiresTtyErrorCode: options.requiresTtyErrorCode,
+    });
+}
+async function confirmTyped(prompter, expected, prompt, errorCode, options) {
+    await confirmSharedTypedAcknowledgement(prompter, {
+        assumeYes: options.assumeYes,
+        expected,
+        prompt,
+        errorCode,
+        requiresTtyErrorCode: options.requiresTtyErrorCode,
+        typedAckRequiredErrorCode: options.typedAckRequiredErrorCode,
+    });
+}
+export async function confirmReputationMutation(prompter, options) {
+    prompter.writeLine(`${options.kind === "give" ? "Giving" : "Revoking"} reputation from "${options.sourceDomainName}" to "${options.targetDomainName}".`);
+    prompter.writeLine(`Resolved sender: ${options.resolved.sender.selector} (${options.resolved.sender.address})`);
+    prompter.writeLine(`Burn amount: ${formatCogAmount(options.amountCogtoshi)}`);
+    prompter.writeLine(`Effect: ${describeReputationEffect(options.resolved.effect)}.`);
+    prompter.writeLine(`Review: ${describeReputationReview(options.resolved.review)}.`);
+    if (options.reviewText !== null) {
+        prompter.writeLine("Warning: review text will be encoded and published publicly in the mempool and on-chain.");
+    }
+    if (options.kind === "give" && options.resolved.selfStake) {
+        prompter.writeLine("Self-stake: yes.");
+        prompter.writeLine("Warning: this is self-stake.");
+        prompter.writeLine("Self-stake is irrevocable and cannot later be revoked.");
+        await confirmTyped(prompter, options.sourceDomainName, `Type ${options.sourceDomainName} to continue: `, "wallet_rep_give_confirmation_rejected", {
+            assumeYes: options.assumeYes,
+            requiresTtyErrorCode: "wallet_rep_give_requires_tty",
+            typedAckRequiredErrorCode: "wallet_rep_give_typed_ack_required",
+        });
+        return;
+    }
+    await confirmYesNo(prompter, options.kind === "give"
+        ? "This burns COG to publish a reputation commitment."
+        : "This revokes visible support but the burned COG is not refunded.", options.kind === "give"
+        ? "wallet_rep_give_confirmation_rejected"
+        : "wallet_rep_revoke_confirmation_rejected", {
+        assumeYes: options.assumeYes,
+        requiresTtyErrorCode: options.kind === "give"
+            ? "wallet_rep_give_requires_tty"
+            : "wallet_rep_revoke_requires_tty",
+    });
+}

package/dist/wallet/tx/reputation/draft.d.ts

@@ -0,0 +1,20 @@
+import type { WalletRuntimePaths } from "../../runtime.js";
+import type { WalletSecretProvider } from "../../state/provider.js";
+import type { PendingMutationRecord, WalletStateV1 } from "../../types.js";
+import type { WalletReadContext } from "../../read/index.js";
+import type { ReputationDraftMutationOptions, ReputationRpcClient } from "./types.js";
+export declare function createReputationDraftMutation(options: ReputationDraftMutationOptions): PendingMutationRecord;
+export declare function reconcilePendingReputationMutation(options: {
+    state: WalletStateV1;
+    mutation: PendingMutationRecord;
+    provider: WalletSecretProvider;
+    nowUnixMs: number;
+    paths: WalletRuntimePaths;
+    rpc: ReputationRpcClient;
+    walletName: string;
+    context: WalletReadContext;
+}): Promise<{
+    state: WalletStateV1;
+    mutation: PendingMutationRecord;
+    resolution: "confirmed" | "live" | "repair-required" | "not-seen" | "continue";
+}>;

package/dist/wallet/tx/reputation/draft.js

@@ -0,0 +1,130 @@
+import { randomBytes } from "node:crypto";
+import { lookupDomain } from "@cogcoin/indexer/queries";
+import { createWalletMutationFeeMetadata, unlockTemporaryBuilderLocks, updateMutationRecord, } from "../common.js";
+import { persistWalletMutationState, } from "../executor.js";
+import { upsertPendingMutation } from "../journal.js";
+export function createReputationDraftMutation(options) {
+    if (options.existing !== null && options.existing !== undefined) {
+        return {
+            ...options.existing,
+            kind: options.kind,
+            domainName: options.sourceDomainName,
+            senderScriptPubKeyHex: options.sender.scriptPubKeyHex,
+            senderLocalIndex: options.sender.localIndex,
+            recipientDomainName: options.targetDomainName,
+            amountCogtoshi: options.amountCogtoshi,
+            reviewPayloadHex: options.reviewPayloadHex,
+            status: "draft",
+            lastUpdatedAtUnixMs: options.nowUnixMs,
+            attemptedTxid: null,
+            attemptedWtxid: null,
+            ...createWalletMutationFeeMetadata(options.feeSelection),
+            temporaryBuilderLockedOutpoints: [],
+        };
+    }
+    return {
+        mutationId: randomBytes(12).toString("hex"),
+        kind: options.kind,
+        domainName: options.sourceDomainName,
+        parentDomainName: null,
+        senderScriptPubKeyHex: options.sender.scriptPubKeyHex,
+        senderLocalIndex: options.sender.localIndex,
+        amountCogtoshi: options.amountCogtoshi,
+        recipientDomainName: options.targetDomainName,
+        reviewPayloadHex: options.reviewPayloadHex,
+        intentFingerprintHex: options.intentFingerprintHex,
+        status: "draft",
+        createdAtUnixMs: options.nowUnixMs,
+        lastUpdatedAtUnixMs: options.nowUnixMs,
+        attemptedTxid: null,
+        attemptedWtxid: null,
+        ...createWalletMutationFeeMetadata(options.feeSelection),
+        temporaryBuilderLockedOutpoints: [],
+    };
+}
+function mutationNeedsRepair(mutation, context) {
+    if (context.snapshot === null || mutation.recipientDomainName == null) {
+        return false;
+    }
+    const sourceDomain = lookupDomain(context.snapshot.state, mutation.domainName);
+    const targetDomain = lookupDomain(context.snapshot.state, mutation.recipientDomainName);
+    if (sourceDomain === null || targetDomain === null) {
+        return true;
+    }
+    return !sourceDomain.anchored
+        || !targetDomain.anchored
+        || Buffer.from(sourceDomain.ownerScriptPubKey).toString("hex") !== mutation.senderScriptPubKeyHex;
+}
+export async function reconcilePendingReputationMutation(options) {
+    if (options.mutation.status === "confirmed" || options.mutation.status === "live") {
+        return {
+            state: options.state,
+            mutation: options.mutation,
+            resolution: options.mutation.status,
+        };
+    }
+    if (options.mutation.status === "repair-required") {
+        return {
+            state: options.state,
+            mutation: options.mutation,
+            resolution: "repair-required",
+        };
+    }
+    const walletTx = options.mutation.attemptedTxid === null
+        ? null
+        : await options.rpc.getTransaction(options.walletName, options.mutation.attemptedTxid).catch(() => null);
+    if (walletTx !== null) {
+        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
+        const status = walletTx.confirmations > 0 ? "confirmed" : "live";
+        const nextMutation = updateMutationRecord(options.mutation, status, options.nowUnixMs, {
+            temporaryBuilderLockedOutpoints: [],
+        });
+        let nextState = upsertPendingMutation(options.state, nextMutation);
+        nextState = await persistWalletMutationState({
+            state: nextState,
+            provider: options.provider,
+            nowUnixMs: options.nowUnixMs,
+            paths: options.paths,
+        });
+        return {
+            state: nextState,
+            mutation: nextMutation,
+            resolution: status,
+        };
+    }
+    if (mutationNeedsRepair(options.mutation, options.context)) {
+        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
+        const repair = updateMutationRecord(options.mutation, "repair-required", options.nowUnixMs, {
+            temporaryBuilderLockedOutpoints: [],
+        });
+        let nextState = upsertPendingMutation(options.state, repair);
+        nextState = await persistWalletMutationState({
+            state: nextState,
+            provider: options.provider,
+            nowUnixMs: options.nowUnixMs,
+            paths: options.paths,
+        });
+        return { state: nextState, mutation: repair, resolution: "repair-required" };
+    }
+    if (options.mutation.status === "broadcast-unknown"
+        || options.mutation.status === "draft"
+        || options.mutation.status === "broadcasting") {
+        await unlockTemporaryBuilderLocks(options.rpc, options.walletName, options.mutation.temporaryBuilderLockedOutpoints);
+        const canceled = updateMutationRecord(options.mutation, "canceled", options.nowUnixMs, {
+            temporaryBuilderLockedOutpoints: [],
+        });
+        let nextState = upsertPendingMutation(options.state, canceled);
+        nextState = await persistWalletMutationState({
+            state: nextState,
+            provider: options.provider,
+            nowUnixMs: options.nowUnixMs,
+            paths: options.paths,
+        });
+        return { state: nextState, mutation: canceled, resolution: "not-seen" };
+    }
+    return {
+        state: options.state,
+        mutation: options.mutation,
+        resolution: "continue",
+    };
+}

package/dist/wallet/tx/reputation/index.d.ts

@@ -0,0 +1,4 @@
+import type { GiveReputationOptions, ReputationMutationResult, RevokeReputationOptions } from "./types.js";
+export type { GiveReputationOptions, ReputationMutationResult, ReputationResolvedEffect, ReputationResolvedReviewSummary, ReputationResolvedSenderSummary, ReputationResolvedSummary, RevokeReputationOptions, } from "./types.js";
+export declare function giveReputation(options: GiveReputationOptions): Promise<ReputationMutationResult>;
+export declare function revokeReputation(options: RevokeReputationOptions): Promise<ReputationMutationResult>;

package/dist/wallet/tx/reputation/index.js

@@ -0,0 +1,162 @@
+import { mergeFixedWalletInputs, } from "../common.js";
+import { executeWalletMutationOperation, publishWalletMutation, resolveExistingWalletMutation, } from "../executor.js";
+import { confirmReputationMutation, } from "./confirm.js";
+import { createReputationDraftMutation, reconcilePendingReputationMutation, } from "./draft.js";
+import { createReputationOpReturnData, createStandaloneReputationFingerprint, resolveStandaloneReputationOperation, } from "./intent.js";
+import { buildPlanForReputationOperation, buildReputationTransaction, } from "./plan.js";
+import { createReputationResult, createReputationReuseResult, } from "./result.js";
+async function submitReputationMutation(options) {
+    if (!options.prompter.isInteractive && options.assumeYes !== true) {
+        throw new Error(`${options.errorPrefix}_requires_tty`);
+    }
+    if (options.amountCogtoshi <= 0n) {
+        throw new Error(`${options.errorPrefix}_invalid_amount`);
+    }
+    const execution = await executeWalletMutationOperation({
+        ...options,
+        controlLockPurpose: options.errorPrefix,
+        preemptionReason: options.errorPrefix,
+        async resolveOperation(readContext) {
+            return resolveStandaloneReputationOperation({
+                readContext: readContext,
+                sourceDomainName: options.sourceDomainName,
+                targetDomainName: options.targetDomainName,
+                amountCogtoshi: options.amountCogtoshi,
+                reviewText: options.reviewText,
+                kind: options.kind,
+                errorPrefix: options.errorPrefix,
+            });
+        },
+        createIntentFingerprint(operation) {
+            return createStandaloneReputationFingerprint({
+                kind: options.kind,
+                operation,
+                amountCogtoshi: options.amountCogtoshi,
+            });
+        },
+        async resolveExistingMutation({ operation, existingMutation, execution }) {
+            if (existingMutation === null) {
+                return {
+                    state: operation.state,
+                    replacementFixedInputs: null,
+                    result: null,
+                };
+            }
+            return resolveExistingWalletMutation({
+                existingMutation,
+                execution,
+                repairRequiredErrorCode: `${options.errorPrefix}_repair_required`,
+                reconcileExistingMutation: (mutation) => reconcilePendingReputationMutation({
+                    state: operation.state,
+                    mutation,
+                    provider: execution.provider,
+                    nowUnixMs: execution.nowUnixMs,
+                    paths: execution.paths,
+                    rpc: execution.rpc,
+                    walletName: execution.walletName,
+                    context: execution.readContext,
+                }),
+                createReuseResult: ({ mutation, resolution, fees }) => createReputationReuseResult({
+                    kind: options.kind,
+                    operation,
+                    amountCogtoshi: options.amountCogtoshi,
+                    mutation,
+                    resolution,
+                    fees,
+                }),
+            });
+        },
+        async confirm({ operation }) {
+            await confirmReputationMutation(options.prompter, {
+                kind: options.kind === "rep-give" ? "give" : "revoke",
+                sourceDomainName: operation.normalizedSourceDomainName,
+                targetDomainName: operation.normalizedTargetDomainName,
+                amountCogtoshi: options.amountCogtoshi,
+                reviewText: operation.review.text,
+                resolved: operation.resolved,
+                assumeYes: options.assumeYes,
+            });
+        },
+        createDraftMutation({ operation, existingMutation, execution, intentFingerprintHex }) {
+            return {
+                mutation: createReputationDraftMutation({
+                    kind: options.kind,
+                    sourceDomainName: operation.normalizedSourceDomainName,
+                    targetDomainName: operation.normalizedTargetDomainName,
+                    amountCogtoshi: options.amountCogtoshi,
+                    sender: operation.sender,
+                    intentFingerprintHex,
+                    nowUnixMs: execution.nowUnixMs,
+                    reviewPayloadHex: operation.review.payloadHex,
+                    feeSelection: execution.feeSelection,
+                    existing: existingMutation,
+                }),
+                prepared: null,
+            };
+        },
+        async build({ operation, state, execution, replacementFixedInputs }) {
+            const reputationPlan = buildPlanForReputationOperation({
+                state,
+                allUtxos: await execution.rpc.listUnspent(execution.walletName, 1),
+                sender: operation.sender,
+                opReturnData: createReputationOpReturnData({
+                    kind: options.kind,
+                    operation,
+                    amountCogtoshi: options.amountCogtoshi,
+                }),
+                errorPrefix: options.errorPrefix,
+            });
+            return buildReputationTransaction({
+                rpc: execution.rpc,
+                walletName: execution.walletName,
+                state,
+                plan: {
+                    ...reputationPlan,
+                    fixedInputs: mergeFixedWalletInputs(reputationPlan.fixedInputs, replacementFixedInputs),
+                },
+                feeRateSatVb: execution.feeSelection.feeRateSatVb,
+            });
+        },
+        publish({ state, execution, built, mutation }) {
+            return publishWalletMutation({
+                rpc: execution.rpc,
+                walletName: execution.walletName,
+                snapshotHeight: execution.readContext.snapshot?.tip?.height ?? null,
+                built,
+                mutation,
+                state,
+                provider: execution.provider,
+                nowUnixMs: execution.nowUnixMs,
+                paths: execution.paths,
+                errorPrefix: options.errorPrefix,
+            });
+        },
+        createResult({ operation, mutation, built, status, reusedExisting, fees }) {
+            return createReputationResult({
+                kind: options.kind,
+                operation,
+                amountCogtoshi: options.amountCogtoshi,
+                mutation,
+                builtTxid: built?.txid ?? null,
+                status: status,
+                reusedExisting,
+                fees,
+            });
+        },
+    });
+    return execution.result;
+}
+export async function giveReputation(options) {
+    return submitReputationMutation({
+        ...options,
+        kind: "rep-give",
+        errorPrefix: "wallet_rep_give",
+    });
+}
+export async function revokeReputation(options) {
+    return submitReputationMutation({
+        ...options,
+        kind: "rep-revoke",
+        errorPrefix: "wallet_rep_revoke",
+    });
+}

package/dist/wallet/tx/reputation/intent.d.ts

@@ -0,0 +1,36 @@
+import { type MutationSender } from "../common.js";
+import type { ReadyWalletReadContext, ReputationMutationKind, ReputationOperation, ReputationResolvedEffect, ReputationResolvedReviewSummary, ReputationResolvedSenderSummary, ReputationResolvedSummary, ReputationReview, StandaloneReputationOperation } from "./types.js";
+export declare function normalizeReputationDomainName(domainName: string, errorCode: string): string;
+export declare function createReputationIntentFingerprint(parts: Array<string | number | bigint>): string;
+export declare function createResolvedReputationSenderSummary(sender: MutationSender, selector: string): ReputationResolvedSenderSummary;
+export declare function createResolvedReputationSummary(options: {
+    kind: "give" | "revoke";
+    sender: MutationSender;
+    senderSelector: string;
+    amountCogtoshi: bigint;
+    review: ReputationReview;
+    selfStake: boolean;
+}): ReputationResolvedSummary;
+export declare function describeReputationEffect(effect: ReputationResolvedEffect): string;
+export declare function describeReputationReview(review: ReputationResolvedReviewSummary): string;
+export declare function resolveReputationOperation(context: ReadyWalletReadContext, sourceDomainName: string, targetDomainName: string, errorPrefix: string): ReputationOperation;
+export declare function encodeReputationReviewText(reviewText: string | null | undefined, errorPrefix: string): Promise<ReputationReview>;
+export declare function resolveStandaloneReputationOperation(options: {
+    readContext: ReadyWalletReadContext;
+    sourceDomainName: string;
+    targetDomainName: string;
+    amountCogtoshi: bigint;
+    reviewText: string | null | undefined;
+    kind: ReputationMutationKind;
+    errorPrefix: string;
+}): Promise<StandaloneReputationOperation>;
+export declare function createStandaloneReputationFingerprint(options: {
+    kind: ReputationMutationKind;
+    operation: StandaloneReputationOperation;
+    amountCogtoshi: bigint;
+}): string;
+export declare function createReputationOpReturnData(options: {
+    kind: ReputationMutationKind;
+    operation: StandaloneReputationOperation;
+    amountCogtoshi: bigint;
+}): Uint8Array;

package/dist/wallet/tx/reputation/intent.js

@@ -0,0 +1,157 @@
+import { createHash } from "node:crypto";
+import { encodeSentence } from "@cogcoin/scoring";
+import { getBalance, lookupDomain, } from "@cogcoin/indexer/queries";
+import { serializeRepCommit, serializeRepRevoke, validateDomainName, } from "../../cogop/index.js";
+import { assertWalletMutationContextReady, createFundingMutationSender, } from "../common.js";
+function createSupportKey(sourceDomainId, targetDomainId) {
+    return `${sourceDomainId}:${targetDomainId}`;
+}
+export function normalizeReputationDomainName(domainName, errorCode) {
+    const normalized = domainName.trim().toLowerCase();
+    if (normalized.length === 0) {
+        throw new Error(errorCode);
+    }
+    validateDomainName(normalized);
+    return normalized;
+}
+export function createReputationIntentFingerprint(parts) {
+    return createHash("sha256")
+        .update(parts.map((part) => String(part)).join("\n"))
+        .digest("hex");
+}
+export function createResolvedReputationSenderSummary(sender, selector) {
+    return {
+        selector,
+        localIndex: sender.localIndex,
+        scriptPubKeyHex: sender.scriptPubKeyHex,
+        address: sender.address,
+    };
+}
+export function createResolvedReputationSummary(options) {
+    return {
+        sender: createResolvedReputationSenderSummary(options.sender, options.senderSelector),
+        effect: options.kind === "give"
+            ? {
+                kind: "give-support",
+                burnCogtoshi: options.amountCogtoshi.toString(),
+            }
+            : {
+                kind: "revoke-support",
+                burnCogtoshi: options.amountCogtoshi.toString(),
+            },
+        review: {
+            included: options.review.payloadHex !== null,
+            byteLength: options.review.payload?.length ?? null,
+        },
+        selfStake: options.selfStake,
+    };
+}
+export function describeReputationEffect(effect) {
+    if (effect.kind === "give-support") {
+        return `burn ${effect.burnCogtoshi} cogtoshi to publish support`;
+    }
+    return `revoke visible support with no refund of the previously burned ${effect.burnCogtoshi} cogtoshi`;
+}
+export function describeReputationReview(review) {
+    if (!review.included || review.byteLength === null) {
+        return "none";
+    }
+    return `included (${review.byteLength} bytes)`;
+}
+export function resolveReputationOperation(context, sourceDomainName, targetDomainName, errorPrefix) {
+    assertWalletMutationContextReady(context, errorPrefix);
+    const sourceDomain = lookupDomain(context.snapshot.state, sourceDomainName);
+    if (sourceDomain === null) {
+        throw new Error(`${errorPrefix}_source_domain_not_found`);
+    }
+    if (!sourceDomain.anchored) {
+        throw new Error(`${errorPrefix}_source_domain_not_anchored`);
+    }
+    const targetDomain = lookupDomain(context.snapshot.state, targetDomainName);
+    if (targetDomain === null) {
+        throw new Error(`${errorPrefix}_target_domain_not_found`);
+    }
+    if (!targetDomain.anchored) {
+        throw new Error(`${errorPrefix}_target_domain_not_anchored`);
+    }
+    const ownerHex = Buffer.from(sourceDomain.ownerScriptPubKey).toString("hex");
+    if (ownerHex !== context.localState.state.funding.scriptPubKeyHex || context.model.walletAddress == null) {
+        throw new Error(`${errorPrefix}_source_owner_not_locally_controlled`);
+    }
+    return {
+        readContext: context,
+        state: context.localState.state,
+        sender: createFundingMutationSender(context.localState.state),
+        senderSelector: context.model.walletAddress,
+        sourceDomain,
+        targetDomain,
+        availableBalanceCogtoshi: getBalance(context.snapshot.state, sourceDomain.ownerScriptPubKey),
+        currentNetSupportCogtoshi: context.snapshot.state.consensus.supportByPair.get(createSupportKey(sourceDomain.domainId, targetDomain.domainId)) ?? 0n,
+    };
+}
+export async function encodeReputationReviewText(reviewText, errorPrefix) {
+    const trimmed = reviewText?.trim() ?? "";
+    if (trimmed === "") {
+        return {
+            text: null,
+            payload: undefined,
+            payloadHex: null,
+        };
+    }
+    return encodeSentence(trimmed)
+        .then((payload) => ({
+        text: trimmed,
+        payload,
+        payloadHex: Buffer.from(payload).toString("hex"),
+    }))
+        .catch((error) => {
+        throw new Error(error instanceof Error ? `${errorPrefix}_invalid_review_${error.message}` : `${errorPrefix}_invalid_review`);
+    });
+}
+export async function resolveStandaloneReputationOperation(options) {
+    const normalizedSourceDomainName = normalizeReputationDomainName(options.sourceDomainName, `${options.errorPrefix}_missing_source_domain`);
+    const normalizedTargetDomainName = normalizeReputationDomainName(options.targetDomainName, `${options.errorPrefix}_missing_target_domain`);
+    const operation = resolveReputationOperation(options.readContext, normalizedSourceDomainName, normalizedTargetDomainName, options.errorPrefix);
+    if (operation.availableBalanceCogtoshi < options.amountCogtoshi) {
+        throw new Error(`${options.errorPrefix}_insufficient_cog_balance`);
+    }
+    if (options.kind === "rep-revoke") {
+        if (operation.sourceDomain.domainId === operation.targetDomain.domainId) {
+            throw new Error(`${options.errorPrefix}_self_revoke_not_allowed`);
+        }
+        if (options.amountCogtoshi > operation.currentNetSupportCogtoshi) {
+            throw new Error(`${options.errorPrefix}_amount_exceeds_net_support`);
+        }
+    }
+    const review = await encodeReputationReviewText(options.reviewText, options.errorPrefix);
+    const selfStake = operation.sourceDomain.domainId === operation.targetDomain.domainId;
+    return {
+        ...operation,
+        normalizedSourceDomainName,
+        normalizedTargetDomainName,
+        review,
+        resolved: createResolvedReputationSummary({
+            kind: options.kind === "rep-give" ? "give" : "revoke",
+            sender: operation.sender,
+            senderSelector: operation.senderSelector,
+            amountCogtoshi: options.amountCogtoshi,
+            review,
+            selfStake,
+        }),
+    };
+}
+export function createStandaloneReputationFingerprint(options) {
+    return createReputationIntentFingerprint([
+        options.kind,
+        options.operation.state.walletRootId,
+        options.operation.sourceDomain.name,
+        options.operation.targetDomain.name,
+        options.amountCogtoshi,
+        options.operation.review.payloadHex ?? "",
+    ]);
+}
+export function createReputationOpReturnData(options) {
+    return options.kind === "rep-give"
+        ? serializeRepCommit(options.operation.sourceDomain.domainId, options.operation.targetDomain.domainId, options.amountCogtoshi, options.operation.review.payload).opReturnData
+        : serializeRepRevoke(options.operation.sourceDomain.domainId, options.operation.targetDomain.domainId, options.amountCogtoshi, options.operation.review.payload).opReturnData;
+}

package/dist/wallet/tx/reputation/plan.d.ts

@@ -0,0 +1,19 @@
+import type { RpcDecodedPsbt, RpcListUnspentEntry } from "../../../bitcoind/types.js";
+import type { BuiltReputationTransaction, ReputationPlan, ReputationRpcClient } from "./types.js";
+import type { WalletStateV1 } from "../../types.js";
+import type { MutationSender } from "../common.js";
+export declare function buildPlanForReputationOperation(options: {
+    state: WalletStateV1;
+    allUtxos: RpcListUnspentEntry[];
+    sender: MutationSender;
+    opReturnData: Uint8Array;
+    errorPrefix: string;
+}): ReputationPlan;
+export declare function validateFundedReputationDraft(decoded: RpcDecodedPsbt, funded: BuiltReputationTransaction["funded"], plan: ReputationPlan): void;
+export declare function buildReputationTransaction(options: {
+    rpc: ReputationRpcClient;
+    walletName: string;
+    state: WalletStateV1;
+    plan: ReputationPlan;
+    feeRateSatVb: number;
+}): Promise<BuiltReputationTransaction>;

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

@@ -0,0 +1,64 @@
+import { buildWalletMutationTransactionWithReserveFallback, outpointKey, } from "../common.js";
+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 buildPlanForReputationOperation(options) {
+    const fundingUtxos = options.allUtxos.filter((entry) => entry.scriptPubKey === options.state.funding.scriptPubKeyHex
+        && entry.confirmations >= 1
+        && entry.spendable !== false
+        && entry.safe !== false);
+    return {
+        sender: options.sender,
+        changeAddress: options.state.funding.address,
+        fixedInputs: [],
+        outputs: [{ data: Buffer.from(options.opReturnData).toString("hex") }],
+        changePosition: 1,
+        expectedOpReturnScriptHex: encodeOpReturnScript(options.opReturnData),
+        allowedFundingScriptPubKeyHex: options.state.funding.scriptPubKeyHex,
+        eligibleFundingOutpointKeys: new Set(fundingUtxos.map((entry) => outpointKey({ txid: entry.txid, vout: entry.vout }))),
+        errorPrefix: options.errorPrefix,
+    };
+}
+export function validateFundedReputationDraft(decoded, funded, plan) {
+    const inputs = decoded.tx.vin;
+    const outputs = decoded.tx.vout;
+    if (inputs.length === 0) {
+        throw new Error(`${plan.errorPrefix}_missing_sender_input`);
+    }
+    if (outputs[0]?.scriptPubKey?.hex !== plan.expectedOpReturnScriptHex) {
+        throw new Error(`${plan.errorPrefix}_opreturn_mismatch`);
+    }
+    if (funded.changepos === -1) {
+        if (outputs.length !== 1) {
+            throw new Error(`${plan.errorPrefix}_unexpected_output_count`);
+        }
+        return;
+    }
+    if (funded.changepos !== plan.changePosition || outputs.length !== 2) {
+        throw new Error(`${plan.errorPrefix}_change_position_mismatch`);
+    }
+    if (outputs[funded.changepos]?.scriptPubKey?.hex !== plan.allowedFundingScriptPubKeyHex) {
+        throw new Error(`${plan.errorPrefix}_change_output_mismatch`);
+    }
+}
+export async function buildReputationTransaction(options) {
+    return buildWalletMutationTransactionWithReserveFallback({
+        rpc: options.rpc,
+        walletName: options.walletName,
+        state: options.state,
+        plan: options.plan,
+        validateFundedDraft: validateFundedReputationDraft,
+        finalizeErrorCode: `${options.plan.errorPrefix}_finalize_failed`,
+        mempoolRejectPrefix: `${options.plan.errorPrefix}_mempool_rejected`,
+        feeRate: options.feeRateSatVb,
+    });
+}