@ottochain/sdk 0.2.0

package/dist/types/generated/ottochain/v1/records.d.ts

@@ -0,0 +1,128 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import { AccessControlPolicy, EventReceipt, FiberLogEntry, FiberStatus, ScriptInvocation, StateMachineDefinition } from "./fiber.js";
+export declare const protobufPackage = "ottochain.v1";
+/** State machine fiber record - on-chain representation */
+export interface StateMachineFiberRecord {
+    fiberId: string;
+    /** Snapshot ordinal */
+    creationOrdinal: number;
+    /** Snapshot ordinal */
+    previousUpdateOrdinal: number;
+    /** Snapshot ordinal */
+    latestUpdateOrdinal: number;
+    definition?: StateMachineDefinition | undefined;
+    /** State ID */
+    currentState: string;
+    stateData?: any | undefined;
+    /** Hash value */
+    stateDataHash: string;
+    /** Fiber ordinal */
+    sequenceNumber: number;
+    /** DAG addresses */
+    owners: string[];
+    status: FiberStatus;
+    lastReceipt?: EventReceipt | undefined;
+    parentFiberId?: string | undefined;
+    childFiberIds: string[];
+}
+/** Script fiber record - on-chain representation */
+export interface ScriptFiberRecord {
+    fiberId: string;
+    /** Snapshot ordinal */
+    creationOrdinal: number;
+    /** Snapshot ordinal */
+    latestUpdateOrdinal: number;
+    scriptProgram?: any | undefined;
+    stateData?: any | undefined;
+    /** Hash value */
+    stateDataHash?: string | undefined;
+    accessControl?: AccessControlPolicy | undefined;
+    /** Fiber ordinal */
+    sequenceNumber: number;
+    /** DAG addresses */
+    owners: string[];
+    status: FiberStatus;
+    lastInvocation?: ScriptInvocation | undefined;
+}
+/** Fiber commit - lightweight proof in on-chain state */
+export interface FiberCommit {
+    /** Hash value */
+    recordHash: string;
+    /** Hash value */
+    stateDataHash?: string | undefined;
+    /** Fiber ordinal */
+    sequenceNumber: number;
+}
+/** On-chain state */
+export interface OnChainState {
+    fiberCommits: {
+        [key: string]: FiberCommit;
+    };
+    latestLogs: {
+        [key: string]: FiberLogEntryList;
+    };
+}
+export interface OnChainState_FiberCommitsEntry {
+    key: string;
+    value?: FiberCommit | undefined;
+}
+export interface OnChainState_LatestLogsEntry {
+    key: string;
+    value?: FiberLogEntryList | undefined;
+}
+/** Helper for map of log entries */
+export interface FiberLogEntryList {
+    entries: FiberLogEntry[];
+}
+/** Calculated state - queryable via ML0 endpoints */
+export interface CalculatedState {
+    stateMachines: {
+        [key: string]: StateMachineFiberRecord;
+    };
+    scripts: {
+        [key: string]: ScriptFiberRecord;
+    };
+}
+export interface CalculatedState_StateMachinesEntry {
+    key: string;
+    value?: StateMachineFiberRecord | undefined;
+}
+export interface CalculatedState_ScriptsEntry {
+    key: string;
+    value?: ScriptFiberRecord | undefined;
+}
+export declare const StateMachineFiberRecord: MessageFns<StateMachineFiberRecord>;
+export declare const ScriptFiberRecord: MessageFns<ScriptFiberRecord>;
+export declare const FiberCommit: MessageFns<FiberCommit>;
+export declare const OnChainState: MessageFns<OnChainState>;
+export declare const OnChainState_FiberCommitsEntry: MessageFns<OnChainState_FiberCommitsEntry>;
+export declare const OnChainState_LatestLogsEntry: MessageFns<OnChainState_LatestLogsEntry>;
+export declare const FiberLogEntryList: MessageFns<FiberLogEntryList>;
+export declare const CalculatedState: MessageFns<CalculatedState>;
+export declare const CalculatedState_StateMachinesEntry: MessageFns<CalculatedState_StateMachinesEntry>;
+export declare const CalculatedState_ScriptsEntry: MessageFns<CalculatedState_ScriptsEntry>;
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+export type DeepPartial<T> = T extends Builtin ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
+    $case: string;
+} ? {
+    [K in keyof Omit<T, "$case">]?: DeepPartial<T[K]>;
+} & {
+    $case: T["$case"];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & {
+    [K in Exclude<keyof I, KeysOfUnion<P>>]: never;
+};
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create<I extends Exact<DeepPartial<T>, I>>(base?: I): T;
+    fromPartial<I extends Exact<DeepPartial<T>, I>>(object: I): T;
+}
+export {};

package/dist/types/generated/ottochain/v1/records_pb.d.ts

@@ -0,0 +1,221 @@
+import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv1";
+import type { Address, FiberOrdinal, HashValue, SnapshotOrdinal, StateId } from "./common_pb.js";
+import type { AccessControlPolicy, EventReceipt, FiberLogEntry, FiberStatus, ScriptInvocation, StateMachineDefinition } from "./fiber_pb.js";
+import type { Value } from "@bufbuild/protobuf/wkt";
+import type { Message } from "@bufbuild/protobuf";
+/**
+ * Describes the file ottochain/v1/records.proto.
+ */
+export declare const file_ottochain_v1_records: GenFile;
+/**
+ * State machine fiber record - on-chain representation
+ *
+ * @generated from message ottochain.v1.StateMachineFiberRecord
+ */
+export type StateMachineFiberRecord = Message<"ottochain.v1.StateMachineFiberRecord"> & {
+    /**
+     * @generated from field: string fiber_id = 1;
+     */
+    fiberId: string;
+    /**
+     * @generated from field: ottochain.v1.SnapshotOrdinal creation_ordinal = 2;
+     */
+    creationOrdinal?: SnapshotOrdinal;
+    /**
+     * @generated from field: ottochain.v1.SnapshotOrdinal previous_update_ordinal = 3;
+     */
+    previousUpdateOrdinal?: SnapshotOrdinal;
+    /**
+     * @generated from field: ottochain.v1.SnapshotOrdinal latest_update_ordinal = 4;
+     */
+    latestUpdateOrdinal?: SnapshotOrdinal;
+    /**
+     * @generated from field: ottochain.v1.StateMachineDefinition definition = 5;
+     */
+    definition?: StateMachineDefinition;
+    /**
+     * @generated from field: ottochain.v1.StateId current_state = 6;
+     */
+    currentState?: StateId;
+    /**
+     * @generated from field: google.protobuf.Value state_data = 7;
+     */
+    stateData?: Value;
+    /**
+     * @generated from field: ottochain.v1.HashValue state_data_hash = 8;
+     */
+    stateDataHash?: HashValue;
+    /**
+     * @generated from field: ottochain.v1.FiberOrdinal sequence_number = 9;
+     */
+    sequenceNumber?: FiberOrdinal;
+    /**
+     * @generated from field: repeated ottochain.v1.Address owners = 10;
+     */
+    owners: Address[];
+    /**
+     * @generated from field: ottochain.v1.FiberStatus status = 11;
+     */
+    status: FiberStatus;
+    /**
+     * @generated from field: optional ottochain.v1.EventReceipt last_receipt = 12;
+     */
+    lastReceipt?: EventReceipt;
+    /**
+     * @generated from field: optional string parent_fiber_id = 13;
+     */
+    parentFiberId?: string;
+    /**
+     * @generated from field: repeated string child_fiber_ids = 14;
+     */
+    childFiberIds: string[];
+};
+/**
+ * Describes the message ottochain.v1.StateMachineFiberRecord.
+ * Use `create(StateMachineFiberRecordSchema)` to create a new message.
+ */
+export declare const StateMachineFiberRecordSchema: GenMessage<StateMachineFiberRecord>;
+/**
+ * Script fiber record - on-chain representation
+ *
+ * @generated from message ottochain.v1.ScriptFiberRecord
+ */
+export type ScriptFiberRecord = Message<"ottochain.v1.ScriptFiberRecord"> & {
+    /**
+     * @generated from field: string fiber_id = 1;
+     */
+    fiberId: string;
+    /**
+     * @generated from field: ottochain.v1.SnapshotOrdinal creation_ordinal = 2;
+     */
+    creationOrdinal?: SnapshotOrdinal;
+    /**
+     * @generated from field: ottochain.v1.SnapshotOrdinal latest_update_ordinal = 3;
+     */
+    latestUpdateOrdinal?: SnapshotOrdinal;
+    /**
+     * @generated from field: google.protobuf.Value script_program = 4;
+     */
+    scriptProgram?: Value;
+    /**
+     * @generated from field: optional google.protobuf.Value state_data = 5;
+     */
+    stateData?: Value;
+    /**
+     * @generated from field: optional ottochain.v1.HashValue state_data_hash = 6;
+     */
+    stateDataHash?: HashValue;
+    /**
+     * @generated from field: ottochain.v1.AccessControlPolicy access_control = 7;
+     */
+    accessControl?: AccessControlPolicy;
+    /**
+     * @generated from field: ottochain.v1.FiberOrdinal sequence_number = 8;
+     */
+    sequenceNumber?: FiberOrdinal;
+    /**
+     * @generated from field: repeated ottochain.v1.Address owners = 9;
+     */
+    owners: Address[];
+    /**
+     * @generated from field: ottochain.v1.FiberStatus status = 10;
+     */
+    status: FiberStatus;
+    /**
+     * @generated from field: optional ottochain.v1.ScriptInvocation last_invocation = 11;
+     */
+    lastInvocation?: ScriptInvocation;
+};
+/**
+ * Describes the message ottochain.v1.ScriptFiberRecord.
+ * Use `create(ScriptFiberRecordSchema)` to create a new message.
+ */
+export declare const ScriptFiberRecordSchema: GenMessage<ScriptFiberRecord>;
+/**
+ * Fiber commit - lightweight proof in on-chain state
+ *
+ * @generated from message ottochain.v1.FiberCommit
+ */
+export type FiberCommit = Message<"ottochain.v1.FiberCommit"> & {
+    /**
+     * @generated from field: ottochain.v1.HashValue record_hash = 1;
+     */
+    recordHash?: HashValue;
+    /**
+     * @generated from field: optional ottochain.v1.HashValue state_data_hash = 2;
+     */
+    stateDataHash?: HashValue;
+    /**
+     * @generated from field: ottochain.v1.FiberOrdinal sequence_number = 3;
+     */
+    sequenceNumber?: FiberOrdinal;
+};
+/**
+ * Describes the message ottochain.v1.FiberCommit.
+ * Use `create(FiberCommitSchema)` to create a new message.
+ */
+export declare const FiberCommitSchema: GenMessage<FiberCommit>;
+/**
+ * On-chain state
+ *
+ * @generated from message ottochain.v1.OnChainState
+ */
+export type OnChainState = Message<"ottochain.v1.OnChainState"> & {
+    /**
+     * @generated from field: map<string, ottochain.v1.FiberCommit> fiber_commits = 1;
+     */
+    fiberCommits: {
+        [key: string]: FiberCommit;
+    };
+    /**
+     * @generated from field: map<string, ottochain.v1.FiberLogEntryList> latest_logs = 2;
+     */
+    latestLogs: {
+        [key: string]: FiberLogEntryList;
+    };
+};
+/**
+ * Describes the message ottochain.v1.OnChainState.
+ * Use `create(OnChainStateSchema)` to create a new message.
+ */
+export declare const OnChainStateSchema: GenMessage<OnChainState>;
+/**
+ * Helper for map of log entries
+ *
+ * @generated from message ottochain.v1.FiberLogEntryList
+ */
+export type FiberLogEntryList = Message<"ottochain.v1.FiberLogEntryList"> & {
+    /**
+     * @generated from field: repeated ottochain.v1.FiberLogEntry entries = 1;
+     */
+    entries: FiberLogEntry[];
+};
+/**
+ * Describes the message ottochain.v1.FiberLogEntryList.
+ * Use `create(FiberLogEntryListSchema)` to create a new message.
+ */
+export declare const FiberLogEntryListSchema: GenMessage<FiberLogEntryList>;
+/**
+ * Calculated state - queryable via ML0 endpoints
+ *
+ * @generated from message ottochain.v1.CalculatedState
+ */
+export type CalculatedState = Message<"ottochain.v1.CalculatedState"> & {
+    /**
+     * @generated from field: map<string, ottochain.v1.StateMachineFiberRecord> state_machines = 1;
+     */
+    stateMachines: {
+        [key: string]: StateMachineFiberRecord;
+    };
+    /**
+     * @generated from field: map<string, ottochain.v1.ScriptFiberRecord> scripts = 2;
+     */
+    scripts: {
+        [key: string]: ScriptFiberRecord;
+    };
+};
+/**
+ * Describes the message ottochain.v1.CalculatedState.
+ * Use `create(CalculatedStateSchema)` to create a new message.
+ */
+export declare const CalculatedStateSchema: GenMessage<CalculatedState>;

package/dist/types/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Ottochain SDK
+ *
+ * Unified SDK combining metakit framework operations with ottochain domain types.
+ *
+ * Structure:
+ * - `metakit` — Signing, encoding, hashing, and network clients for Constellation metagraphs
+ * - `generated` — Protobuf-generated types (source of truth)
+ * - `apps/identity` — Agent Identity application types
+ * - `apps/contracts` — Contract application types
+ * - `errors` — Custom error classes for structured error handling
+ * - `validation` — Input validation with Zod schemas
+ *
+ * @packageDocumentation
+ */
+export * from './types.js';
+export * from './metakit/index.js';
+export * from './generated/index.js';
+export { OttoChainError, NetworkError, ValidationError, SigningError, TransactionError, ErrorCode, isErrorCode, wrapError, } from './errors.js';
+export { DagAddressSchema, PrivateKeySchema, PublicKeySchema, KeyPairSchema, SignatureProofSchema, SignedSchema, TransactionReferenceSchema, CurrencyTransactionValueSchema, CurrencyTransactionSchema, TransferParamsSchema, AgentIdentityRegistrationSchema, PlatformLinkSchema, ContractTermsSchema, ProposeContractRequestSchema, AcceptContractRequestSchema, CompleteContractRequestSchema, validate, validatePrivateKey, validatePublicKey, validateAddress, validateKeyPair, safeParse, assert, type ValidatedKeyPair, type ValidatedSignatureProof, type ValidatedCurrencyTransaction, type ValidatedTransferParams, type ValidatedAgentIdentityRegistration, type ValidatedPlatformLink, type ValidatedProposeContractRequest, type ValidatedAcceptContractRequest, type ValidatedCompleteContractRequest, } from './validation.js';
+export * from './errors.js';
+export * from './validation.js';

package/dist/types/metakit/binary.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Binary Encoding
+ *
+ * Converts JSON data to binary format for cryptographic operations.
+ * Supports both regular encoding and DataUpdate encoding with Constellation prefix.
+ */
+/**
+ * Convert data to binary bytes for signing
+ *
+ * For regular data:
+ *   JSON -> RFC 8785 canonicalization -> UTF-8 bytes
+ *
+ * For DataUpdate (isDataUpdate=true):
+ *   JSON -> RFC 8785 -> UTF-8 -> Base64 -> prepend Constellation prefix -> UTF-8 bytes
+ *
+ * @param data - Any JSON-serializable object
+ * @param isDataUpdate - If true, applies DataUpdate encoding with Constellation prefix
+ * @returns Binary bytes as Uint8Array
+ *
+ * @example
+ * ```typescript
+ * // Regular encoding
+ * const bytes = toBytes({ action: 'test' });
+ *
+ * // DataUpdate encoding
+ * const updateBytes = toBytes({ action: 'test' }, true);
+ * ```
+ */
+export declare function toBytes<T>(data: T, isDataUpdate?: boolean): Uint8Array;
+/**
+ * Encode data as a DataUpdate with Constellation prefix
+ *
+ * This is equivalent to `toBytes(data, true)`.
+ *
+ * @param data - Any JSON-serializable object
+ * @returns Binary bytes with Constellation prefix
+ */
+export declare function encodeDataUpdate<T>(data: T): Uint8Array;

package/dist/types/metakit/canonicalize.d.ts

@@ -0,0 +1,26 @@
+/**
+ * RFC 8785 JSON Canonicalization
+ *
+ * Provides deterministic JSON serialization according to RFC 8785.
+ * This ensures identical JSON objects always produce identical strings.
+ */
+/**
+ * Canonicalize JSON data according to RFC 8785
+ *
+ * Key features:
+ * - Object keys sorted by UTF-16BE binary comparison
+ * - Numbers serialized in shortest decimal representation
+ * - No whitespace
+ * - Proper Unicode escaping
+ *
+ * @param data - Any JSON-serializable object
+ * @returns Canonical JSON string
+ * @throws Error if data cannot be serialized to JSON
+ *
+ * @example
+ * ```typescript
+ * const canonical = canonicalize({ b: 2, a: 1 });
+ * // Returns: '{"a":1,"b":2}'
+ * ```
+ */
+export declare function canonicalize<T>(data: T): string;

package/dist/types/metakit/codec.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Codec Utilities
+ *
+ * Encoding/decoding utilities for the Constellation signature protocol.
+ * Re-exports from binary.ts for backwards compatibility and provides additional utilities.
+ */
+export { toBytes, encodeDataUpdate } from './binary.js';
+export { CONSTELLATION_PREFIX } from './types.js';
+/**
+ * Decode a DataUpdate encoded message back to its original JSON
+ *
+ * @param bytes - DataUpdate encoded bytes
+ * @returns Decoded JSON object
+ * @throws Error if bytes are not valid DataUpdate encoding
+ */
+export declare function decodeDataUpdate<T>(bytes: Uint8Array): T;

package/dist/types/metakit/currency-transaction.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Currency transaction operations for metagraph token transfers
+ *
+ * @packageDocumentation
+ */
+import type { CurrencyTransaction, TransactionReference, TransferParams } from './currency-types.js';
+import type { VerificationResult } from './types.js';
+/**
+ * Convert token amount to smallest units
+ *
+ * @param amount - Amount in token units (e.g., 100.5)
+ * @returns Amount in smallest units (1e-8)
+ *
+ * @example
+ * ```typescript
+ * const units = tokenToUnits(100.5); // 10050000000
+ * ```
+ */
+export declare function tokenToUnits(amount: number): number;
+/**
+ * Convert smallest units to token amount
+ *
+ * @param units - Amount in smallest units
+ * @returns Amount in token units
+ *
+ * @example
+ * ```typescript
+ * const tokens = unitsToToken(10050000000); // 100.5
+ * ```
+ */
+export declare function unitsToToken(units: number): number;
+/**
+ * Validate DAG address format
+ *
+ * @param address - DAG address to validate
+ * @returns True if address is valid
+ *
+ * @example
+ * ```typescript
+ * const valid = isValidDagAddress('DAG...');
+ * ```
+ */
+export declare function isValidDagAddress(address: string): boolean;
+/**
+ * Create a metagraph token transaction
+ *
+ * @param params - Transfer parameters
+ * @param privateKey - Private key to sign with (hex string)
+ * @param lastRef - Reference to last accepted transaction
+ * @returns Signed currency transaction
+ *
+ * @throws If addresses are invalid or amount is too small
+ *
+ * @example
+ * ```typescript
+ * const tx = await createCurrencyTransaction(
+ *   { destination: 'DAG...', amount: 100.5, fee: 0 },
+ *   privateKey,
+ *   { hash: 'abc123...', ordinal: 5 }
+ * );
+ * ```
+ */
+export declare function createCurrencyTransaction(params: TransferParams, privateKey: string, lastRef: TransactionReference): Promise<CurrencyTransaction>;
+/**
+ * Create multiple metagraph token transactions (batch)
+ *
+ * @param transfers - Array of transfer parameters
+ * @param privateKey - Private key to sign with
+ * @param lastRef - Reference to last accepted transaction
+ * @returns Array of signed currency transactions
+ *
+ * @throws If any address is invalid or amount is too small
+ *
+ * @example
+ * ```typescript
+ * const txns = await createCurrencyTransactionBatch(
+ *   [
+ *     { destination: 'DAG...1', amount: 10 },
+ *     { destination: 'DAG...2', amount: 20 },
+ *   ],
+ *   privateKey,
+ *   { hash: 'abc123...', ordinal: 5 }
+ * );
+ * ```
+ */
+export declare function createCurrencyTransactionBatch(transfers: TransferParams[], privateKey: string, lastRef: TransactionReference): Promise<CurrencyTransaction[]>;
+/**
+ * Add a signature to an existing currency transaction (for multi-sig)
+ *
+ * @param transaction - Transaction to sign
+ * @param privateKey - Private key to sign with
+ * @returns Transaction with additional signature
+ *
+ * @throws If sign-verify fails
+ *
+ * @example
+ * ```typescript
+ * const signedTx = await signCurrencyTransaction(tx, privateKey2);
+ * ```
+ */
+export declare function signCurrencyTransaction(transaction: CurrencyTransaction, privateKey: string): Promise<CurrencyTransaction>;
+/**
+ * Verify all signatures on a currency transaction
+ *
+ * @param transaction - Transaction to verify
+ * @returns Verification result with valid/invalid proofs
+ *
+ * @example
+ * ```typescript
+ * const result = await verifyCurrencyTransaction(tx);
+ * console.log('Valid:', result.isValid);
+ * ```
+ */
+export declare function verifyCurrencyTransaction(transaction: CurrencyTransaction): Promise<VerificationResult>;
+/**
+ * Encode a currency transaction for hashing
+ *
+ * @param transaction - Transaction to encode
+ * @returns Hex-encoded string
+ *
+ * @example
+ * ```typescript
+ * const encoded = encodeCurrencyTransaction(tx);
+ * ```
+ */
+export declare function encodeCurrencyTransaction(transaction: CurrencyTransaction): string;
+/**
+ * Hash a currency transaction
+ *
+ * @param transaction - Transaction to hash
+ * @returns Hash object with value and bytes
+ *
+ * @example
+ * ```typescript
+ * const hash = await hashCurrencyTransaction(tx);
+ * console.log('Hash:', hash.value);
+ * ```
+ */
+export declare function hashCurrencyTransaction(transaction: CurrencyTransaction): Promise<{
+    value: string;
+    bytes: Uint8Array;
+}>;
+/**
+ * Get transaction reference from a currency transaction
+ * Useful for chaining transactions
+ *
+ * @param transaction - Transaction to extract reference from
+ * @param ordinal - Ordinal number for this transaction
+ * @returns Transaction reference
+ *
+ * @example
+ * ```typescript
+ * const ref = await getTransactionReference(tx, 6);
+ * // Use ref as lastRef for next transaction
+ * ```
+ */
+export declare function getTransactionReference(transaction: CurrencyTransaction, ordinal: number): Promise<TransactionReference>;

package/dist/types/metakit/currency-types.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Currency transaction types for metagraph token transfers
+ *
+ * @packageDocumentation
+ */
+import type { Signed } from './types.js';
+/**
+ * Reference to a previous transaction for chaining
+ */
+export interface TransactionReference {
+    /** Transaction hash */
+    hash: string;
+    /** Transaction ordinal number */
+    ordinal: number;
+}
+/**
+ * Currency transaction value structure (v2)
+ * Contains the actual transaction data before signing
+ */
+export interface CurrencyTransactionValue {
+    /** Source DAG address */
+    source: string;
+    /** Destination DAG address */
+    destination: string;
+    /** Amount in smallest units (1e-8) */
+    amount: number;
+    /** Fee in smallest units (1e-8) */
+    fee: number;
+    /** Reference to parent transaction */
+    parent: TransactionReference;
+    /** Random salt for uniqueness (as string) */
+    salt: string;
+}
+/**
+ * Currency transaction structure (v2)
+ * A signed currency transaction value
+ * Used for metagraph token transfers
+ */
+export type CurrencyTransaction = Signed<CurrencyTransactionValue>;
+/**
+ * Parameters for creating a token transfer
+ */
+export interface TransferParams {
+    /** Destination DAG address */
+    destination: string;
+    /** Amount in token units (e.g., 100.5 tokens) */
+    amount: number;
+    /** Fee in token units (defaults to 0) */
+    fee?: number;
+}
+/**
+ * Token decimals constant (1e-8)
+ * Same as DAG_DECIMALS from dag4.js
+ */
+export declare const TOKEN_DECIMALS = 1e-8;