@ottochain/sdk 1.2.0 → 1.4.0

package/dist/esm/metakit/wallet.js

@@ -1,117 +0,0 @@
-/**
- * Wallet and Key Management Utilities
- *
- * Functions for generating and managing cryptographic keys.
- */
-import { dag4 } from '@stardust-collective/dag4';
-/**
- * Generate a new random key pair
- *
- * @returns KeyPair with private key, public key, and DAG address
- *
- * @example
- * ```typescript
- * const keyPair = generateKeyPair();
- * console.log(keyPair.address);    // DAG address
- * console.log(keyPair.privateKey); // 64 char hex
- * console.log(keyPair.publicKey);  // 130 char hex (with 04 prefix)
- * ```
- */
-export function generateKeyPair() {
-    const privateKey = dag4.keyStore.generatePrivateKey();
-    return keyPairFromPrivateKey(privateKey);
-}
-/**
- * Derive a key pair from an existing private key
- *
- * @param privateKey - Private key in hex format (64 characters)
- * @returns KeyPair with private key, public key, and DAG address
- *
- * @example
- * ```typescript
- * const keyPair = keyPairFromPrivateKey(existingPrivateKey);
- * ```
- */
-export function keyPairFromPrivateKey(privateKey) {
-    // Get uncompressed public key (with 04 prefix)
-    const publicKey = dag4.keyStore.getPublicKeyFromPrivate(privateKey, false);
-    // Derive DAG address
-    const address = dag4.keyStore.getDagAddressFromPublicKey(publicKey);
-    return {
-        privateKey,
-        publicKey: normalizePublicKey(publicKey),
-        address,
-    };
-}
-/**
- * Get the public key hex from a private key
- *
- * @param privateKey - Private key in hex format
- * @param compressed - If true, returns compressed public key (33 bytes)
- * @returns Public key in hex format
- */
-export function getPublicKeyHex(privateKey, compressed = false) {
-    return dag4.keyStore.getPublicKeyFromPrivate(privateKey, compressed);
-}
-/**
- * Get the public key ID (without 04 prefix) from a private key
- *
- * This format is used in SignatureProof.id
- *
- * @param privateKey - Private key in hex format
- * @returns Public key ID (128 characters, no 04 prefix)
- */
-export function getPublicKeyId(privateKey) {
-    const publicKey = dag4.keyStore.getPublicKeyFromPrivate(privateKey, false);
-    // Remove 04 prefix if present
-    if (publicKey.length === 130 && publicKey.startsWith('04')) {
-        return publicKey.substring(2);
-    }
-    return publicKey;
-}
-/**
- * Get DAG address from a public key
- *
- * @param publicKey - Public key in hex format (with or without 04 prefix)
- * @returns DAG address string
- */
-export function getAddress(publicKey) {
-    const normalizedKey = normalizePublicKey(publicKey);
-    return dag4.keyStore.getDagAddressFromPublicKey(normalizedKey);
-}
-/**
- * Validate that a private key is correctly formatted
- *
- * @param privateKey - Private key to validate
- * @returns true if valid hex string of correct length
- */
-export function isValidPrivateKey(privateKey) {
-    if (typeof privateKey !== 'string')
-        return false;
-    if (privateKey.length !== 64)
-        return false;
-    return /^[0-9a-fA-F]+$/.test(privateKey);
-}
-/**
- * Validate that a public key is correctly formatted
- *
- * @param publicKey - Public key to validate
- * @returns true if valid hex string of correct length
- */
-export function isValidPublicKey(publicKey) {
-    if (typeof publicKey !== 'string')
-        return false;
-    // With 04 prefix: 130 chars, without: 128 chars
-    if (publicKey.length !== 128 && publicKey.length !== 130)
-        return false;
-    return /^[0-9a-fA-F]+$/.test(publicKey);
-}
-/**
- * Normalize public key to include 04 prefix
- */
-function normalizePublicKey(publicKey) {
-    if (publicKey.length === 128) {
-        return '04' + publicKey;
-    }
-    return publicKey;
-}

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

@@ -1,38 +0,0 @@
-/**
- * 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

@@ -1,26 +0,0 @@
-/**
- * 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

@@ -1,16 +0,0 @@
-/**
- * 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

@@ -1,157 +0,0 @@
-/**
- * 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

@@ -1,55 +0,0 @@
-/**
- * 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;

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

@@ -1,50 +0,0 @@
-/**
- * Hashing Utilities
- *
- * SHA-256 and SHA-512 hashing for the Constellation signature protocol.
- */
-import { Hash } from './types.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 declare function hash<T>(data: T): Hash;
-/**
- * Compute SHA-256 hash of raw bytes
- *
- * @param bytes - Input bytes
- * @returns Hash object with hex string and raw bytes
- */
-export declare function hashBytes(bytes: Uint8Array): Hash;
-/**
- * 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 declare function computeDigest<T>(data: T, isDataUpdate?: boolean): Uint8Array;
-/**
- * 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 declare function hashData<T>(data: T, isDataUpdate?: boolean): Hash;

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

@@ -1,26 +0,0 @@
-/**
- * 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 type { SignatureProof, Signed, KeyPair, Hash, VerificationResult, SigningOptions, } from './types.js';
-export { ALGORITHM, CONSTELLATION_PREFIX } from './types.js';
-export { canonicalize } from './canonicalize.js';
-export { toBytes, encodeDataUpdate } from './binary.js';
-export { hash, hashBytes, hashData, computeDigest } from './hash.js';
-export { decodeDataUpdate } from './codec.js';
-export { sign, signDataUpdate, signHash } from './sign.js';
-export { verify, verifyHash, verifySignature } from './verify.js';
-export { createSignedObject, addSignature, batchSign } from './signed-object.js';
-export { generateKeyPair, keyPairFromPrivateKey, getPublicKeyHex, getPublicKeyId, getAddress, isValidPrivateKey, isValidPublicKey, } from './wallet.js';
-export type { TransactionReference, CurrencyTransactionValue, CurrencyTransaction, TransferParams, } from './currency-types.js';
-export { TOKEN_DECIMALS } from './currency-types.js';
-export { createCurrencyTransaction, createCurrencyTransactionBatch, signCurrencyTransaction, verifyCurrencyTransaction, encodeCurrencyTransaction, hashCurrencyTransaction, getTransactionReference, isValidDagAddress, tokenToUnits, unitsToToken, } from './currency-transaction.js';
-export { CurrencyL1Client, DataL1Client, HttpClient, NetworkError } from './network/index.js';
-export type { NetworkConfig, RequestOptions, TransactionStatus, PendingTransaction, PostTransactionResponse, EstimateFeeResponse, PostDataResponse, } from './network/index.js';
-export { createTransitionPayload, createArchivePayload, createInvokeScriptPayload, signTransaction, addTransactionSignature, getPublicKeyForRegistration, } from './transaction.js';
-export { createStateMachinePayload, createScriptPayload, createDataTransactionRequest, } from './transaction.js';
-export type { CreateStateMachineParams, CreateStateMachineMessage, CreateScriptParams, CreateScriptMessage, DataTransactionRequest, TransitionParams, TransitionStateMachineMessage, ArchiveParams, ArchiveStateMachineMessage, InvokeScriptParams, InvokeScriptMessage, } from './transaction.js';

package/dist/types/metakit/network/client.d.ts

@@ -1,23 +0,0 @@
-/**
- * Base HTTP client for network operations
- *
- * @packageDocumentation
- */
-import { RequestOptions } from './types.js';
-/**
- * Simple HTTP client using native fetch
- */
-export declare class HttpClient {
-    private baseUrl;
-    private defaultTimeout;
-    constructor(baseUrl: string, timeout?: number);
-    /**
-     * Make a GET request
-     */
-    get<T>(path: string, options?: RequestOptions): Promise<T>;
-    /**
-     * Make a POST request
-     */
-    post<T>(path: string, body?: unknown, options?: RequestOptions): Promise<T>;
-    private request;
-}

package/dist/types/metakit/network/currency-l1-client.d.ts

@@ -1,71 +0,0 @@
-/**
- * Currency L1 client for submitting and querying transactions
- *
- * @packageDocumentation
- */
-import type { NetworkConfig, PendingTransaction, PostTransactionResponse, RequestOptions } from './types.js';
-import type { TransactionReference, CurrencyTransaction } from '../currency-types.js';
-/**
- * Client for interacting with Currency L1 nodes
- *
- * @example
- * ```typescript
- * const client = new CurrencyL1Client({ l1Url: 'http://localhost:9010' });
- *
- * // Get last reference for an address
- * const lastRef = await client.getLastReference('DAG...');
- *
- * // Submit a transaction
- * const result = await client.postTransaction(signedTx);
- *
- * // Check transaction status
- * const pending = await client.getPendingTransaction(result.hash);
- * ```
- */
-export declare class CurrencyL1Client {
-    private client;
-    /**
-     * Create a new CurrencyL1Client
-     *
-     * @param config - Network configuration with l1Url
-     * @throws Error if l1Url is not provided
-     */
-    constructor(config: NetworkConfig);
-    /**
-     * Get the last accepted transaction reference for an address
-     *
-     * This is needed to create a new transaction that chains from
-     * the address's most recent transaction.
-     *
-     * @param address - DAG address to query
-     * @param options - Request options
-     * @returns Transaction reference with hash and ordinal
-     */
-    getLastReference(address: string, options?: RequestOptions): Promise<TransactionReference>;
-    /**
-     * Submit a signed currency transaction to the L1 network
-     *
-     * @param transaction - Signed currency transaction
-     * @param options - Request options
-     * @returns Response containing the transaction hash
-     */
-    postTransaction(transaction: CurrencyTransaction, options?: RequestOptions): Promise<PostTransactionResponse>;
-    /**
-     * Get a pending transaction by hash
-     *
-     * Use this to poll for transaction status after submission.
-     * Returns null if the transaction is not found (already confirmed or invalid).
-     *
-     * @param hash - Transaction hash
-     * @param options - Request options
-     * @returns Pending transaction details or null if not found
-     */
-    getPendingTransaction(hash: string, options?: RequestOptions): Promise<PendingTransaction | null>;
-    /**
-     * Check the health/availability of the L1 node
-     *
-     * @param options - Request options
-     * @returns True if the node is healthy
-     */
-    checkHealth(options?: RequestOptions): Promise<boolean>;
-}

package/dist/types/metakit/network/data-l1-client.d.ts

@@ -1,57 +0,0 @@
-/**
- * Data L1 client for submitting data transactions to metagraphs
- *
- * @packageDocumentation
- */
-import type { NetworkConfig, EstimateFeeResponse, PostDataResponse, RequestOptions } from './types.js';
-import type { Signed } from '../types.js';
-/**
- * Client for interacting with Data L1 nodes (metagraphs)
- *
- * @example
- * ```typescript
- * const client = new DataL1Client({ dataL1Url: 'http://localhost:8080' });
- *
- * // Estimate fee for data submission
- * const feeInfo = await client.estimateFee(signedData);
- *
- * // Submit data
- * const result = await client.postData(signedData);
- * ```
- */
-export declare class DataL1Client {
-    private client;
-    /**
-     * Create a new DataL1Client
-     *
-     * @param config - Network configuration with dataL1Url
-     * @throws Error if dataL1Url is not provided
-     */
-    constructor(config: NetworkConfig);
-    /**
-     * Estimate the fee for submitting data
-     *
-     * Some metagraphs charge fees for data submissions.
-     * Call this before postData to know the required fee.
-     *
-     * @param data - Signed data object to estimate fee for
-     * @param options - Request options
-     * @returns Fee estimate with amount and destination address
-     */
-    estimateFee<T>(data: Signed<T>, options?: RequestOptions): Promise<EstimateFeeResponse>;
-    /**
-     * Submit signed data to the Data L1 node
-     *
-     * @param data - Signed data object to submit
-     * @param options - Request options
-     * @returns Response containing the data hash
-     */
-    postData<T>(data: Signed<T>, options?: RequestOptions): Promise<PostDataResponse>;
-    /**
-     * Check the health/availability of the Data L1 node
-     *
-     * @param options - Request options
-     * @returns True if the node is healthy
-     */
-    checkHealth(options?: RequestOptions): Promise<boolean>;
-}

package/dist/types/metakit/network/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * Network operations for L1 node interactions
- *
- * @packageDocumentation
- */
-export { CurrencyL1Client } from './currency-l1-client.js';
-export { DataL1Client } from './data-l1-client.js';
-export { HttpClient } from './client.js';
-export { NetworkError } from './types.js';
-export type { NetworkConfig, RequestOptions, TransactionStatus, PendingTransaction, PostTransactionResponse, EstimateFeeResponse, PostDataResponse, } from './types.js';