@cogcoin/client 0.5.0

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

@@ -0,0 +1,7 @@
+export interface NormalizedBtcTarget {
+    scriptPubKeyHex: string;
+    address: string | null;
+    opaque: boolean;
+}
+export declare function renderScriptPubKeyAsAddress(scriptPubKeyHex: string): string | null;
+export declare function normalizeBtcTarget(target: string): NormalizedBtcTarget;

package/dist/wallet/tx/targets.js

@@ -0,0 +1,122 @@
+import { createHash } from "node:crypto";
+import { base58, bech32, bech32m } from "@scure/base";
+import { validateExternalScriptPubKey } from "../cogop/index.js";
+const BASE58CHECK_P2PKH_MAINNET = 0x00;
+const BASE58CHECK_P2SH_MAINNET = 0x05;
+const BECH32_HRP_MAINNET = "bc";
+function sha256(value) {
+    return createHash("sha256").update(value).digest();
+}
+function checksum4(value) {
+    return sha256(sha256(value)).subarray(0, 4);
+}
+function encodeBase58Check(version, payload) {
+    const body = Buffer.concat([Buffer.from([version]), Buffer.from(payload)]);
+    return base58.encode(Buffer.concat([body, Buffer.from(checksum4(body))]));
+}
+function decodeBase58Check(value) {
+    const decoded = Buffer.from(base58.decode(value));
+    if (decoded.length < 5) {
+        throw new Error("wallet_target_invalid_address");
+    }
+    const body = decoded.subarray(0, decoded.length - 4);
+    const actualChecksum = decoded.subarray(decoded.length - 4);
+    const expectedChecksum = checksum4(body);
+    if (!Buffer.from(expectedChecksum).equals(actualChecksum)) {
+        throw new Error("wallet_target_invalid_address");
+    }
+    return {
+        version: body[0],
+        payload: body.subarray(1),
+    };
+}
+function encodeWitnessAddress(version, program) {
+    const words = [version, ...bech32.toWords(program)];
+    return version === 0
+        ? bech32.encode(BECH32_HRP_MAINNET, words)
+        : bech32m.encode(BECH32_HRP_MAINNET, words);
+}
+function buildWitnessScript(version, program) {
+    const versionOpcode = version === 0 ? 0x00 : 0x50 + version;
+    return Buffer.concat([Buffer.from([versionOpcode, program.length]), Buffer.from(program)]).toString("hex");
+}
+function tryDecodeWitnessAddress(value) {
+    for (const codec of [bech32, bech32m]) {
+        try {
+            const decoded = codec.decode(value);
+            if (decoded.prefix !== BECH32_HRP_MAINNET || decoded.words.length === 0) {
+                continue;
+            }
+            const version = decoded.words[0];
+            const program = Buffer.from(codec.fromWords(decoded.words.slice(1)));
+            if (version < 0 || version > 16 || program.length < 2 || program.length > 40) {
+                continue;
+            }
+            if (version === 0 && program.length !== 20 && program.length !== 32) {
+                continue;
+            }
+            return buildWitnessScript(version, program);
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+function decodeAddressToScriptPubKeyHex(address) {
+    const witnessScriptHex = tryDecodeWitnessAddress(address);
+    if (witnessScriptHex !== null) {
+        return witnessScriptHex;
+    }
+    const decoded = decodeBase58Check(address);
+    if (decoded.version === BASE58CHECK_P2PKH_MAINNET && decoded.payload.length === 20) {
+        return `76a914${Buffer.from(decoded.payload).toString("hex")}88ac`;
+    }
+    if (decoded.version === BASE58CHECK_P2SH_MAINNET && decoded.payload.length === 20) {
+        return `a914${Buffer.from(decoded.payload).toString("hex")}87`;
+    }
+    throw new Error("wallet_target_invalid_address");
+}
+export function renderScriptPubKeyAsAddress(scriptPubKeyHex) {
+    if (/^0014[0-9a-f]{40}$/i.test(scriptPubKeyHex)) {
+        return encodeWitnessAddress(0, Buffer.from(scriptPubKeyHex.slice(4), "hex"));
+    }
+    if (/^0020[0-9a-f]{64}$/i.test(scriptPubKeyHex)) {
+        return encodeWitnessAddress(0, Buffer.from(scriptPubKeyHex.slice(4), "hex"));
+    }
+    if (/^5120[0-9a-f]{64}$/i.test(scriptPubKeyHex)) {
+        return encodeWitnessAddress(1, Buffer.from(scriptPubKeyHex.slice(4), "hex"));
+    }
+    if (/^76a914[0-9a-f]{40}88ac$/i.test(scriptPubKeyHex)) {
+        return encodeBase58Check(BASE58CHECK_P2PKH_MAINNET, Buffer.from(scriptPubKeyHex.slice(6, -4), "hex"));
+    }
+    if (/^a914[0-9a-f]{40}87$/i.test(scriptPubKeyHex)) {
+        return encodeBase58Check(BASE58CHECK_P2SH_MAINNET, Buffer.from(scriptPubKeyHex.slice(4, -2), "hex"));
+    }
+    return null;
+}
+export function normalizeBtcTarget(target) {
+    const trimmed = target.trim();
+    if (trimmed === "") {
+        throw new Error("wallet_target_missing");
+    }
+    if (trimmed.startsWith("spk:")) {
+        const scriptPubKeyHex = trimmed.slice(4).toLowerCase();
+        if (!/^[0-9a-f]+$/.test(scriptPubKeyHex) || scriptPubKeyHex.length % 2 !== 0) {
+            throw new Error("wallet_target_invalid_script");
+        }
+        validateExternalScriptPubKey(Buffer.from(scriptPubKeyHex, "hex"));
+        return {
+            scriptPubKeyHex,
+            address: renderScriptPubKeyAsAddress(scriptPubKeyHex),
+            opaque: renderScriptPubKeyAsAddress(scriptPubKeyHex) === null,
+        };
+    }
+    const scriptPubKeyHex = decodeAddressToScriptPubKeyHex(trimmed).toLowerCase();
+    validateExternalScriptPubKey(Buffer.from(scriptPubKeyHex, "hex"));
+    return {
+        scriptPubKeyHex,
+        address: trimmed,
+        opaque: false,
+    };
+}

package/dist/wallet/types.d.ts

@@ -0,0 +1,249 @@
+export type WalletNetwork = "mainnet";
+export type ScriptPubKeyHex = string;
+export type WalletMnemonicLanguage = "english";
+export interface OutpointRecord {
+    txid: string;
+    vout: number;
+}
+export type PendingMutationStatus = "draft" | "broadcasting" | "broadcast-unknown" | "live" | "confirmed" | "canceled" | "repair-required";
+export interface PendingMutationRecord {
+    mutationId: string;
+    kind: "register" | "transfer" | "sell" | "buy" | "rep-give" | "rep-revoke" | "send" | "lock" | "claim" | "field-create" | "field-set" | "field-clear" | "endpoint" | "delegate" | "miner" | "canonical";
+    registerKind?: "root" | "subdomain";
+    domainName: string;
+    parentDomainName: string | null;
+    senderScriptPubKeyHex: ScriptPubKeyHex;
+    senderLocalIndex: number | null;
+    recipientScriptPubKeyHex?: ScriptPubKeyHex | null;
+    endpointValueHex?: string | null;
+    priceCogtoshi?: bigint | null;
+    amountCogtoshi?: bigint | null;
+    recipientDomainName?: string | null;
+    reviewPayloadHex?: string | null;
+    timeoutHeight?: number | null;
+    conditionHex?: string | null;
+    lockId?: number | null;
+    preimageHex?: string | null;
+    fieldName?: string | null;
+    fieldId?: number | null;
+    fieldPermanent?: boolean | null;
+    fieldFormat?: number | null;
+    fieldValueHex?: string | null;
+    intentFingerprintHex: string;
+    status: PendingMutationStatus;
+    createdAtUnixMs: number;
+    lastUpdatedAtUnixMs: number;
+    attemptedTxid: string | null;
+    attemptedWtxid: string | null;
+    temporaryBuilderLockedOutpoints: OutpointRecord[];
+}
+export interface LocalIdentityRecord {
+    index: number;
+    scriptPubKeyHex: ScriptPubKeyHex;
+    address: string | null;
+    status: "funding" | "dedicated" | "read-only";
+    assignedDomainNames: string[];
+}
+export interface DomainRecord {
+    name: string;
+    domainId: number | null;
+    dedicatedIndex: number | null;
+    currentOwnerScriptPubKeyHex: ScriptPubKeyHex | null;
+    currentOwnerLocalIndex: number | null;
+    canonicalChainStatus: "unknown" | "registered-unanchored" | "anchored";
+    localAnchorIntent: "none" | "reserved" | "tx1-live" | "tx2-live" | "repair-required";
+    currentCanonicalAnchorOutpoint: {
+        txid: string;
+        vout: number;
+        valueSats: number;
+    } | null;
+    foundingMessageText: string | null;
+    birthTime: number | null;
+}
+export interface HookClientStateRecord {
+    mode: "builtin" | "custom" | "disabled";
+    validationState: "unknown" | "validated" | "stale" | "failed" | "never" | "current";
+    lastValidationAtUnixMs: number | null;
+    lastValidationError: string | null;
+    validatedLaunchFingerprint: string | null;
+    validatedFullFingerprint: string | null;
+    fullTrustWarningAcknowledgedAtUnixMs: number | null;
+    consecutiveFailureCount: number;
+    cooldownUntilUnixMs: number | null;
+}
+export interface MiningStateRecord {
+    runMode: "stopped" | "foreground" | "background";
+    state: "idle" | "live" | "paused" | "paused-stale" | "repair-required";
+    pauseReason: string | null;
+    currentPublishState: "none" | "broadcasting" | "broadcast-unknown" | "in-mempool";
+    currentDomain: string | null;
+    currentDomainId: number | null;
+    currentDomainIndex: number | null;
+    currentSenderScriptPubKeyHex: ScriptPubKeyHex | null;
+    currentTxid: string | null;
+    currentWtxid: string | null;
+    currentFeeRateSatVb: number | null;
+    currentAbsoluteFeeSats: number | null;
+    currentScore: string | null;
+    currentSentence: string | null;
+    currentEncodedSentenceBytesHex: string | null;
+    currentBip39WordIndices: number[] | null;
+    currentBlendSeedHex: string | null;
+    currentBlockTargetHeight: number | null;
+    currentReferencedBlockHashDisplay: string | null;
+    currentIntentFingerprintHex: string | null;
+    liveMiningFamilyInMempool: boolean | null;
+    currentPublishDecision: string | null;
+    replacementCount: number;
+    currentBlockFeeSpentSats: string;
+    sessionFeeSpentSats: string;
+    lifetimeFeeSpentSats: string;
+    sharedMiningConflictOutpoint: {
+        txid: string;
+        vout: number;
+    } | null;
+}
+export interface ProactiveFamilyTransactionRecord {
+    status: "draft" | "broadcasting" | "broadcast-unknown" | "live" | "confirmed" | "canceled" | "repair-required";
+    attemptedTxid: string | null;
+    attemptedWtxid: string | null;
+    temporaryBuilderLockedOutpoints: OutpointRecord[];
+    rawHex: string | null;
+}
+export interface ProactiveFamilyStateRecord {
+    familyId: string;
+    type: "anchor" | "field" | string;
+    status: "draft" | "broadcasting" | "broadcast-unknown" | "live" | "confirmed" | "canceled" | "repair-required";
+    intentFingerprintHex: string;
+    createdAtUnixMs: number;
+    lastUpdatedAtUnixMs?: number;
+    domainName?: string | null;
+    domainId?: number | null;
+    sourceSenderLocalIndex?: number | null;
+    sourceSenderScriptPubKeyHex?: ScriptPubKeyHex | null;
+    reservedDedicatedIndex?: number | null;
+    reservedScriptPubKeyHex?: ScriptPubKeyHex | null;
+    foundingMessageText?: string | null;
+    foundingMessagePayloadHex?: string | null;
+    listingCancelCommitted?: boolean;
+    fieldName?: string | null;
+    expectedFieldId?: number | null;
+    fieldPermanent?: boolean | null;
+    fieldFormat?: number | null;
+    fieldValueHex?: string | null;
+    currentStep?: "reserved" | "tx1" | "tx2" | null;
+    tx1?: ProactiveFamilyTransactionRecord | null;
+    tx2?: ProactiveFamilyTransactionRecord | null;
+}
+export interface WalletStateV1 {
+    schemaVersion: 1;
+    stateRevision: number;
+    lastWrittenAtUnixMs: number;
+    walletRootId: string;
+    network: WalletNetwork;
+    anchorValueSats: number;
+    nextDedicatedIndex: number;
+    fundingIndex: 0;
+    mnemonic: {
+        phrase: string;
+        language: WalletMnemonicLanguage;
+    };
+    keys: {
+        masterFingerprintHex: string;
+        accountPath: string;
+        accountXprv: string;
+        accountXpub: string;
+    };
+    descriptor: {
+        privateExternal: string;
+        publicExternal: string;
+        checksum: string | null;
+        rangeEnd: number;
+        safetyMargin: number;
+    };
+    funding: {
+        address: string;
+        scriptPubKeyHex: ScriptPubKeyHex;
+    };
+    walletBirthTime: number;
+    managedCoreWallet: {
+        walletName: string;
+        internalPassphrase: string;
+        descriptorChecksum: string | null;
+        fundingAddress0: string | null;
+        fundingScriptPubKeyHex0: ScriptPubKeyHex | null;
+        proofStatus: "not-proven" | "ready" | "missing" | "mismatch";
+        lastImportedAtUnixMs: number | null;
+        lastVerifiedAtUnixMs: number | null;
+    };
+    identities: LocalIdentityRecord[];
+    domains: DomainRecord[];
+    miningState: MiningStateRecord;
+    hookClientState: {
+        mining: HookClientStateRecord;
+    };
+    proactiveFamilies: ProactiveFamilyStateRecord[];
+    pendingMutations?: PendingMutationRecord[];
+}
+export interface PortableWalletArchivePayloadV1 {
+    schemaVersion: 1;
+    exportedAtUnixMs: number;
+    walletRootId: string;
+    network: WalletNetwork;
+    anchorValueSats: number;
+    nextDedicatedIndex: number;
+    fundingIndex: 0;
+    mnemonic: {
+        phrase: string;
+        language: WalletMnemonicLanguage;
+    };
+    expected: {
+        masterFingerprintHex: string;
+        accountPath: string;
+        accountXpub: string;
+        publicExternalDescriptor: string;
+        descriptorChecksum: string | null;
+        rangeEnd: number;
+        safetyMargin: number;
+        fundingAddress0: string;
+        fundingScriptPubKeyHex0: ScriptPubKeyHex;
+        walletBirthTime: number;
+    };
+    identities: LocalIdentityRecord[];
+    domains: DomainRecord[];
+    miningState: MiningStateRecord;
+    hookClientState: {
+        mining: HookClientStateRecord;
+    };
+    proactiveFamilies: ProactiveFamilyStateRecord[];
+}
+export interface Argon2EnvelopeParams {
+    name: "argon2id";
+    memoryKib: number;
+    iterations: number;
+    parallelism: number;
+    salt: string;
+}
+export interface EncryptedEnvelopeV1 {
+    format: string;
+    version: 1;
+    cipher: "aes-256-gcm";
+    wrappedBy: string;
+    argon2id?: Argon2EnvelopeParams | null;
+    secretProvider?: {
+        kind: string;
+        keyId: string;
+    } | null;
+    nonce: string;
+    tag: string;
+    ciphertext: string;
+}
+export interface UnlockSessionStateV1 {
+    schemaVersion: 1;
+    walletRootId: string;
+    sessionId: string;
+    createdAtUnixMs: number;
+    unlockUntilUnixMs: number;
+    sourceStateRevision: number;
+    wrappedSessionKeyMaterial: string;
+}

package/dist/wallet/types.js

@@ -0,0 +1 @@
+export {};