@cogcoin/client 0.5.0

package/dist/sqlite/driver.js

@@ -0,0 +1,98 @@
+import { cloneBytes } from "../bytes.js";
+import { loadBetterSqlite3 } from "./better-sqlite3.js";
+function normalizeValue(value) {
+    if (value instanceof Uint8Array) {
+        return Buffer.from(value);
+    }
+    return value;
+}
+function normalizeRow(row) {
+    if (row === null || row === undefined) {
+        return null;
+    }
+    if (typeof row !== "object" || row === null) {
+        return row;
+    }
+    const next = { ...row };
+    for (const [key, value] of Object.entries(next)) {
+        if (value instanceof Uint8Array) {
+            next[key] = cloneBytes(value);
+        }
+        else if (Buffer.isBuffer(value)) {
+            next[key] = new Uint8Array(value);
+        }
+    }
+    return next;
+}
+function normalizeRows(rows) {
+    return rows.map((row) => normalizeRow(row));
+}
+async function openBetterSqliteDatabase(options) {
+    const BetterSqlite3 = await loadBetterSqlite3();
+    const openOptions = {};
+    if (options.fileMustExist !== undefined) {
+        openOptions.fileMustExist = options.fileMustExist;
+    }
+    if (options.readonly !== undefined) {
+        openOptions.readonly = options.readonly;
+    }
+    const database = new BetterSqlite3(options.filename, openOptions);
+    return {
+        async exec(sql) {
+            database.exec(sql);
+        },
+        async run(sql, params = []) {
+            const statement = database.prepare(sql);
+            const result = statement.run(...params.map(normalizeValue));
+            return {
+                changes: Number(result.changes),
+                lastInsertRowid: result.lastInsertRowid,
+            };
+        },
+        async get(sql, params = []) {
+            const statement = database.prepare(sql);
+            return normalizeRow(statement.get(...params.map(normalizeValue)) ?? null);
+        },
+        async all(sql, params = []) {
+            const statement = database.prepare(sql);
+            return normalizeRows(statement.all(...params.map(normalizeValue)) ?? []);
+        },
+        async transaction(operation) {
+            database.exec("BEGIN IMMEDIATE");
+            try {
+                const result = await operation();
+                database.exec("COMMIT");
+                return result;
+            }
+            catch (error) {
+                database.exec("ROLLBACK");
+                throw error;
+            }
+        },
+        async close() {
+            database.close();
+        },
+    };
+}
+async function applyPragmas(database, pragmas) {
+    const foreignKeys = pragmas?.foreignKeys ?? true;
+    const busyTimeoutMs = pragmas?.busyTimeoutMs ?? 5000;
+    const journalMode = pragmas?.journalMode ?? "WAL";
+    const synchronous = pragmas?.synchronous ?? "FULL";
+    await database.exec(`PRAGMA foreign_keys = ${foreignKeys ? "ON" : "OFF"}`);
+    await database.exec(`PRAGMA busy_timeout = ${busyTimeoutMs}`);
+    await database.get("PRAGMA journal_mode = " + journalMode);
+    await database.exec(`PRAGMA synchronous = ${synchronous}`);
+}
+export async function openSqliteDatabase(options) {
+    const database = await openBetterSqliteDatabase(options);
+    await applyPragmas(database, options.pragmas);
+    return database;
+}
+export async function openReadonlySqliteDatabase(filename) {
+    return openBetterSqliteDatabase({
+        filename,
+        fileMustExist: true,
+        readonly: true,
+    });
+}

package/dist/sqlite/index.d.ts

@@ -0,0 +1,4 @@
+import type { SqliteStoreOptions } from "./types.js";
+export { migrateSqliteStore } from "./migrate.js";
+export type * from "./types.js";
+export declare function openSqliteStore(options: SqliteStoreOptions): Promise<import("../types.js").ClientStoreAdapter>;

package/dist/sqlite/index.js

@@ -0,0 +1,9 @@
+import { createSqliteStoreAdapter } from "./store.js";
+import { openSqliteDatabase } from "./driver.js";
+import { migrateSqliteStore } from "./migrate.js";
+export { migrateSqliteStore } from "./migrate.js";
+export async function openSqliteStore(options) {
+    const database = await openSqliteDatabase(options);
+    await migrateSqliteStore(database);
+    return createSqliteStoreAdapter(database);
+}

package/dist/sqlite/migrate.d.ts

@@ -0,0 +1,2 @@
+import type { SqliteDatabase } from "./driver.js";
+export declare function migrateSqliteStore(database: SqliteDatabase): Promise<void>;

package/dist/sqlite/migrate.js

@@ -0,0 +1,37 @@
+const SCHEMA_VERSION = 1;
+export async function migrateSqliteStore(database) {
+    const versionRow = await database.get("PRAGMA user_version");
+    const currentVersion = versionRow?.user_version ?? 0;
+    if (currentVersion > SCHEMA_VERSION) {
+        throw new Error("sqlite_store_schema_version_unsupported");
+    }
+    if (currentVersion === 0) {
+        await database.transaction(async () => {
+            await database.exec(`
+        CREATE TABLE IF NOT EXISTS meta (
+          key TEXT PRIMARY KEY,
+          value BLOB NOT NULL
+        )
+      `);
+            await database.exec(`
+        CREATE TABLE IF NOT EXISTS checkpoints (
+          height INTEGER PRIMARY KEY,
+          block_hash BLOB NOT NULL,
+          state_bytes BLOB NOT NULL,
+          created_at INTEGER NOT NULL
+        )
+      `);
+            await database.exec(`
+        CREATE TABLE IF NOT EXISTS block_records (
+          height INTEGER PRIMARY KEY,
+          block_hash BLOB NOT NULL UNIQUE,
+          previous_hash BLOB NOT NULL,
+          record_bytes BLOB NOT NULL,
+          state_hash_hex TEXT NOT NULL,
+          created_at INTEGER NOT NULL
+        )
+      `);
+            await database.exec("PRAGMA user_version = 1");
+        });
+    }
+}

package/dist/sqlite/store.d.ts

@@ -0,0 +1,3 @@
+import type { ClientStoreAdapter } from "../types.js";
+import type { SqliteDatabase } from "./driver.js";
+export declare function createSqliteStoreAdapter(database: SqliteDatabase): ClientStoreAdapter;

package/dist/sqlite/store.js

@@ -0,0 +1,122 @@
+import { bytesToHex, cloneBytes, hexToBytes, } from "../bytes.js";
+import { deleteCheckpointsAbove, loadLatestCheckpoint, replaceCheckpoint, } from "./checkpoints.js";
+import { loadTipSnapshotMeta, writeTipMeta, } from "./tip-meta.js";
+export function createSqliteStoreAdapter(database) {
+    let writeQueue = Promise.resolve();
+    let closed = false;
+    function assertOpen() {
+        if (closed) {
+            throw new Error("sqlite_store_closed");
+        }
+    }
+    function enqueueWrite(operation) {
+        const next = writeQueue.then(operation, operation);
+        writeQueue = next.then(() => undefined, () => undefined);
+        return next;
+    }
+    return {
+        async loadTip() {
+            assertOpen();
+            const decoded = await loadTipSnapshotMeta(database);
+            return decoded === null ? null : decoded.tip;
+        },
+        async loadLatestSnapshot() {
+            assertOpen();
+            const tipMeta = await loadTipSnapshotMeta(database);
+            if (tipMeta !== null) {
+                return {
+                    height: tipMeta.tip.height,
+                    blockHashHex: tipMeta.tip.blockHashHex,
+                    stateBytes: tipMeta.stateBytes,
+                    createdAt: tipMeta.updatedAt,
+                };
+            }
+            const row = await loadLatestCheckpoint(database);
+            if (row === null) {
+                return null;
+            }
+            return {
+                height: row.height,
+                blockHashHex: row.blockHashHex,
+                stateBytes: row.stateBytes,
+                createdAt: row.createdAt,
+            };
+        },
+        async loadBlockRecordsAfter(height) {
+            assertOpen();
+            const rows = await database.all(`SELECT height, block_hash, previous_hash, record_bytes, state_hash_hex, created_at
+         FROM block_records
+         WHERE height > ?
+         ORDER BY height ASC`, [height]);
+            return rows.map((row) => ({
+                height: row.height,
+                blockHashHex: bytesToHex(row.block_hash),
+                previousHashHex: row.previous_hash.length === 0 ? null : bytesToHex(row.previous_hash),
+                stateHashHex: row.state_hash_hex.length === 0 ? null : row.state_hash_hex,
+                recordBytes: cloneBytes(row.record_bytes),
+                createdAt: row.created_at,
+            }));
+        },
+        async writeAppliedBlock(entry) {
+            assertOpen();
+            await enqueueWrite(async () => {
+                const createdAt = entry.blockRecord?.createdAt ?? entry.checkpoint?.createdAt ?? Date.now();
+                await database.transaction(async () => {
+                    if (entry.deleteAboveHeight !== null && entry.deleteAboveHeight !== undefined) {
+                        await database.run(`DELETE FROM block_records WHERE height > ?`, [entry.deleteAboveHeight]);
+                        await deleteCheckpointsAbove(database, entry.deleteAboveHeight);
+                    }
+                    if (entry.blockRecord !== null && entry.blockRecord !== undefined) {
+                        await database.run(`INSERT INTO block_records (height, block_hash, previous_hash, record_bytes, state_hash_hex, created_at)
+               VALUES (?, ?, ?, ?, ?, ?)`, [
+                            entry.blockRecord.height,
+                            hexToBytes(entry.blockRecord.blockHashHex),
+                            entry.blockRecord.previousHashHex === null ? new Uint8Array() : hexToBytes(entry.blockRecord.previousHashHex),
+                            entry.blockRecord.recordBytes,
+                            entry.blockRecord.stateHashHex ?? "",
+                            entry.blockRecord.createdAt,
+                        ]);
+                    }
+                    await writeTipMeta(database, entry.tip, entry.stateBytes, createdAt);
+                    if (entry.checkpoint !== null && entry.checkpoint !== undefined) {
+                        await replaceCheckpoint(database, entry.checkpoint);
+                    }
+                });
+            });
+        },
+        async deleteBlockRecordsAbove(height) {
+            assertOpen();
+            await enqueueWrite(async () => {
+                await database.transaction(async () => {
+                    await database.run(`DELETE FROM block_records WHERE height > ?`, [height]);
+                    await deleteCheckpointsAbove(database, height);
+                });
+            });
+        },
+        async loadBlockRecord(height) {
+            assertOpen();
+            const row = await database.get(`SELECT height, block_hash, previous_hash, record_bytes, state_hash_hex, created_at
+         FROM block_records
+         WHERE height = ?`, [height]);
+            if (row === null) {
+                return null;
+            }
+            return {
+                height: row.height,
+                blockHashHex: bytesToHex(row.block_hash),
+                previousHashHex: row.previous_hash.length === 0 ? null : bytesToHex(row.previous_hash),
+                stateHashHex: row.state_hash_hex.length === 0 ? null : row.state_hash_hex,
+                recordBytes: cloneBytes(row.record_bytes),
+                createdAt: row.created_at,
+            };
+        },
+        async close() {
+            if (closed) {
+                return;
+            }
+            await writeQueue;
+            closed = true;
+            await database.close();
+        },
+    };
+}

package/dist/sqlite/tip-meta.d.ts

@@ -0,0 +1,26 @@
+import type { ClientTip } from "../types.js";
+import type { SqliteDatabase } from "./driver.js";
+export declare const TIP_META_KEYS: {
+    readonly tipHeight: "tip_height";
+    readonly tipBlockHash: "tip_block_hash";
+    readonly tipPreviousHash: "tip_previous_hash";
+    readonly tipStateHashHex: "tip_state_hash_hex";
+    readonly tipStateBytes: "tip_state_bytes";
+    readonly tipUpdatedAt: "tip_updated_at";
+};
+export interface StoredTipMeta {
+    tip: ClientTip;
+    stateBytes: Uint8Array | null;
+    updatedAt: number;
+}
+export interface StoredTipSnapshot {
+    tip: ClientTip;
+    stateBytes: Uint8Array;
+    updatedAt: number;
+}
+export declare function decodeTipMeta(meta: Map<string, Uint8Array>): StoredTipMeta | null;
+export declare function requireTipStateBytes(meta: StoredTipMeta | null): StoredTipSnapshot | null;
+export declare function loadTipMeta(database: SqliteDatabase): Promise<StoredTipMeta | null>;
+export declare function loadTipSnapshotMeta(database: SqliteDatabase): Promise<StoredTipSnapshot | null>;
+export declare function clearTipMeta(database: SqliteDatabase): Promise<void>;
+export declare function writeTipMeta(database: SqliteDatabase, tip: ClientTip | null, stateBytes: Uint8Array | null, updatedAt: number): Promise<void>;

package/dist/sqlite/tip-meta.js

@@ -0,0 +1,97 @@
+import { bytesToHex, cloneBytes, decodeInteger, decodeNullableText, encodeInteger, encodeNullableText, hexToBytes, } from "../bytes.js";
+export const TIP_META_KEYS = {
+    tipHeight: "tip_height",
+    tipBlockHash: "tip_block_hash",
+    tipPreviousHash: "tip_previous_hash",
+    tipStateHashHex: "tip_state_hash_hex",
+    tipStateBytes: "tip_state_bytes",
+    tipUpdatedAt: "tip_updated_at",
+};
+function readMetaValue(meta, key) {
+    return meta.get(key) ?? null;
+}
+function allTipMetaKeys() {
+    return [
+        TIP_META_KEYS.tipHeight,
+        TIP_META_KEYS.tipBlockHash,
+        TIP_META_KEYS.tipPreviousHash,
+        TIP_META_KEYS.tipStateHashHex,
+        TIP_META_KEYS.tipStateBytes,
+        TIP_META_KEYS.tipUpdatedAt,
+    ];
+}
+export function decodeTipMeta(meta) {
+    const heightBytes = readMetaValue(meta, TIP_META_KEYS.tipHeight);
+    const hashBytes = readMetaValue(meta, TIP_META_KEYS.tipBlockHash);
+    const previousHashBytes = readMetaValue(meta, TIP_META_KEYS.tipPreviousHash);
+    const stateHashHexBytes = readMetaValue(meta, TIP_META_KEYS.tipStateHashHex);
+    const stateBytes = readMetaValue(meta, TIP_META_KEYS.tipStateBytes);
+    const updatedAtBytes = readMetaValue(meta, TIP_META_KEYS.tipUpdatedAt);
+    if (heightBytes === null &&
+        hashBytes === null &&
+        previousHashBytes === null &&
+        stateHashHexBytes === null &&
+        stateBytes === null &&
+        updatedAtBytes === null) {
+        return null;
+    }
+    if (heightBytes === null ||
+        hashBytes === null ||
+        previousHashBytes === null ||
+        stateHashHexBytes === null ||
+        updatedAtBytes === null) {
+        throw new Error("sqlite_store_tip_meta_incomplete");
+    }
+    return {
+        tip: {
+            height: decodeInteger(heightBytes),
+            blockHashHex: bytesToHex(hashBytes),
+            previousHashHex: previousHashBytes.length === 0 ? null : bytesToHex(previousHashBytes),
+            stateHashHex: decodeNullableText(stateHashHexBytes),
+        },
+        stateBytes: stateBytes === null ? null : cloneBytes(stateBytes),
+        updatedAt: decodeInteger(updatedAtBytes),
+    };
+}
+export function requireTipStateBytes(meta) {
+    if (meta === null) {
+        return null;
+    }
+    if (meta.stateBytes === null) {
+        throw new Error("sqlite_store_tip_meta_incomplete");
+    }
+    return {
+        tip: meta.tip,
+        stateBytes: meta.stateBytes,
+        updatedAt: meta.updatedAt,
+    };
+}
+export async function loadTipMeta(database) {
+    const rows = await database.all(`SELECT key, value FROM meta WHERE key IN (?, ?, ?, ?, ?, ?)`, allTipMetaKeys());
+    const meta = new Map();
+    for (const row of rows) {
+        meta.set(row.key, cloneBytes(row.value));
+    }
+    return decodeTipMeta(meta);
+}
+export async function loadTipSnapshotMeta(database) {
+    return requireTipStateBytes(await loadTipMeta(database));
+}
+async function upsertMeta(database, key, value) {
+    await database.run(`INSERT INTO meta (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value`, [key, value]);
+}
+export async function clearTipMeta(database) {
+    await database.run(`DELETE FROM meta WHERE key IN (?, ?, ?, ?, ?, ?)`, allTipMetaKeys());
+}
+export async function writeTipMeta(database, tip, stateBytes, updatedAt) {
+    if (tip === null || stateBytes === null) {
+        await clearTipMeta(database);
+        return;
+    }
+    await upsertMeta(database, TIP_META_KEYS.tipHeight, encodeInteger(tip.height));
+    await upsertMeta(database, TIP_META_KEYS.tipBlockHash, hexToBytes(tip.blockHashHex));
+    await upsertMeta(database, TIP_META_KEYS.tipPreviousHash, tip.previousHashHex === null ? new Uint8Array() : hexToBytes(tip.previousHashHex));
+    await upsertMeta(database, TIP_META_KEYS.tipStateHashHex, encodeNullableText(tip.stateHashHex));
+    await upsertMeta(database, TIP_META_KEYS.tipStateBytes, stateBytes);
+    await upsertMeta(database, TIP_META_KEYS.tipUpdatedAt, encodeInteger(updatedAt));
+}

package/dist/sqlite/types.d.ts

@@ -0,0 +1,10 @@
+export interface SqlitePragmaOptions {
+    foreignKeys?: boolean;
+    busyTimeoutMs?: number;
+    journalMode?: "WAL" | "DELETE" | "TRUNCATE" | "PERSIST" | "MEMORY" | "OFF";
+    synchronous?: "FULL" | "NORMAL" | "OFF" | "EXTRA";
+}
+export interface SqliteStoreOptions {
+    filename: string;
+    pragmas?: SqlitePragmaOptions;
+}

package/dist/sqlite/types.js

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

package/dist/types.d.ts

@@ -0,0 +1,55 @@
+import type { AppliedBlock, BitcoinBlock, BlockRecord, GenesisParameters, IndexerState } from "@cogcoin/indexer/types";
+export interface ClientTip {
+    height: number;
+    blockHashHex: string;
+    previousHashHex: string | null;
+    stateHashHex: string | null;
+}
+export interface ClientCheckpoint {
+    height: number;
+    blockHashHex: string;
+    stateBytes: Uint8Array;
+    createdAt: number;
+}
+export interface StoredBlockRecord {
+    height: number;
+    blockHashHex: string;
+    previousHashHex: string | null;
+    stateHashHex: string | null;
+    recordBytes: Uint8Array;
+    createdAt: number;
+}
+export interface WriteAppliedBlockEntry {
+    tip: ClientTip | null;
+    stateBytes: Uint8Array | null;
+    blockRecord?: StoredBlockRecord | null;
+    checkpoint?: ClientCheckpoint | null;
+    deleteAboveHeight?: number | null;
+}
+export interface ClientStoreAdapter {
+    loadTip(): Promise<ClientTip | null>;
+    loadLatestSnapshot(): Promise<ClientCheckpoint | null>;
+    loadBlockRecordsAfter(height: number): Promise<StoredBlockRecord[]>;
+    writeAppliedBlock(entry: WriteAppliedBlockEntry): Promise<void>;
+    deleteBlockRecordsAbove(height: number): Promise<void>;
+    loadBlockRecord(height: number): Promise<StoredBlockRecord | null>;
+    close(): Promise<void>;
+}
+export interface ClientOptions {
+    store: ClientStoreAdapter;
+    genesisParameters?: GenesisParameters;
+    snapshotInterval?: number;
+}
+export interface ApplyBlockResult {
+    tip: ClientTip;
+    checkpoint: ClientCheckpoint | null;
+    applied: AppliedBlock;
+}
+export interface Client {
+    getTip(): Promise<ClientTip | null>;
+    getState(): Promise<IndexerState>;
+    applyBlock(block: BitcoinBlock): Promise<ApplyBlockResult>;
+    rewindToHeight(height: number): Promise<ClientTip | null>;
+    close(): Promise<void>;
+}
+export type { BitcoinBlock, BlockRecord, GenesisParameters, IndexerState, };

package/dist/types.js

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

package/dist/wallet/archive.d.ts

@@ -0,0 +1,4 @@
+import type { PortableWalletArchivePayloadV1 } from "./types.js";
+export declare const PORTABLE_WALLET_ARCHIVE_FORMAT = "cogcoin-portable-wallet-archive";
+export declare function writePortableWalletArchive(path: string, payload: PortableWalletArchivePayloadV1, passphrase: Uint8Array | string): Promise<void>;
+export declare function readPortableWalletArchive(path: string, passphrase: Uint8Array | string): Promise<PortableWalletArchivePayloadV1>;

package/dist/wallet/archive.js

@@ -0,0 +1,39 @@
+import { readFile } from "node:fs/promises";
+import { writeJsonFileAtomic } from "./fs/atomic.js";
+import { decryptJsonWithPassphrase, encryptJsonWithPassphrase, } from "./state/crypto.js";
+export const PORTABLE_WALLET_ARCHIVE_FORMAT = "cogcoin-portable-wallet-archive";
+function assertPortableWalletArchivePayload(payload) {
+    if (payload.schemaVersion !== 1
+        || payload.walletRootId.trim() === ""
+        || payload.mnemonic.phrase.trim() === ""
+        || payload.expected.accountPath.trim() === ""
+        || payload.expected.publicExternalDescriptor.trim() === ""
+        || payload.expected.fundingAddress0.trim() === ""
+        || payload.expected.fundingScriptPubKeyHex0.trim() === "") {
+        throw new Error("wallet_archive_payload_invalid");
+    }
+    return payload;
+}
+export async function writePortableWalletArchive(path, payload, passphrase) {
+    const envelope = await encryptJsonWithPassphrase(assertPortableWalletArchivePayload(payload), passphrase, {
+        format: PORTABLE_WALLET_ARCHIVE_FORMAT,
+    });
+    await writeJsonFileAtomic(path, envelope, { mode: 0o600 });
+}
+export async function readPortableWalletArchive(path, passphrase) {
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            throw new Error("wallet_import_archive_not_found");
+        }
+        throw error;
+    }
+    const envelope = JSON.parse(raw);
+    if (envelope.format !== PORTABLE_WALLET_ARCHIVE_FORMAT || envelope.version !== 1) {
+        throw new Error("wallet_archive_format_invalid");
+    }
+    return assertPortableWalletArchivePayload(await decryptJsonWithPassphrase(envelope, passphrase));
+}

package/dist/wallet/cogop/constants.d.ts

@@ -0,0 +1,32 @@
+export declare const COG_PREFIX: Uint8Array<ArrayBuffer>;
+export declare const MIN_OP_RETURN_BYTES = 4;
+export declare const MAX_OP_RETURN_BYTES = 80;
+export declare const MIN_SCRIPT_PUBKEY_BYTES = 1;
+export declare const MAX_SCRIPT_PUBKEY_BYTES = 67;
+export declare const MIN_NAME_BYTES = 1;
+export declare const MAX_NAME_BYTES = 63;
+export declare const FIELD_FORMAT_BYTES: {
+    readonly clear: 0;
+    readonly bytes: 1;
+    readonly text: 2;
+    readonly json: 9;
+};
+export declare const COG_OPCODES: {
+    readonly MINE: 1;
+    readonly COG_TRANSFER: 2;
+    readonly COG_LOCK: 3;
+    readonly COG_CLAIM: 4;
+    readonly DOMAIN_REG: 5;
+    readonly DOMAIN_TRANSFER: 6;
+    readonly DOMAIN_SELL: 7;
+    readonly DOMAIN_BUY: 8;
+    readonly FIELD_REG: 9;
+    readonly DATA_UPDATE: 10;
+    readonly SET_ENDPOINT: 11;
+    readonly REP_COMMIT: 12;
+    readonly REP_REVOKE: 13;
+    readonly SET_CANONICAL: 14;
+    readonly DOMAIN_ANCHOR: 15;
+    readonly SET_DELEGATE: 16;
+    readonly SET_MINER: 17;
+};

package/dist/wallet/cogop/constants.js

@@ -0,0 +1,32 @@
+export const COG_PREFIX = new Uint8Array([0x43, 0x4f, 0x47]);
+export const MIN_OP_RETURN_BYTES = 4;
+export const MAX_OP_RETURN_BYTES = 80;
+export const MIN_SCRIPT_PUBKEY_BYTES = 1;
+export const MAX_SCRIPT_PUBKEY_BYTES = 67;
+export const MIN_NAME_BYTES = 1;
+export const MAX_NAME_BYTES = 63;
+export const FIELD_FORMAT_BYTES = {
+    clear: 0x00,
+    bytes: 0x01,
+    text: 0x02,
+    json: 0x09,
+};
+export const COG_OPCODES = {
+    MINE: 0x01,
+    COG_TRANSFER: 0x02,
+    COG_LOCK: 0x03,
+    COG_CLAIM: 0x04,
+    DOMAIN_REG: 0x05,
+    DOMAIN_TRANSFER: 0x06,
+    DOMAIN_SELL: 0x07,
+    DOMAIN_BUY: 0x08,
+    FIELD_REG: 0x09,
+    DATA_UPDATE: 0x0a,
+    SET_ENDPOINT: 0x0b,
+    REP_COMMIT: 0x0c,
+    REP_REVOKE: 0x0d,
+    SET_CANONICAL: 0x0e,
+    DOMAIN_ANCHOR: 0x0f,
+    SET_DELEGATE: 0x10,
+    SET_MINER: 0x11,
+};

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

@@ -0,0 +1,32 @@
+import { FIELD_FORMAT_BYTES } from "./constants.js";
+import { writeU8, writeU32BE, writeU64BE } from "./numeric.js";
+import { validateExternalScriptPubKey, writeLenPrefixedSpk } from "./scriptpubkey.js";
+import { validateDomainName, validateFieldName } from "./validate-name.js";
+export type ScriptPubKey = Uint8Array;
+export type Bytes32 = Uint8Array;
+export type Coglex60 = Uint8Array;
+export type OpReturnPayload = Uint8Array;
+export interface SerializerResult {
+    opReturnData: Uint8Array;
+}
+declare function concatParts(parts: Uint8Array[]): Uint8Array;
+declare function writeAsciiName(name: string, validator: (value: string) => void): Uint8Array;
+export declare function computeRootRegistrationPriceSats(rootName: string): bigint;
+export declare function serializeMine(domainId: number, referencedBlockHashInternal: Bytes32, sentence60: Coglex60, minerData?: Uint8Array): SerializerResult;
+export declare function serializeCogTransfer(amount: bigint, recipientSpk: ScriptPubKey): SerializerResult;
+export declare function serializeCogLock(amount: bigint, timeoutHeight: number, recipientDomainId: number, condition32: Bytes32): SerializerResult;
+export declare function serializeCogClaim(lockId: number, preimage32: Bytes32): SerializerResult;
+export declare function serializeDomainReg(name: string): SerializerResult;
+export declare function serializeDomainTransfer(domainId: number, recipientSpk: ScriptPubKey): SerializerResult;
+export declare function serializeDomainSell(domainId: number, listedPrice: bigint): SerializerResult;
+export declare function serializeDomainBuy(domainId: number, expectedPrice: bigint): SerializerResult;
+export declare function serializeFieldReg(parentDomainId: number, permanent: boolean, fieldName: string): SerializerResult;
+export declare function serializeDataUpdate(domainId: number, fieldId: number, format: number, value?: Uint8Array): SerializerResult;
+export declare function serializeSetEndpoint(domainId: number, endpoint?: Uint8Array): SerializerResult;
+export declare function serializeRepCommit(sourceDomainId: number, targetDomainId: number, amount: bigint, review60?: Coglex60): SerializerResult;
+export declare function serializeRepRevoke(sourceDomainId: number, targetDomainId: number, amount: bigint, review60?: Coglex60): SerializerResult;
+export declare function serializeSetCanonical(domainId: number): SerializerResult;
+export declare function serializeDomainAnchor(domainId: number, foundingMessage60?: Coglex60): SerializerResult;
+export declare function serializeSetDelegate(domainId: number, delegateSpk?: ScriptPubKey): SerializerResult;
+export declare function serializeSetMiner(domainId: number, minerSpk?: ScriptPubKey): SerializerResult;
+export { concatParts, FIELD_FORMAT_BYTES, validateDomainName, validateExternalScriptPubKey, validateFieldName, writeAsciiName, writeLenPrefixedSpk, writeU8, writeU32BE, writeU64BE, };