@ottochain/sdk 0.2.0

package/dist/esm/generated/ottochain/v1/records_pb.js

@@ -0,0 +1,41 @@
+// @generated by protoc-gen-es v2.2.0 with parameter "target=ts,import_extension=.js"
+// @generated from file ottochain/v1/records.proto (package ottochain.v1, syntax proto3)
+/* eslint-disable */
+import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv1";
+import { file_ottochain_v1_common } from "./common_pb.js";
+import { file_ottochain_v1_fiber } from "./fiber_pb.js";
+import { file_google_protobuf_struct } from "@bufbuild/protobuf/wkt";
+/**
+ * Describes the file ottochain/v1/records.proto.
+ */
+export const file_ottochain_v1_records = /*@__PURE__*/ fileDesc("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", [file_ottochain_v1_common, file_ottochain_v1_fiber, file_google_protobuf_struct]);
+/**
+ * Describes the message ottochain.v1.StateMachineFiberRecord.
+ * Use `create(StateMachineFiberRecordSchema)` to create a new message.
+ */
+export const StateMachineFiberRecordSchema = /*@__PURE__*/ messageDesc(file_ottochain_v1_records, 0);
+/**
+ * Describes the message ottochain.v1.ScriptFiberRecord.
+ * Use `create(ScriptFiberRecordSchema)` to create a new message.
+ */
+export const ScriptFiberRecordSchema = /*@__PURE__*/ messageDesc(file_ottochain_v1_records, 1);
+/**
+ * Describes the message ottochain.v1.FiberCommit.
+ * Use `create(FiberCommitSchema)` to create a new message.
+ */
+export const FiberCommitSchema = /*@__PURE__*/ messageDesc(file_ottochain_v1_records, 2);
+/**
+ * Describes the message ottochain.v1.OnChainState.
+ * Use `create(OnChainStateSchema)` to create a new message.
+ */
+export const OnChainStateSchema = /*@__PURE__*/ messageDesc(file_ottochain_v1_records, 3);
+/**
+ * Describes the message ottochain.v1.FiberLogEntryList.
+ * Use `create(FiberLogEntryListSchema)` to create a new message.
+ */
+export const FiberLogEntryListSchema = /*@__PURE__*/ messageDesc(file_ottochain_v1_records, 4);
+/**
+ * Describes the message ottochain.v1.CalculatedState.
+ * Use `create(CalculatedStateSchema)` to create a new message.
+ */
+export const CalculatedStateSchema = /*@__PURE__*/ messageDesc(file_ottochain_v1_records, 5);

package/dist/esm/index.js

@@ -0,0 +1,33 @@
+/**
+ * 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
+ */
+// Type aliases for semantic clarity (matches wire format)
+export * from './types.js';
+// Metakit utilities (signing, hashing, HTTP client)
+export * from './metakit/index.js';
+// Generated protobuf types (canonical definitions)
+export * from './generated/index.js';
+// Custom error classes
+export { OttoChainError, NetworkError, ValidationError, SigningError, TransactionError, ErrorCode, isErrorCode, wrapError, } from './errors.js';
+// Validation schemas and helpers
+export { 
+// Schemas
+DagAddressSchema, PrivateKeySchema, PublicKeySchema, KeyPairSchema, SignatureProofSchema, SignedSchema, TransactionReferenceSchema, CurrencyTransactionValueSchema, CurrencyTransactionSchema, TransferParamsSchema, AgentIdentityRegistrationSchema, PlatformLinkSchema, ContractTermsSchema, ProposeContractRequestSchema, AcceptContractRequestSchema, CompleteContractRequestSchema, 
+// Helpers
+validate, validatePrivateKey, validatePublicKey, validateAddress, validateKeyPair, safeParse, assert, } from './validation.js';
+// Error classes
+export * from './errors.js';
+// Validation schemas and helpers
+export * from './validation.js';

package/dist/esm/metakit/binary.js

@@ -0,0 +1,53 @@
+/**
+ * Binary Encoding
+ *
+ * Converts JSON data to binary format for cryptographic operations.
+ * Supports both regular encoding and DataUpdate encoding with Constellation prefix.
+ */
+import { canonicalize } from './canonicalize.js';
+import { CONSTELLATION_PREFIX } from './types.js';
+/**
+ * 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 function toBytes(data, isDataUpdate = false) {
+    const canonicalJson = canonicalize(data);
+    const utf8Bytes = new TextEncoder().encode(canonicalJson);
+    if (isDataUpdate) {
+        // Base64 encode the UTF-8 bytes
+        const base64String = Buffer.from(utf8Bytes).toString('base64');
+        // Create the wrapped string with Constellation prefix
+        const wrappedString = `${CONSTELLATION_PREFIX}${base64String.length}\n${base64String}`;
+        return new TextEncoder().encode(wrappedString);
+    }
+    return utf8Bytes;
+}
+/**
+ * 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 function encodeDataUpdate(data) {
+    return toBytes(data, true);
+}

package/dist/esm/metakit/canonicalize.js

@@ -0,0 +1,33 @@
+/**
+ * RFC 8785 JSON Canonicalization
+ *
+ * Provides deterministic JSON serialization according to RFC 8785.
+ * This ensures identical JSON objects always produce identical strings.
+ */
+import canonicalizeLib from 'canonicalize';
+/**
+ * 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 function canonicalize(data) {
+    const result = canonicalizeLib(data);
+    if (result === undefined) {
+        throw new Error('Failed to canonicalize data: data cannot be serialized to JSON');
+    }
+    return result;
+}

package/dist/esm/metakit/codec.js

@@ -0,0 +1,38 @@
+/**
+ * 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 function decodeDataUpdate(bytes) {
+    const text = new TextDecoder().decode(bytes);
+    // Validate prefix
+    if (!text.startsWith('\x19Constellation Signed Data:\n')) {
+        throw new Error('Invalid DataUpdate encoding: missing Constellation prefix');
+    }
+    // Parse the format: \x19Constellation Signed Data:\n{length}\n{base64}
+    const withoutPrefix = text.slice('\x19Constellation Signed Data:\n'.length);
+    const newlineIndex = withoutPrefix.indexOf('\n');
+    if (newlineIndex === -1) {
+        throw new Error('Invalid DataUpdate encoding: missing length delimiter');
+    }
+    const lengthStr = withoutPrefix.slice(0, newlineIndex);
+    const base64Data = withoutPrefix.slice(newlineIndex + 1);
+    const expectedLength = parseInt(lengthStr, 10);
+    if (isNaN(expectedLength) || base64Data.length !== expectedLength) {
+        throw new Error('Invalid DataUpdate encoding: length mismatch');
+    }
+    // Decode base64 to UTF-8 JSON
+    const jsonBytes = Buffer.from(base64Data, 'base64');
+    const jsonString = new TextDecoder().decode(jsonBytes);
+    return JSON.parse(jsonString);
+}

package/dist/esm/metakit/currency-transaction.js

@@ -0,0 +1,306 @@
+/**
+ * Currency transaction operations for metagraph token transfers
+ *
+ * @packageDocumentation
+ */
+import { TransactionV2, txEncode, keyStore, } from '@stardust-collective/dag4-keystore';
+import { TOKEN_DECIMALS } from './currency-types.js';
+import { getAddress } from './wallet.js';
+import { normalizeSignatureToLowS } from './verify.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 function tokenToUnits(amount) {
+    return Math.floor(amount * 1e8);
+}
+/**
+ * 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 function unitsToToken(units) {
+    return units * TOKEN_DECIMALS;
+}
+/**
+ * Validate DAG address format
+ *
+ * @param address - DAG address to validate
+ * @returns True if address is valid
+ *
+ * @example
+ * ```typescript
+ * const valid = isValidDagAddress('DAG...');
+ * ```
+ */
+export function isValidDagAddress(address) {
+    return keyStore.validateDagAddress(address);
+}
+/**
+ * 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 async function createCurrencyTransaction(params, privateKey, lastRef) {
+    // Get source address from private key
+    const publicKey = keyStore.getPublicKeyFromPrivate(privateKey);
+    const source = getAddress(publicKey);
+    // Validate addresses
+    if (!isValidDagAddress(source)) {
+        throw new Error('Invalid source address');
+    }
+    if (!isValidDagAddress(params.destination)) {
+        throw new Error('Invalid destination address');
+    }
+    if (source === params.destination) {
+        throw new Error('Source and destination addresses cannot be the same');
+    }
+    // Convert amounts to smallest units
+    const amount = tokenToUnits(params.amount);
+    const fee = tokenToUnits(params.fee ?? 0);
+    // Validate amounts
+    if (amount < 1) {
+        throw new Error('Transfer amount must be greater than 1e-8');
+    }
+    if (fee < 0) {
+        throw new Error('Fee must be greater than or equal to zero');
+    }
+    // Use dag4.js TransactionV2 to create and encode the transaction
+    const txProps = {
+        fromAddress: source,
+        toAddress: params.destination,
+        amount,
+        fee,
+        lastTxRef: lastRef,
+    };
+    const tx = new TransactionV2(txProps);
+    // Get encoded transaction for hashing
+    const encodedTx = tx.getEncoded();
+    // Kryo serialize - v2 uses setReferences = false (matching dag4.js behavior)
+    const serializedTx = txEncode.kryoSerialize(encodedTx, false);
+    // Hash the serialized transaction
+    const hash = keyStore.sha256(Buffer.from(serializedTx, 'hex'));
+    // Sign the hash
+    const signature = await keyStore.sign(privateKey, hash);
+    // Get uncompressed public key
+    const uncompressedPublicKey = publicKey.length === 128 ? '04' + publicKey : publicKey;
+    // Verify signature
+    const success = keyStore.verify(uncompressedPublicKey, hash, signature);
+    if (!success) {
+        throw new Error('Sign-Verify failed');
+    }
+    // Add signature proof (remove '04' prefix from public key)
+    const proof = {
+        id: uncompressedPublicKey.substring(2),
+        signature,
+    };
+    tx.addSignature(proof);
+    return tx.getPostTransaction();
+}
+/**
+ * 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 async function createCurrencyTransactionBatch(transfers, privateKey, lastRef) {
+    const transactions = [];
+    let currentRef = { ...lastRef };
+    for (const transfer of transfers) {
+        const tx = await createCurrencyTransaction(transfer, privateKey, currentRef);
+        // Calculate hash for next transaction's parent reference
+        const hash = await hashCurrencyTransaction(tx);
+        // Update reference for next transaction
+        currentRef = {
+            hash: hash.value,
+            ordinal: currentRef.ordinal + 1,
+        };
+        transactions.push(tx);
+    }
+    return transactions;
+}
+/**
+ * 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 async function signCurrencyTransaction(transaction, privateKey) {
+    // Reconstruct TransactionV2 from PostTransaction
+    const tx = TransactionV2.fromPostTransaction(transaction);
+    // Restore existing proofs (fromPostTransaction doesn't copy them)
+    for (const existingProof of transaction.proofs) {
+        tx.addSignature(existingProof);
+    }
+    // Get encoded transaction
+    const encodedTx = tx.getEncoded();
+    // Kryo serialize - v2 uses setReferences = false (matching dag4.js behavior)
+    const serializedTx = txEncode.kryoSerialize(encodedTx, false);
+    const hash = keyStore.sha256(Buffer.from(serializedTx, 'hex'));
+    // Sign the hash
+    const publicKey = keyStore.getPublicKeyFromPrivate(privateKey);
+    const signature = await keyStore.sign(privateKey, hash);
+    // Verify signature
+    const uncompressedPublicKey = publicKey.length === 128 ? '04' + publicKey : publicKey;
+    const success = keyStore.verify(uncompressedPublicKey, hash, signature);
+    if (!success) {
+        throw new Error('Sign-Verify failed');
+    }
+    // Add new proof
+    const proof = {
+        id: uncompressedPublicKey.substring(2),
+        signature,
+    };
+    tx.addSignature(proof);
+    return tx.getPostTransaction();
+}
+/**
+ * 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 async function verifyCurrencyTransaction(transaction) {
+    // Reconstruct TransactionV2 to get encoded form
+    const tx = TransactionV2.fromPostTransaction(transaction);
+    // Get hash
+    const encodedTx = tx.getEncoded();
+    // Kryo serialize - v2 uses setReferences = false (matching dag4.js behavior)
+    const serializedTx = txEncode.kryoSerialize(encodedTx, false);
+    const hash = keyStore.sha256(Buffer.from(serializedTx, 'hex'));
+    const validProofs = [];
+    const invalidProofs = [];
+    // Verify each proof
+    for (const proof of transaction.proofs) {
+        const publicKey = '04' + proof.id; // Add back the '04' prefix
+        // Normalize signature to low-S form for BIP 62/146 compatibility
+        const normalizedSignature = normalizeSignatureToLowS(proof.signature);
+        const isValid = keyStore.verify(publicKey, hash, normalizedSignature);
+        if (isValid) {
+            validProofs.push(proof);
+        }
+        else {
+            invalidProofs.push(proof);
+        }
+    }
+    return {
+        isValid: invalidProofs.length === 0 && validProofs.length > 0,
+        validProofs,
+        invalidProofs,
+    };
+}
+/**
+ * Encode a currency transaction for hashing
+ *
+ * @param transaction - Transaction to encode
+ * @returns Hex-encoded string
+ *
+ * @example
+ * ```typescript
+ * const encoded = encodeCurrencyTransaction(tx);
+ * ```
+ */
+export function encodeCurrencyTransaction(transaction) {
+    const tx = TransactionV2.fromPostTransaction(transaction);
+    return tx.getEncoded();
+}
+/**
+ * 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 async function hashCurrencyTransaction(transaction) {
+    const encoded = encodeCurrencyTransaction(transaction);
+    // Kryo serialize - v2 uses setReferences = false (matching dag4.js behavior)
+    const serialized = txEncode.kryoSerialize(encoded, false);
+    const hash = keyStore.sha256(Buffer.from(serialized, 'hex'));
+    return {
+        value: hash,
+        bytes: Buffer.from(hash, 'hex'),
+    };
+}
+/**
+ * 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 async function getTransactionReference(transaction, ordinal) {
+    const hash = await hashCurrencyTransaction(transaction);
+    return {
+        hash: hash.value,
+        ordinal,
+    };
+}

package/dist/esm/metakit/currency-types.js

@@ -0,0 +1,10 @@
+/**
+ * Currency transaction types for metagraph token transfers
+ *
+ * @packageDocumentation
+ */
+/**
+ * Token decimals constant (1e-8)
+ * Same as DAG_DECIMALS from dag4.js
+ */
+export const TOKEN_DECIMALS = 1e-8;

package/dist/esm/metakit/hash.js

@@ -0,0 +1,77 @@
+/**
+ * Hashing Utilities
+ *
+ * SHA-256 and SHA-512 hashing for the Constellation signature protocol.
+ */
+import { sha256 } from 'js-sha256';
+import { sha512 } from 'js-sha512';
+import { toBytes } from './binary.js';
+/**
+ * Compute SHA-256 hash of canonical JSON data
+ *
+ * @param data - Any JSON-serializable object
+ * @returns Hash object with hex string and raw bytes
+ *
+ * @example
+ * ```typescript
+ * const hashResult = hash({ action: 'test' });
+ * console.log(hashResult.value); // 64-char hex string
+ * ```
+ */
+export function hash(data) {
+    const bytes = toBytes(data, false);
+    return hashBytes(bytes);
+}
+/**
+ * Compute SHA-256 hash of raw bytes
+ *
+ * @param bytes - Input bytes
+ * @returns Hash object with hex string and raw bytes
+ */
+export function hashBytes(bytes) {
+    const hashArray = sha256.array(bytes);
+    const hashUint8 = new Uint8Array(hashArray);
+    const hashHex = sha256.hex(bytes);
+    return {
+        value: hashHex,
+        bytes: hashUint8,
+    };
+}
+/**
+ * Compute the full signing digest according to Constellation protocol
+ *
+ * Protocol:
+ * 1. Serialize data to binary (with optional DataUpdate prefix)
+ * 2. Compute SHA-256 hash
+ * 3. Convert hash to hex string
+ * 4. Treat hex string as UTF-8 bytes (NOT hex decode)
+ * 5. Compute SHA-512 of those bytes
+ * 6. Truncate to 32 bytes for secp256k1 signing
+ *
+ * @param data - Any JSON-serializable object
+ * @param isDataUpdate - Whether to apply DataUpdate encoding
+ * @returns 32-byte digest ready for ECDSA signing
+ */
+export function computeDigest(data, isDataUpdate = false) {
+    // Step 1: Serialize to binary
+    const dataBytes = toBytes(data, isDataUpdate);
+    // Step 2: SHA-256 hash
+    const sha256Hash = hashBytes(dataBytes);
+    // Step 3-4: Hex string as UTF-8 bytes (critical: NOT hex decode)
+    const hexAsUtf8 = new TextEncoder().encode(sha256Hash.value);
+    // Step 5: SHA-512
+    const sha512Hash = sha512.array(hexAsUtf8);
+    // Step 6: Truncate to 32 bytes
+    return new Uint8Array(sha512Hash.slice(0, 32));
+}
+/**
+ * Compute SHA-256 hash of data with optional DataUpdate encoding
+ *
+ * @param data - Any JSON-serializable object
+ * @param isDataUpdate - Whether to apply DataUpdate encoding
+ * @returns Hash object
+ */
+export function hashData(data, isDataUpdate = false) {
+    const bytes = toBytes(data, isDataUpdate);
+    return hashBytes(bytes);
+}

package/dist/esm/metakit/index.js

@@ -0,0 +1,30 @@
+/**
+ * Metakit SDK
+ *
+ * Reusable signing, encoding, and network operations for Constellation metagraphs.
+ * This module is framework-level functionality, independent of any specific metagraph domain.
+ *
+ * @packageDocumentation
+ */
+export { ALGORITHM, CONSTELLATION_PREFIX } from './types.js';
+// Canonicalization
+export { canonicalize } from './canonicalize.js';
+// Binary encoding
+export { toBytes, encodeDataUpdate } from './binary.js';
+// Hashing
+export { hash, hashBytes, hashData, computeDigest } from './hash.js';
+// Codec utilities
+export { decodeDataUpdate } from './codec.js';
+// Signing
+export { sign, signDataUpdate, signHash } from './sign.js';
+// Verification
+export { verify, verifyHash, verifySignature } from './verify.js';
+// High-level API
+export { createSignedObject, addSignature, batchSign } from './signed-object.js';
+// Wallet utilities
+export { generateKeyPair, keyPairFromPrivateKey, getPublicKeyHex, getPublicKeyId, getAddress, isValidPrivateKey, isValidPublicKey, } from './wallet.js';
+export { TOKEN_DECIMALS } from './currency-types.js';
+// Currency transaction operations
+export { createCurrencyTransaction, createCurrencyTransactionBatch, signCurrencyTransaction, verifyCurrencyTransaction, encodeCurrencyTransaction, hashCurrencyTransaction, getTransactionReference, isValidDagAddress, tokenToUnits, unitsToToken, } from './currency-transaction.js';
+// Network operations
+export { CurrencyL1Client, DataL1Client, HttpClient, NetworkError } from './network/index.js';