@cogcoin/client 1.1.8 → 1.1.9

package/dist/wallet/tx/field/types.d.ts

@@ -0,0 +1,163 @@
+import type { lookupDomain } from "@cogcoin/indexer/queries";
+import type { RpcTransaction } from "../../../bitcoind/types.js";
+import type { WalletPrompter } from "../../lifecycle.js";
+import type { WalletReadContext } from "../../read/index.js";
+import type { WalletRuntimePaths } from "../../runtime.js";
+import type { WalletSecretProvider } from "../../state/provider.js";
+import type { PendingMutationRecord, WalletStateV1 } from "../../types.js";
+import type { FixedWalletInput, MutationSender, WalletMutationFeeSummary, WalletMutationRpcClient } from "../common.js";
+export type FieldMutationKind = "field-create" | "field-set" | "field-clear";
+export type FieldValueInputSource = {
+    kind: "text";
+    value: string;
+} | {
+    kind: "json";
+    value: string;
+} | {
+    kind: "bytes";
+    value: string;
+} | {
+    kind: "raw";
+    format: string;
+    value: string;
+};
+export interface FieldRpcClient extends WalletMutationRpcClient {
+    getBlockchainInfo(): Promise<{
+        blocks: number;
+    }>;
+    sendRawTransaction(hex: string): Promise<string>;
+    getRawTransaction(txid: string, verbose?: boolean): Promise<RpcTransaction>;
+}
+export interface FieldPlan {
+    sender: MutationSender;
+    changeAddress: string;
+    fixedInputs: FixedWalletInput[];
+    outputs: unknown[];
+    changePosition: number;
+    expectedOpReturnScriptHex: string;
+    allowedFundingScriptPubKeyHex: string;
+    eligibleFundingOutpointKeys: Set<string>;
+    errorPrefix: string;
+}
+export type ReadyWalletReadContext = WalletReadContext & {
+    localState: {
+        availability: "ready";
+        state: WalletStateV1;
+    };
+    snapshot: NonNullable<WalletReadContext["snapshot"]>;
+    model: NonNullable<WalletReadContext["model"]>;
+};
+export interface FieldOperation {
+    readContext: ReadyWalletReadContext;
+    state: WalletStateV1;
+    sender: MutationSender;
+    senderSelector: string;
+    chainDomain: NonNullable<ReturnType<typeof lookupDomain>>;
+}
+export interface StandaloneFieldMutationOperation extends FieldOperation {
+    normalizedDomainName: string;
+    normalizedFieldName: string;
+    existingObservedField: ReturnType<typeof import("../../read/index.js").findDomainField>;
+}
+export interface NormalizedFieldValue {
+    format: number;
+    formatLabel: string;
+    value: Uint8Array;
+    valueHex: string;
+}
+export interface CreateFieldOptions {
+    domainName: string;
+    fieldName: string;
+    permanent?: boolean;
+    feeRateSatVb?: number | null;
+    dataDir: string;
+    databasePath: string;
+    provider?: WalletSecretProvider;
+    prompter: WalletPrompter;
+    assumeYes?: boolean;
+    nowUnixMs?: number;
+    paths?: WalletRuntimePaths;
+    openReadContext?: typeof import("../../read/index.js").openWalletReadContext;
+    attachService?: typeof import("../../../bitcoind/service.js").attachOrStartManagedBitcoindService;
+    rpcFactory?: (config: Parameters<typeof import("../../../bitcoind/node.js").createRpcClient>[0]) => FieldRpcClient;
+}
+export interface SetFieldOptions extends Omit<CreateFieldOptions, "permanent"> {
+    source: FieldValueInputSource;
+}
+export interface ClearFieldOptions extends Omit<CreateFieldOptions, "permanent" | "source"> {
+}
+export interface FieldMutationResult {
+    kind: FieldMutationKind;
+    domainName: string;
+    fieldName: string;
+    fieldId: number | null;
+    txid: string;
+    permanent: boolean | null;
+    format: number | null;
+    status: "live" | "confirmed";
+    reusedExisting: boolean;
+    resolved?: FieldResolvedSummary | null;
+    fees: WalletMutationFeeSummary;
+}
+export interface FieldResolvedSenderSummary {
+    selector: string;
+    localIndex: number;
+    scriptPubKeyHex: string;
+    address: string;
+}
+export type FieldResolvedPath = "standalone-field-reg" | "standalone-data-update" | "standalone-data-clear";
+export interface FieldResolvedValueSummary {
+    format: number;
+    byteLength: number;
+}
+export type FieldResolvedEffect = {
+    kind: "create-empty-field";
+    burnCogtoshi: "100";
+} | {
+    kind: "write-field-value";
+    burnCogtoshi: "1";
+} | {
+    kind: "clear-field-value";
+    burnCogtoshi: "0";
+};
+export interface FieldResolvedSummary {
+    sender: FieldResolvedSenderSummary;
+    path: FieldResolvedPath;
+    value: FieldResolvedValueSummary | null;
+    effect: FieldResolvedEffect;
+}
+export interface FieldDraftMutationOptions {
+    kind: FieldMutationKind;
+    domainName: string;
+    fieldName: string;
+    sender: MutationSender;
+    intentFingerprintHex: string;
+    nowUnixMs: number;
+    feeSelection: {
+        feeRateSatVb: number;
+        source: "custom-satvb" | "estimated-next-block-plus-one" | "fallback-default";
+    };
+    existing?: PendingMutationRecord | null;
+    fieldId?: number | null;
+    fieldPermanent?: boolean | null;
+    fieldFormat?: number | null;
+    fieldValueHex?: string | null;
+}
+export interface PreparedFieldMutation {
+    opReturnData: Uint8Array;
+    mutation: PendingMutationRecord;
+}
+export interface FieldMutationVariant {
+    kind: FieldMutationKind;
+    errorPrefix: string;
+    createMutation(options: {
+        operation: FieldOperation;
+        existing: PendingMutationRecord | null;
+        feeSelection: {
+            feeRateSatVb: number;
+            source: "custom-satvb" | "estimated-next-block-plus-one" | "fallback-default";
+        };
+        nowUnixMs: number;
+    }): Promise<PreparedFieldMutation>;
+    confirm(operation: FieldOperation): Promise<void>;
+}

package/dist/wallet/tx/field/types.js

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

package/dist/wallet/tx/field/variants/clear.d.ts

@@ -0,0 +1,2 @@
+import type { ClearFieldOptions, FieldMutationVariant } from "../types.js";
+export declare function createClearFieldVariant(options: ClearFieldOptions): FieldMutationVariant;

package/dist/wallet/tx/field/variants/clear.js

@@ -0,0 +1,60 @@
+import { FIELD_FORMAT_BYTES, serializeDataUpdate } from "../../../cogop/index.js";
+import { createFieldIntentFingerprint, normalizeFieldDomainName, normalizeFieldNameInput, } from "../intent.js";
+import { createStandaloneFieldMutation, getObservedFieldState, } from "../draft.js";
+import { describeFieldEffect } from "../result.js";
+export function createClearFieldVariant(options) {
+    return {
+        kind: "field-clear",
+        errorPrefix: "wallet_field_clear",
+        async createMutation({ operation, existing, feeSelection, nowUnixMs }) {
+            const normalizedDomainName = normalizeFieldDomainName(options.domainName);
+            const normalizedFieldName = normalizeFieldNameInput(options.fieldName);
+            const observedField = getObservedFieldState(operation.readContext, normalizedDomainName, normalizedFieldName);
+            if (observedField === null) {
+                throw new Error("wallet_field_clear_field_not_found");
+            }
+            if (observedField.permanent && !observedField.hasValue) {
+                throw new Error("wallet_field_clear_noop_permanent_clear");
+            }
+            const intentFingerprintHex = createFieldIntentFingerprint([
+                "field-clear",
+                operation.state.walletRootId,
+                normalizedDomainName,
+                observedField.fieldId,
+            ]);
+            return {
+                opReturnData: serializeDataUpdate(operation.chainDomain.domainId, observedField.fieldId, FIELD_FORMAT_BYTES.clear).opReturnData,
+                mutation: createStandaloneFieldMutation({
+                    kind: "field-clear",
+                    domainName: normalizedDomainName,
+                    fieldName: normalizedFieldName,
+                    sender: operation.sender,
+                    intentFingerprintHex,
+                    nowUnixMs,
+                    feeSelection,
+                    existing,
+                    fieldId: observedField.fieldId,
+                    fieldPermanent: observedField.permanent,
+                    fieldFormat: FIELD_FORMAT_BYTES.clear,
+                    fieldValueHex: "",
+                }),
+            };
+        },
+        async confirm(operation) {
+            const normalizedDomainName = normalizeFieldDomainName(options.domainName);
+            const normalizedFieldName = normalizeFieldNameInput(options.fieldName);
+            const observedField = getObservedFieldState(operation.readContext, normalizedDomainName, normalizedFieldName);
+            if (observedField === null) {
+                throw new Error("wallet_field_clear_field_not_found");
+            }
+            if (observedField.permanent && !observedField.hasValue) {
+                throw new Error("wallet_field_clear_noop_permanent_clear");
+            }
+            options.prompter.writeLine(`Clearing field "${normalizedDomainName}:${normalizedFieldName}".`);
+            options.prompter.writeLine(`Resolved sender: ${operation.senderSelector} (${operation.sender.address})`);
+            options.prompter.writeLine("Path: standalone-data-clear");
+            options.prompter.writeLine(`Effect: ${describeFieldEffect({ kind: "clear-field-value", burnCogtoshi: "0" })}.`);
+            options.prompter.writeLine("This publishes a standalone DATA_UPDATE clear.");
+        },
+    };
+}

package/dist/wallet/tx/field/variants/create.d.ts

@@ -0,0 +1,2 @@
+import type { CreateFieldOptions, FieldMutationVariant } from "../types.js";
+export declare function createFieldCreateVariant(options: CreateFieldOptions): FieldMutationVariant;

package/dist/wallet/tx/field/variants/create.js

@@ -0,0 +1,67 @@
+import { getBalance } from "@cogcoin/indexer/queries";
+import { serializeFieldReg } from "../../../cogop/index.js";
+import { confirmYesNo } from "../confirm.js";
+import { createFieldIntentFingerprint, normalizeFieldDomainName, normalizeFieldNameInput, } from "../intent.js";
+import { createStandaloneFieldMutation, findActiveFieldCreateMutationByDomain, getObservedFieldState, } from "../draft.js";
+import { createResolvedFieldSenderSummary, describeFieldEffect, } from "../result.js";
+export function createFieldCreateVariant(options) {
+    const permanent = options.permanent ?? false;
+    return {
+        kind: "field-create",
+        errorPrefix: "wallet_field_create",
+        async createMutation({ operation, existing, feeSelection, nowUnixMs }) {
+            const normalizedDomainName = normalizeFieldDomainName(options.domainName);
+            const normalizedFieldName = normalizeFieldNameInput(options.fieldName);
+            const existingField = getObservedFieldState(operation.readContext, normalizedDomainName, normalizedFieldName);
+            if (existingField !== null) {
+                throw new Error("wallet_field_create_field_exists");
+            }
+            if (operation.chainDomain.nextFieldId === 0xffff_ffff) {
+                throw new Error("wallet_field_create_field_id_exhausted");
+            }
+            const senderBalance = getBalance(operation.readContext.snapshot.state, Buffer.from(operation.sender.scriptPubKeyHex, "hex"));
+            if (senderBalance < 100n) {
+                throw new Error("wallet_field_create_insufficient_cog");
+            }
+            const intentFingerprintHex = createFieldIntentFingerprint([
+                "field-create",
+                operation.state.walletRootId,
+                normalizedDomainName,
+                normalizedFieldName,
+                permanent ? 1 : 0,
+            ]);
+            const conflictCreate = findActiveFieldCreateMutationByDomain(operation.state, normalizedDomainName, intentFingerprintHex);
+            if (conflictCreate !== null) {
+                throw new Error("wallet_field_create_registration_already_pending");
+            }
+            return {
+                opReturnData: serializeFieldReg(operation.chainDomain.domainId, permanent, normalizedFieldName).opReturnData,
+                mutation: createStandaloneFieldMutation({
+                    kind: "field-create",
+                    domainName: normalizedDomainName,
+                    fieldName: normalizedFieldName,
+                    sender: operation.sender,
+                    intentFingerprintHex,
+                    nowUnixMs,
+                    feeSelection,
+                    existing,
+                    fieldId: operation.chainDomain.nextFieldId,
+                    fieldPermanent: permanent,
+                }),
+            };
+        },
+        async confirm(operation) {
+            const fieldRef = `${normalizeFieldDomainName(options.domainName)}:${normalizeFieldNameInput(options.fieldName)}`;
+            options.prompter.writeLine(`Creating field "${fieldRef}" as ${permanent ? "permanent" : "mutable"}.`);
+            options.prompter.writeLine(`Resolved sender: ${operation.senderSelector} (${operation.sender.address})`);
+            options.prompter.writeLine("Path: standalone-field-reg");
+            options.prompter.writeLine(`Effect: ${describeFieldEffect({ kind: "create-empty-field", burnCogtoshi: "100" })}.`);
+            options.prompter.writeLine("This publishes a standalone FIELD_REG and burns 0.00000100 COG.");
+            await confirmYesNo(options.prompter, "The field will be created empty and the burn is not reversible.", "wallet_field_create_confirmation_rejected", {
+                assumeYes: options.assumeYes,
+                requiresTtyErrorCode: "wallet_field_create_requires_tty",
+            });
+            void createResolvedFieldSenderSummary;
+        },
+    };
+}

package/dist/wallet/tx/field/variants/set.d.ts

@@ -0,0 +1,2 @@
+import type { FieldMutationVariant, SetFieldOptions } from "../types.js";
+export declare function createSetFieldVariant(options: SetFieldOptions): Promise<FieldMutationVariant>;

package/dist/wallet/tx/field/variants/set.js

@@ -0,0 +1,195 @@
+import { readFile } from "node:fs/promises";
+import { resolve as resolvePath } from "node:path";
+import { FIELD_FORMAT_BYTES, serializeDataUpdate, } from "../../../cogop/index.js";
+import { getBalance } from "@cogcoin/indexer/queries";
+import { confirmTyped, confirmYesNo, } from "../confirm.js";
+import { createFieldIntentFingerprint, normalizeFieldDomainName, normalizeFieldNameInput, } from "../intent.js";
+import { createStandaloneFieldMutation, getObservedFieldState, } from "../draft.js";
+import { describeFieldEffect, } from "../result.js";
+function describeRawFormat(format) {
+    if (format === FIELD_FORMAT_BYTES.bytes) {
+        return "bytes (0x01)";
+    }
+    if (format === FIELD_FORMAT_BYTES.text) {
+        return "text (0x02)";
+    }
+    if (format === FIELD_FORMAT_BYTES.json) {
+        return "json (0x09)";
+    }
+    return `raw (0x${format.toString(16).padStart(2, "0")})`;
+}
+async function loadFieldValue(source) {
+    if (source.kind === "text") {
+        if (source.value.length === 0) {
+            throw new Error("wallet_field_value_missing");
+        }
+        const value = new TextEncoder().encode(source.value);
+        return {
+            format: FIELD_FORMAT_BYTES.text,
+            formatLabel: "text (0x02)",
+            value,
+            valueHex: Buffer.from(value).toString("hex"),
+        };
+    }
+    if (source.kind === "json") {
+        if (source.value.length === 0) {
+            throw new Error("wallet_field_value_missing");
+        }
+        try {
+            JSON.parse(source.value);
+        }
+        catch {
+            throw new Error("wallet_field_invalid_json");
+        }
+        const value = new TextEncoder().encode(source.value);
+        return {
+            format: FIELD_FORMAT_BYTES.json,
+            formatLabel: "json (0x09)",
+            value,
+            valueHex: Buffer.from(value).toString("hex"),
+        };
+    }
+    if (source.kind === "bytes") {
+        let value;
+        if (source.value.startsWith("hex:")) {
+            const payload = source.value.slice(4);
+            if (!/^[0-9a-f]+$/.test(payload) || payload.length % 2 !== 0) {
+                throw new Error("wallet_field_invalid_bytes");
+            }
+            value = Buffer.from(payload, "hex");
+        }
+        else if (source.value.startsWith("@")) {
+            const filePath = source.value.slice(1);
+            if (filePath.trim() === "") {
+                throw new Error("wallet_field_invalid_bytes");
+            }
+            value = await readFile(resolvePath(process.cwd(), filePath));
+        }
+        else {
+            throw new Error("wallet_field_invalid_bytes");
+        }
+        if (value.length === 0) {
+            throw new Error("wallet_field_value_missing");
+        }
+        return {
+            format: FIELD_FORMAT_BYTES.bytes,
+            formatLabel: "bytes (0x01)",
+            value,
+            valueHex: value.toString("hex"),
+        };
+    }
+    const match = /^raw:(\d{1,3})$/.exec(source.format);
+    if (match == null) {
+        throw new Error("wallet_field_invalid_raw_format");
+    }
+    const format = Number.parseInt(match[1], 10);
+    if (!Number.isInteger(format) || format < 0 || format > 0xff || format === FIELD_FORMAT_BYTES.clear) {
+        throw new Error("wallet_field_invalid_raw_format");
+    }
+    let value;
+    if (source.value.startsWith("hex:")) {
+        const payload = source.value.slice(4);
+        if (!/^[0-9a-f]+$/.test(payload) || payload.length % 2 !== 0) {
+            throw new Error("wallet_field_invalid_value");
+        }
+        value = Buffer.from(payload, "hex");
+    }
+    else if (source.value.startsWith("@")) {
+        const filePath = source.value.slice(1);
+        if (filePath.trim() === "") {
+            throw new Error("wallet_field_invalid_value");
+        }
+        value = await readFile(resolvePath(process.cwd(), filePath));
+    }
+    else if (source.value.startsWith("utf8:")) {
+        value = new TextEncoder().encode(source.value.slice(5));
+    }
+    else {
+        throw new Error("wallet_field_invalid_value");
+    }
+    if (value.length === 0) {
+        throw new Error("wallet_field_value_missing");
+    }
+    return {
+        format,
+        formatLabel: describeRawFormat(format),
+        value,
+        valueHex: Buffer.from(value).toString("hex"),
+    };
+}
+export async function createSetFieldVariant(options) {
+    const value = await loadFieldValue(options.source);
+    return {
+        kind: "field-set",
+        errorPrefix: "wallet_field_set",
+        async createMutation({ operation, existing, feeSelection, nowUnixMs }) {
+            const normalizedDomainName = normalizeFieldDomainName(options.domainName);
+            const normalizedFieldName = normalizeFieldNameInput(options.fieldName);
+            const observedField = getObservedFieldState(operation.readContext, normalizedDomainName, normalizedFieldName);
+            if (observedField === null) {
+                throw new Error("wallet_field_set_field_not_found");
+            }
+            if (observedField.permanent && observedField.hasValue) {
+                throw new Error("wallet_field_set_permanent_field_frozen");
+            }
+            const senderBalance = getBalance(operation.readContext.snapshot.state, Buffer.from(operation.sender.scriptPubKeyHex, "hex"));
+            if (senderBalance < 1n) {
+                throw new Error("wallet_field_set_insufficient_cog");
+            }
+            const intentFingerprintHex = createFieldIntentFingerprint([
+                "field-set",
+                operation.state.walletRootId,
+                normalizedDomainName,
+                observedField.fieldId,
+                value.format,
+                value.valueHex,
+            ]);
+            return {
+                opReturnData: serializeDataUpdate(operation.chainDomain.domainId, observedField.fieldId, value.format, value.value).opReturnData,
+                mutation: createStandaloneFieldMutation({
+                    kind: "field-set",
+                    domainName: normalizedDomainName,
+                    fieldName: normalizedFieldName,
+                    sender: operation.sender,
+                    intentFingerprintHex,
+                    nowUnixMs,
+                    feeSelection,
+                    existing,
+                    fieldId: observedField.fieldId,
+                    fieldPermanent: observedField.permanent,
+                    fieldFormat: value.format,
+                    fieldValueHex: value.valueHex,
+                }),
+            };
+        },
+        async confirm(operation) {
+            const normalizedDomainName = normalizeFieldDomainName(options.domainName);
+            const normalizedFieldName = normalizeFieldNameInput(options.fieldName);
+            const observedField = getObservedFieldState(operation.readContext, normalizedDomainName, normalizedFieldName);
+            if (observedField === null) {
+                throw new Error("wallet_field_set_field_not_found");
+            }
+            const fieldRef = `${normalizedDomainName}:${normalizedFieldName}`;
+            options.prompter.writeLine(`Updating field "${fieldRef}".`);
+            options.prompter.writeLine(`Resolved sender: ${operation.senderSelector} (${operation.sender.address})`);
+            options.prompter.writeLine("Path: standalone-data-update");
+            options.prompter.writeLine(`Effect: ${describeFieldEffect({ kind: "write-field-value", burnCogtoshi: "1" })}.`);
+            options.prompter.writeLine(`Format: ${value.formatLabel}`);
+            options.prompter.writeLine(`Value bytes: ${value.value.length}`);
+            options.prompter.writeLine("Warning: the field value is public in the mempool and on-chain.");
+            if (observedField.permanent && !observedField.hasValue) {
+                options.prompter.writeLine("This is the first non-clear value write to a permanent field.");
+                await confirmTyped(options.prompter, fieldRef, `Type ${fieldRef} to continue: `, "wallet_field_set_confirmation_rejected", {
+                    assumeYes: options.assumeYes,
+                    requiresTtyErrorCode: "wallet_field_set_requires_tty",
+                    typedAckRequiredErrorCode: "wallet_field_set_typed_ack_required",
+                });
+                return;
+            }
+            await confirmYesNo(options.prompter, "This publishes a standalone DATA_UPDATE.", "wallet_field_set_confirmation_rejected", {
+                assumeYes: options.assumeYes,
+                requiresTtyErrorCode: "wallet_field_set_requires_tty",
+            });
+        },
+    };
+}

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

@@ -1,95 +1 @@
-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";
-type FieldMutationKind = "field-create" | "field-set" | "field-clear";
-export type FieldValueInputSource = {
-    kind: "text";
-    value: string;
-} | {
-    kind: "json";
-    value: string;
-} | {
-    kind: "bytes";
-    value: string;
-} | {
-    kind: "raw";
-    format: string;
-    value: string;
-};
-interface FieldRpcClient extends WalletMutationRpcClient {
-    getBlockchainInfo(): Promise<{
-        blocks: number;
-    }>;
-    sendRawTransaction(hex: string): Promise<string>;
-    getRawTransaction(txid: string, verbose?: boolean): Promise<RpcTransaction>;
-}
-export interface CreateFieldOptions {
-    domainName: string;
-    fieldName: string;
-    permanent?: boolean;
-    feeRateSatVb?: number | null;
-    dataDir: string;
-    databasePath: string;
-    provider?: WalletSecretProvider;
-    prompter: WalletPrompter;
-    assumeYes?: boolean;
-    nowUnixMs?: number;
-    paths?: WalletRuntimePaths;
-    openReadContext?: typeof openWalletReadContext;
-    attachService?: typeof attachOrStartManagedBitcoindService;
-    rpcFactory?: (config: Parameters<typeof createRpcClient>[0]) => FieldRpcClient;
-}
-export interface SetFieldOptions extends Omit<CreateFieldOptions, "permanent"> {
-    source: FieldValueInputSource;
-}
-export interface ClearFieldOptions extends Omit<CreateFieldOptions, "permanent" | "source"> {
-}
-export interface FieldMutationResult {
-    kind: FieldMutationKind;
-    domainName: string;
-    fieldName: string;
-    fieldId: number | null;
-    txid: string;
-    permanent: boolean | null;
-    format: number | null;
-    status: "live" | "confirmed";
-    reusedExisting: boolean;
-    resolved?: FieldResolvedSummary | null;
-    fees: WalletMutationFeeSummary;
-}
-export interface FieldResolvedSenderSummary {
-    selector: string;
-    localIndex: number;
-    scriptPubKeyHex: string;
-    address: string;
-}
-export type FieldResolvedPath = "standalone-field-reg" | "standalone-data-update" | "standalone-data-clear";
-export interface FieldResolvedValueSummary {
-    format: number;
-    byteLength: number;
-}
-export type FieldResolvedEffect = {
-    kind: "create-empty-field";
-    burnCogtoshi: "100";
-} | {
-    kind: "write-field-value";
-    burnCogtoshi: "1";
-} | {
-    kind: "clear-field-value";
-    burnCogtoshi: "0";
-};
-export interface FieldResolvedSummary {
-    sender: FieldResolvedSenderSummary;
-    path: FieldResolvedPath;
-    value: FieldResolvedValueSummary | null;
-    effect: FieldResolvedEffect;
-}
-export declare function createField(options: CreateFieldOptions): Promise<FieldMutationResult>;
-export declare function setField(options: SetFieldOptions): Promise<FieldMutationResult>;
-export declare function clearField(options: ClearFieldOptions): Promise<FieldMutationResult>;
-export {};
+export * from "./field/index.js";