@arkade-os/sdk 0.4.15 → 0.4.17

package/dist/types/extension/asset/assetGroup.d.ts

@@ -5,7 +5,22 @@ import { AssetOutput } from "./assetOutput";
 import { Metadata } from "./metadata";
 import { BufferReader, BufferWriter } from "./utils";
 /**
- * An asset group contains inputs/outputs and all data related to a given asset id.
+ * An asset group contains inputs, outputs, and all data related to a given asset id.
+ *
+ * @see Packet
+ * @see AssetId
+ * @see AssetRef
+ *
+ * @example
+ * ```typescript
+ * const group = AssetGroup.create(
+ *   null,                              // asset ID: null for new issuance
+ *   null,                              // control asset ID: null when reissuance not needed
+ *   [],                                // asset inputs: empty for new issuance
+ *   [AssetOutput.create(0, 1000)],     // asset outputs: 1000 units at vout index 0
+ *   []                                 // metadata: can be empty
+ * )
+ * ```
  */
 export declare class AssetGroup {
     readonly assetId: AssetId | null;
@@ -13,16 +28,92 @@ export declare class AssetGroup {
     readonly inputs: AssetInput[];
     readonly outputs: AssetOutput[];
     private readonly metadataList;
+    /** @see create */
     constructor(assetId: AssetId | null, controlAsset: AssetRef | null, inputs: AssetInput[], outputs: AssetOutput[], metadata: Metadata[]);
+    /**
+     * Create and validate an asset group.
+     *
+     * @param assetId - Asset id for this group, or `null` for fresh issuance
+     * @param controlAsset - Optional control asset reference for (re) issuance
+     * @param inputs - Asset inputs in the group
+     * @param outputs - Asset outputs in the group
+     * @param metadata - Metadata entries associated with the group
+     * @returns A validated asset group
+     * @throws Error if the group fails validation
+     * @see validate
+     */
     static create(assetId: AssetId | null, controlAsset: AssetRef | null, inputs: AssetInput[], outputs: AssetOutput[], metadata: Metadata[]): AssetGroup;
+    /**
+     * Decode an asset group from its hex string form.
+     *
+     * @param s - Hex-encoded asset group
+     * @returns Decoded asset group
+     * @throws Error if the string is not valid hex or does not encode a valid asset group
+     * @see toString
+     */
     static fromString(s: string): AssetGroup;
+    /**
+     * Decode an asset group from its serialized bytes.
+     *
+     * @param buf - Serialized asset group bytes
+     * @returns Decoded asset group
+     * @throws Error if the buffer is empty or malformed
+     */
     static fromBytes(buf: Uint8Array): AssetGroup;
+    /**
+     * Return true when the group represents an issuance.
+     *
+     * @returns `true` when the group has no asset id
+     */
     isIssuance(): boolean;
+    /**
+     * Return true when the group represents a reissuance.
+     *
+     * @returns `true` when the group has an asset id and outputs exceed local inputs
+     * @remarks
+     * Only local inputs contribute to the comparison; intent-backed inputs contribute `0` here.
+     */
     isReissuance(): boolean;
+    /**
+     * Serialize the asset group to raw bytes.
+     *
+     * @returns Serialized asset group bytes
+     * @see fromBytes
+     */
     serialize(): Uint8Array;
+    /**
+     * Validate the asset group and its child structures.
+     *
+     * @throws Error if the group is empty or violates issuance invariants
+     */
     validate(): void;
+    /**
+     * Convert the group into its batch-leaf representation for the given intent txid.
+     *
+     * @param intentTxid - Intent transaction id used to build the leaf input reference
+     * @returns Batch-leaf asset group
+     * @see AssetInput.createIntent
+     */
     toBatchLeafAssetGroup(intentTxid: Uint8Array): AssetGroup;
+    /**
+     * Encode the asset group to a hex string.
+     *
+     * @returns Hex-encoded asset group
+     * @see fromString
+     */
     toString(): string;
+    /**
+     * Decode an asset group from a binary reader.
+     *
+     * @param reader - Reader positioned at an asset group
+     * @returns Decoded asset group
+     * @throws Error if the encoded group is malformed
+     */
     static fromReader(reader: BufferReader): AssetGroup;
+    /**
+     * Serialize the asset group into an existing binary writer.
+     *
+     * @param writer - Writer to append the asset group to
+     */
     serializeTo(writer: BufferWriter): void;
 }

package/dist/types/extension/asset/assetId.d.ts

@@ -1,19 +1,83 @@
 import { BufferReader, BufferWriter } from "./utils";
 /**
- * AssetId represents the id of an asset.
- * @param txid - the genesis transaction id (decoded from hex)
- * @param groupIndex - the asset group index in the genesis transaction
+ * AssetId identifies a specific asset.
+ *
+ * @remarks
+ * Asset ids are derived from the genesis transaction id plus the asset group index.
+ *
+ * @see AssetRef
+ *
+ * @example
+ * ```typescript
+ * const assetId = AssetId.create('00'.repeat(32), 0)
+ * const encoded = assetId.toString()
+ * const decoded = AssetId.fromString(encoded)
+ * ```
  */
 export declare class AssetId {
     readonly txid: Uint8Array;
     readonly groupIndex: number;
     private constructor();
+    /**
+     * Create an asset id from a genesis transaction id and group index.
+     *
+     * @param txid - Hex-encoded genesis transaction id
+     * @param groupIndex - Asset group index within the genesis transaction
+     * @returns A validated asset id
+     * @throws Error if the txid is missing, malformed, or not 32 bytes long
+     * @see fromString
+     */
     static create(txid: string, groupIndex: number): AssetId;
+    /**
+     * Decode an asset id from its hex string representation.
+     *
+     * @param s - Hex-encoded asset id
+     * @returns Decoded asset id
+     * @throws Error if the string is not valid hex or does not encode a valid asset id
+     * @see toString
+     */
     static fromString(s: string): AssetId;
+    /**
+     * Decode an asset id from its serialized bytes.
+     *
+     * @param buf - Serialized asset id bytes
+     * @returns Decoded asset id
+     * @throws Error if the buffer length is invalid
+     */
     static fromBytes(buf: Uint8Array): AssetId;
+    /**
+     * Serialize the asset id to raw bytes.
+     *
+     * @returns Serialized asset id bytes
+     * @see fromBytes
+     */
     serialize(): Uint8Array;
+    /**
+     * Encode the asset id to a hex string.
+     *
+     * @returns Hex-encoded asset id
+     * @see fromString
+     */
     toString(): string;
+    /**
+     * Validate the asset id fields.
+     *
+     * @throws Error if the txid is empty or the group index is out of range
+     */
     validate(): void;
+    /**
+     * Decode an asset id from a binary reader.
+     *
+     * @param reader - Reader positioned at an asset id
+     * @returns Decoded asset id
+     * @throws Error if the reader does not contain enough bytes
+     */
     static fromReader(reader: BufferReader): AssetId;
+    /**
+     * Serialize the asset id into an existing binary writer.
+     *
+     * @param writer - Writer to append the asset id to
+     * @see serialize
+     */
     serializeTo(writer: BufferWriter): void;
 }

package/dist/types/extension/asset/assetInput.d.ts

@@ -17,16 +17,27 @@ type AssetInputIntent = Pick<AssetInputLocal, "vin" | "amount"> & {
 export declare class AssetInput {
     readonly input: AssetInputLocal | AssetInputIntent;
     private constructor();
+    /** Gets the transaction input index for an asset input, e.g. 0 */
     get vin(): number;
+    /** Gets the amount for an input (in most cases, 330 sats) */
     get amount(): bigint;
+    /** Create a local asset input that points at a transaction input index. */
     static create(vin: number, amount: bigint | number): AssetInput;
+    /** Create an intent-backed asset input referencing an external intent transaction. */
     static createIntent(txid: string, vin: number, amount: bigint | number): AssetInput;
+    /** Decode an asset input from its hex string form. */
     static fromString(s: string): AssetInput;
+    /** Decode an asset input from its serialized bytes. */
     static fromBytes(buf: Uint8Array): AssetInput;
+    /** Serialize the asset input to raw bytes. */
     serialize(): Uint8Array;
+    /** Encode the asset input to a hex string. */
     toString(): string;
+    /** Validate the asset input fields. */
     validate(): void;
+    /** Decode an asset input from a buffer reader. */
     static fromReader(reader: BufferReader): AssetInput;
+    /** Serialize the asset input into an existing buffer writer. */
     serializeTo(writer: BufferWriter): void;
 }
 /**
@@ -35,12 +46,19 @@ export declare class AssetInput {
 export declare class AssetInputs {
     readonly inputs: AssetInput[];
     private constructor();
+    /** Create a validated list of asset inputs. */
     static create(inputs: AssetInput[]): AssetInputs;
+    /** Decode an asset input list from its hex string form. */
     static fromString(s: string): AssetInputs;
+    /** Serialize the asset input list to raw bytes. */
     serialize(): Uint8Array;
+    /** Encode the asset input list to a hex string. */
     toString(): string;
+    /** Validate the asset input list. */
     validate(): void;
+    /** Decode an asset input list from a buffer reader. */
     static fromReader(reader: BufferReader): AssetInputs;
+    /** Serialize the asset input list into an existing buffer writer. */
     serializeTo(writer: BufferWriter): void;
 }
 export {};

package/dist/types/extension/asset/assetOutput.d.ts

@@ -11,13 +11,21 @@ export declare class AssetOutput {
     readonly amount: bigint;
     static readonly TYPE_LOCAL = 1;
     private constructor();
+    /** Create a local asset output referencing a transaction output index. */
     static create(vout: number, amount: bigint | number): AssetOutput;
+    /** Decode an asset output from its hex string form. */
     static fromString(s: string): AssetOutput;
+    /** Decode an asset output from its serialized bytes. */
     static fromBytes(buf: Uint8Array): AssetOutput;
+    /** Serialize the asset output to raw bytes. */
     serialize(): Uint8Array;
+    /** Encode the asset output to a hex string. */
     toString(): string;
+    /** Validate the asset output fields. */
     validate(): void;
+    /** Decode an asset output from a buffer reader. */
     static fromReader(reader: BufferReader): AssetOutput;
+    /** Serialize the asset output into an existing buffer writer. */
     serializeTo(writer: BufferWriter): void;
 }
 /**
@@ -29,11 +37,18 @@ export declare class AssetOutput {
 export declare class AssetOutputs {
     readonly outputs: AssetOutput[];
     private constructor();
+    /** Create a validated list of asset outputs. */
     static create(outputs: AssetOutput[]): AssetOutputs;
+    /** Decode an asset output list from its hex string form. */
     static fromString(s: string): AssetOutputs;
+    /** Serialize the asset output list to raw bytes. */
     serialize(): Uint8Array;
+    /** Encode the asset output list to a hex string. */
     toString(): string;
+    /** Validate the asset output list. */
     validate(): void;
+    /** Decode an asset output list from a buffer reader. */
     static fromReader(reader: BufferReader): AssetOutputs;
+    /** Serialize the asset output list into an existing buffer writer. */
     serializeTo(writer: BufferWriter): void;
 }

package/dist/types/extension/asset/assetRef.d.ts

@@ -9,17 +9,83 @@ type AssetRefByGroup = {
     type: AssetRefType.ByGroup;
     groupIndex: number;
 };
+/**
+ * Reference to either an explicit asset id or another asset group in the same packet.
+ *
+ * @see AssetId
+ *
+ * @example
+ * ```typescript
+ * const refById = AssetRef.fromId(assetId)
+ * const refByGroup = AssetRef.fromGroupIndex(0)
+ * ```
+ */
 export declare class AssetRef {
     readonly ref: AssetRefByID | AssetRefByGroup;
     private constructor();
+    /** Reference type discriminator. */
     get type(): AssetRefType;
+    /**
+     * Create an asset reference that points to a specific asset id.
+     *
+     * @param assetId - Asset id referenced by this pointer
+     * @returns Asset reference by id
+     * @see fromGroupIndex
+     */
     static fromId(assetId: AssetId): AssetRef;
+    /**
+     * Create an asset reference that points to another asset group by index.
+     *
+     * @param groupIndex - Zero-based asset group index in the packet
+     * @returns Asset reference by group index
+     * @see fromId
+     */
     static fromGroupIndex(groupIndex: number): AssetRef;
+    /**
+     * Decode an asset reference from its hex string form.
+     *
+     * @param s - Hex-encoded asset reference
+     * @returns Decoded asset reference
+     * @throws Error if the string is not valid hex or does not encode a valid asset reference
+     * @see toString
+     */
     static fromString(s: string): AssetRef;
+    /**
+     * Decode an asset reference from its serialized bytes.
+     *
+     * @param buf - Serialized asset reference bytes
+     * @returns Decoded asset reference
+     * @throws Error if the buffer is empty or malformed
+     */
     static fromBytes(buf: Uint8Array): AssetRef;
+    /**
+     * Serialize the asset reference to raw bytes.
+     *
+     * @returns Serialized asset reference bytes
+     * @see fromBytes
+     */
     serialize(): Uint8Array;
+    /**
+     * Encode the asset reference to a hex string.
+     *
+     * @returns Hex-encoded asset reference
+     * @see fromString
+     */
     toString(): string;
+    /**
+     * Decode an asset reference from a binary reader.
+     *
+     * @param reader - Reader positioned at an asset reference
+     * @returns Decoded asset reference
+     * @throws Error if the type is unknown or the reader does not contain enough bytes
+     */
     static fromReader(reader: BufferReader): AssetRef;
+    /**
+     * Serialize the asset reference into an existing binary writer.
+     *
+     * @param writer - Writer to append the asset reference to
+     * @see serialize
+     */
     serializeTo(writer: BufferWriter): void;
 }
 export {};

package/dist/types/extension/asset/metadata.d.ts

@@ -9,15 +9,23 @@ export declare class Metadata {
     readonly key: Uint8Array;
     readonly value: Uint8Array;
     private constructor();
+    /** Create a metadata entry from raw key and value bytes. */
     static create(key: Bytes, value: Bytes): Metadata;
+    /** Decode metadata from its hex string form. */
     static fromString(s: string): Metadata;
+    /** Decode metadata from its serialized bytes. */
     static fromBytes(buf: Uint8Array): Metadata;
+    /** Serialize metadata to raw bytes. */
     serialize(): Uint8Array;
+    /** Encode metadata to a hex string. */
     toString(): string;
     get keyString(): string;
     get valueString(): string;
+    /** Validate the metadata key and value. */
     validate(): void;
+    /** Decode metadata from a buffer reader. */
     static fromReader(reader: BufferReader): Metadata;
+    /** Serialize metadata into an existing buffer writer. */
     serializeTo(writer: BufferWriter): void;
 }
 export declare class MetadataList {
@@ -26,12 +34,19 @@ export declare class MetadataList {
     static readonly ARK_BRANCH_TAG = "ArkadeAssetBranch";
     static readonly ARK_LEAF_VERSION = 0;
     constructor(items: Metadata[]);
+    /** Create a metadata list from its hex string form. */
     static fromString(s: string): MetadataList;
+    /** Decode a metadata list from its serialized bytes. */
     static fromBytes(buf: Uint8Array): MetadataList;
+    /** Decode a metadata list from a buffer reader. */
     static fromReader(reader: BufferReader): MetadataList;
+    /** Serialize the metadata list into an existing buffer writer. */
     serializeTo(writer: BufferWriter): void;
+    /** Serialize the metadata list to raw bytes. */
     serialize(): Uint8Array;
+    /** Iterate through metadata entries in insertion order. */
     [Symbol.iterator](): Iterator<Metadata>;
     get length(): number;
+    /** Compute the tagged Merkle root for the metadata list. */
     hash(): Uint8Array;
 }

package/dist/types/extension/asset/packet.d.ts

@@ -9,6 +9,7 @@ export declare class Packet implements ExtensionPacket {
     /** PACKET_TYPE is the 1-byte TLV type tag used in the Extension envelope. */
     static readonly PACKET_TYPE = 0;
     private constructor();
+    /** Create a validated asset packet from a list of asset groups. */
     static create(groups: AssetGroup[]): Packet;
     /**
      * fromBytes parses a Packet from raw bytes.
@@ -22,10 +23,11 @@ export declare class Packet implements ExtensionPacket {
      * type returns the TLV packet type tag. Implements ExtensionPacket interface.
      */
     type(): number;
+    /** Convert the packet into the batch-leaf form for a specific intent transaction id. */
     leafTxPacket(intentTxid: Uint8Array): Packet;
     /**
      * serialize encodes the packet as raw bytes (varint group count + group data).
-     * Does NOT include OP_RETURN, ARK magic, or TLV type/length — those are
+     * Does NOT include OP_RETURN, Arkade magic bytes (`ARK`), or TLV type/length; those are
      * added by the Extension module.
      */
     serialize(): Uint8Array;
@@ -33,6 +35,7 @@ export declare class Packet implements ExtensionPacket {
      * toString returns the hex-encoded raw packet bytes.
      */
     toString(): string;
+    /** Validate packet structure and cross-group references. */
     validate(): void;
     private static fromReader;
 }

package/dist/types/extension/index.d.ts

@@ -6,7 +6,7 @@ export type { ExtensionPacket } from "./packet";
 export { UnknownPacket } from "./packet";
 /**
  * ArkadeMagic is the 3-byte magic prefix ("ARK") that identifies an OP_RETURN
- * output as an ark extension blob.
+ * output as an Arkade extension blob.
  */
 export declare const ARKADE_MAGIC: Uint8Array<ArrayBuffer>;
 /**

package/dist/types/forfeit.d.ts

@@ -1,4 +1,18 @@
 import { Transaction } from "./utils/transaction";
 import { TransactionInputUpdate, TransactionOutput } from "@scure/btc-signer/psbt.js";
+/**
+ * Build a forfeit transaction that spends the provided inputs to a single forfeit output.
+ *
+ * @param inputs - Inputs to include in the forfeit transaction
+ * @param forfeitPkScript - ScriptPubKey for the forfeit output
+ * @param txLocktime - Optional locktime to apply to the transaction
+ */
 export declare function buildForfeitTx(inputs: TransactionInputUpdate[], forfeitPkScript: Uint8Array, txLocktime?: number): Transaction;
+/**
+ * Build a forfeit transaction using an explicit output descriptor (used for delegated renewals)
+ *
+ * @param inputs - Inputs to include in the forfeit transaction
+ * @param output - Primary transaction output
+ * @param txLocktime - Optional locktime to apply to the transaction
+ */
 export declare function buildForfeitTxWithOutput(inputs: TransactionInputUpdate[], output: TransactionOutput, txLocktime?: number): Transaction;

package/dist/types/identity/index.d.ts

@@ -1,12 +1,22 @@
 import { Transaction } from "../utils/transaction";
 import { SignerSession } from "../tree/signingSession";
 export interface Identity extends ReadonlyIdentity {
+    /** Returns a signer session used for musig2 tree signing flows. */
     signerSession(): SignerSession;
+    /** Sign an arbitrary message using the requested signature type. */
     signMessage(message: Uint8Array, signatureType: "schnorr" | "ecdsa"): Promise<Uint8Array>;
+    /**
+     * Sign the provided transaction inputs.
+     *
+     * @param tx - Transaction to sign
+     * @param inputIndexes - Optional input indexes to sign. When omitted, the implementation should sign every signable input.
+     */
     sign(tx: Transaction, inputIndexes?: number[]): Promise<Transaction>;
 }
 export interface ReadonlyIdentity {
+    /** Returns the x-only public key used by Taproot scripts. */
     xOnlyPublicKey(): Promise<Uint8Array>;
+    /** Returns the compressed public key for this identity. */
     compressedPublicKey(): Promise<Uint8Array>;
 }
 /** A single PSBT signing request within a batch. */
@@ -25,6 +35,12 @@ export interface SignRequest {
  * will throw if the lengths do not match.
  */
 export interface BatchSignableIdentity extends Identity {
+    /**
+     * Sign multiple transactions in a single wallet interaction.
+     *
+     * @param requests - Transactions and optional input indexes to sign
+     * @returns Signed transactions in the same order as the input requests
+     */
     signMultiple(requests: SignRequest[]): Promise<Transaction[]>;
 }
 /** Type guard for identities that support batch signing. */

package/dist/types/identity/seedIdentity.d.ts

@@ -1,21 +1,23 @@
 import { Identity, ReadonlyIdentity } from ".";
 import { Transaction } from "../utils/transaction";
 import { SignerSession } from "../tree/signingSession";
-/** Use default BIP86 derivation with network selection. */
+/** Used for default BIP86 derivation with network selection. */
 export interface NetworkOptions {
     /**
      * Mainnet (coin type 0) or testnet (coin type 1).
-     * @default true
+     *
+     * @defaultValue `true`
      */
     isMainnet?: boolean;
 }
-/** Use a custom output descriptor for derivation. */
+/** Used for custom output descriptor derivation. */
 export interface DescriptorOptions {
     /** Custom output descriptor that determines the derivation path. */
     descriptor: string;
 }
-/** Either default BIP86 derivation (with optional network) or a custom descriptor. */
+/** Either default BIP86 derivation (with optional network selection) or a custom descriptor. */
 export type SeedIdentityOptions = NetworkOptions | DescriptorOptions;
+/** Used for deriving an identity from a BIP39 mnemonic. */
 export type MnemonicOptions = SeedIdentityOptions & {
     /** Optional BIP39 passphrase for additional seed entropy. */
     passphrase?: string;
@@ -29,7 +31,7 @@ export type MnemonicOptions = SeedIdentityOptions & {
  * format is HD-ready, allowing future support for multiple addresses
  * and change derivation.
  *
- * Prefer this (or {@link MnemonicIdentity}) over `SingleKey` for new
+ * Prefer this (or @see MnemonicIdentity) over `SingleKey` for new
  * integrations — `SingleKey` exists for backward compatibility with
  * raw nsec-style keys.
  *
@@ -77,7 +79,7 @@ export declare class SeedIdentity implements Identity {
  *
  * This is the most user-friendly identity type — recommended for wallet
  * applications where users manage their own backup phrase. Extends
- * {@link SeedIdentity} with mnemonic validation and optional passphrase
+ * @see SeedIdentity with mnemonic validation and optional passphrase
  * support.
  *
  * @example

package/dist/types/identity/singleKey.d.ts

@@ -22,8 +22,11 @@ import { SignerSession } from "../tree/signingSession";
 export declare class SingleKey implements Identity {
     private key;
     private constructor();
+    /** Create a signing identity from raw private key bytes. */
     static fromPrivateKey(privateKey: Uint8Array): SingleKey;
+    /** Create a signing identity from a hex-encoded private key. */
     static fromHex(privateKeyHex: string): SingleKey;
+    /** Create a signing identity with a freshly generated random private key. */
     static fromRandomBytes(): SingleKey;
     /**
      * Export the private key as a hex string.
@@ -40,6 +43,7 @@ export declare class SingleKey implements Identity {
 }
 export declare class ReadonlySingleKey implements ReadonlyIdentity {
     private readonly publicKey;
+    /** Create a readonly identity from a compressed public key. */
     constructor(publicKey: Uint8Array);
     /**
      * Create a ReadonlySingleKey from a compressed public key.

package/dist/types/intent/index.d.ts

@@ -5,10 +5,11 @@ import { ExtendedCoin } from "../wallet";
  * Intent proof implementation for Bitcoin message signing.
  *
  * Intent proof defines a standard for signing Bitcoin messages as well as proving
- * ownership of coins. This namespace provides utilities for creating and
- * validating Intent proof.
+ * ownership of outputs.
  *
- * it is greatly inspired by BIP322.
+ * This namespace provides utilities for creating and validating Intent proof.
+ *
+ * It is greatly inspired by BIP322.
  * @see https://github.com/bitcoin/bips/blob/master/bip-0322.mediawiki
  *
  * @example
@@ -30,15 +31,21 @@ export declare namespace Intent {
      * Creates a new Intent proof unsigned transaction.
      *
      * This function constructs a special transaction that can be signed to prove
-     * ownership of VTXOs and UTXOs. The proof includes the message to be
+     * ownership of onchain and virtual outputs. The proof includes the message to be
      * signed and the inputs/outputs that demonstrate ownership.
      *
      * @param message - The Intent message to be signed, either raw string of Message object
-     * @param inputs - Array of transaction inputs to prove ownership of
+     * @param ins - Array of transaction inputs to prove ownership of
      * @param outputs - Optional array of transaction outputs
      * @returns An unsigned Intent proof transaction
      */
     function create(message: string | Message, ins: (TransactionInput | ExtendedCoin)[], outputs?: TransactionOutput[]): Proof;
+    /**
+     * Compute the fee paid by an intent proof transaction.
+     *
+     * @param proof - Intent proof transaction
+     * @returns The fee in satoshis
+     */
     function fee(proof: Proof): number;
     type RegisterMessage = {
         type: "register";
@@ -56,6 +63,12 @@ export declare namespace Intent {
         expire_at: number;
     };
     type Message = RegisterMessage | DeleteMessage | GetPendingTxMessage;
+    /**
+     * Serialize an intent message to the canonical JSON string used for signing.
+     *
+     * @param message - Intent message payload
+     * @returns Canonical string form of the message
+     */
     function encodeMessage(message: Message): string;
 }
 export declare const OP_RETURN_EMPTY_PKSCRIPT: Uint8Array<ArrayBuffer>;
@@ -68,6 +81,6 @@ export declare const TAG_INTENT_PROOF = "ark-intent-proof-message";
  *
  * @param message - The message to embed
  * @param pkScript - The scriptPubKey of the signer's address
- * @param tag - Tagged-hash tag (defaults to the Ark intent proof tag)
+ * @param tag - Tagged-hash tag (defaults to the Arkade intent proof tag)
  */
 export declare function craftToSpendTx(message: string, pkScript: Uint8Array, tag?: string): Transaction;