@cogcoin/client 0.5.0

package/dist/wallet/tx/identity-selector.d.ts

@@ -0,0 +1,12 @@
+import type { WalletReadContext } from "../read/index.js";
+type ReadyWalletMutationContext = WalletReadContext & {
+    localState: {
+        availability: "ready";
+    };
+    snapshot: NonNullable<WalletReadContext["snapshot"]>;
+    model: NonNullable<WalletReadContext["model"]>;
+};
+type ResolvedIdentity = ReadyWalletMutationContext["model"]["identities"][number];
+export declare function getCanonicalIdentitySelector(identity: ResolvedIdentity): string;
+export declare function resolveIdentityBySelector(context: ReadyWalletMutationContext, selector: string, errorPrefix: string): ResolvedIdentity;
+export {};

package/dist/wallet/tx/identity-selector.js

@@ -0,0 +1,52 @@
+import { serializeDomainReg } from "../cogop/index.js";
+function normalizeDomainName(value, errorCode) {
+    const normalized = value.trim().toLowerCase();
+    if (normalized.length === 0) {
+        throw new Error(errorCode);
+    }
+    serializeDomainReg(normalized);
+    return normalized;
+}
+export function getCanonicalIdentitySelector(identity) {
+    return identity.selectors.find((selector) => selector.startsWith("id:")) ?? `id:${identity.index}`;
+}
+export function resolveIdentityBySelector(context, selector, errorPrefix) {
+    const trimmed = selector.trim();
+    if (trimmed === "") {
+        throw new Error(`${errorPrefix}_sender_selector_missing`);
+    }
+    if (trimmed.startsWith("id:")) {
+        const index = Number.parseInt(trimmed.slice(3), 10);
+        const identity = context.model.identities.find((entry) => entry.index === index) ?? null;
+        if (identity === null) {
+            throw new Error(`${errorPrefix}_sender_not_found`);
+        }
+        return identity;
+    }
+    if (trimmed.startsWith("domain:")) {
+        const domainName = normalizeDomainName(trimmed.slice(7), `${errorPrefix}_sender_selector_invalid_domain`);
+        const domain = context.model.domains.find((entry) => entry.name === domainName) ?? null;
+        if (domain === null || domain.ownerLocalIndex === null) {
+            throw new Error(`${errorPrefix}_sender_not_found`);
+        }
+        const identity = context.model.identities.find((entry) => entry.index === domain.ownerLocalIndex) ?? null;
+        if (identity === null) {
+            throw new Error(`${errorPrefix}_sender_not_found`);
+        }
+        return identity;
+    }
+    if (trimmed.startsWith("spk:")) {
+        const scriptPubKeyHex = trimmed.slice(4).toLowerCase();
+        const identity = context.model.identities.find((entry) => entry.scriptPubKeyHex === scriptPubKeyHex) ?? null;
+        if (identity === null) {
+            throw new Error(`${errorPrefix}_sender_not_found`);
+        }
+        return identity;
+    }
+    const normalizedAddress = trimmed.toLowerCase();
+    const identity = context.model.identities.find((entry) => entry.address?.toLowerCase() === normalizedAddress) ?? null;
+    if (identity === null) {
+        throw new Error(`${errorPrefix}_sender_not_found`);
+    }
+    return identity;
+}

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

@@ -0,0 +1,7 @@
+export { extractOpReturnPayloadFromScriptHex, registerDomain, type RegisterDomainResult, } from "./register.js";
+export { buyDomain, parseCogAmountToCogtoshi, sellDomain, transferDomain, type DomainMarketMutationResult, } from "./domain-market.js";
+export { claimCogLock, lockCogToDomain, reclaimCogLock, sendCog, type CogMutationResult, } from "./cog.js";
+export { anchorDomain, type AnchorDomainResult, } from "./anchor.js";
+export { clearDomainDelegate, clearDomainEndpoint, clearDomainMiner, setDomainCanonical, setDomainDelegate, setDomainEndpoint, setDomainMiner, type DomainAdminMutationResult, } from "./domain-admin.js";
+export { clearField, createField, setField, type ClearFieldOptions, type CreateFieldOptions, type FieldMutationResult, type FieldValueInputSource, type SetFieldOptions, } from "./field.js";
+export { giveReputation, revokeReputation, type GiveReputationOptions, type ReputationMutationResult, type RevokeReputationOptions, } from "./reputation.js";

package/dist/wallet/tx/index.js

@@ -0,0 +1,7 @@
+export { extractOpReturnPayloadFromScriptHex, registerDomain, } from "./register.js";
+export { buyDomain, parseCogAmountToCogtoshi, sellDomain, transferDomain, } from "./domain-market.js";
+export { claimCogLock, lockCogToDomain, reclaimCogLock, sendCog, } from "./cog.js";
+export { anchorDomain, } from "./anchor.js";
+export { clearDomainDelegate, clearDomainEndpoint, clearDomainMiner, setDomainCanonical, setDomainDelegate, setDomainEndpoint, setDomainMiner, } from "./domain-admin.js";
+export { clearField, createField, setField, } from "./field.js";
+export { giveReputation, revokeReputation, } from "./reputation.js";

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

@@ -0,0 +1,5 @@
+import type { PendingMutationRecord, WalletStateV1 } from "../types.js";
+export declare function getPendingMutations(state: WalletStateV1): PendingMutationRecord[];
+export declare function listActivePendingMutations(state: WalletStateV1): PendingMutationRecord[];
+export declare function findPendingMutationByIntent(state: WalletStateV1, intentFingerprintHex: string): PendingMutationRecord | null;
+export declare function upsertPendingMutation(state: WalletStateV1, mutation: PendingMutationRecord): WalletStateV1;

package/dist/wallet/tx/journal.js

@@ -0,0 +1,31 @@
+const ACTIVE_MUTATION_STATUSES = new Set([
+    "draft",
+    "broadcasting",
+    "broadcast-unknown",
+    "live",
+    "repair-required",
+]);
+export function getPendingMutations(state) {
+    return state.pendingMutations ?? [];
+}
+export function listActivePendingMutations(state) {
+    return getPendingMutations(state).filter((mutation) => ACTIVE_MUTATION_STATUSES.has(mutation.status));
+}
+export function findPendingMutationByIntent(state, intentFingerprintHex) {
+    return getPendingMutations(state).find((mutation) => mutation.intentFingerprintHex === intentFingerprintHex) ?? null;
+}
+export function upsertPendingMutation(state, mutation) {
+    const pendingMutations = getPendingMutations(state);
+    const existingIndex = pendingMutations.findIndex((entry) => entry.mutationId === mutation.mutationId);
+    const nextPendingMutations = pendingMutations.slice();
+    if (existingIndex >= 0) {
+        nextPendingMutations[existingIndex] = mutation;
+    }
+    else {
+        nextPendingMutations.push(mutation);
+    }
+    return {
+        ...state,
+        pendingMutations: nextPendingMutations,
+    };
+}

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

@@ -0,0 +1,68 @@
+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 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;
+}
+export interface RegisterDomainOptions {
+    domainName: string;
+    fromIdentity?: string | 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 {};