@ottochain/sdk 0.2.0

package/dist/metakit/index.d.ts

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

package/dist/metakit/index.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Metakit SDK
+ *
+ * Reusable signing, encoding, and network operations for Constellation metagraphs.
+ * This module is framework-level functionality, independent of any specific metagraph domain.
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkError = exports.HttpClient = exports.DataL1Client = exports.CurrencyL1Client = exports.unitsToToken = exports.tokenToUnits = exports.isValidDagAddress = exports.getTransactionReference = exports.hashCurrencyTransaction = exports.encodeCurrencyTransaction = exports.verifyCurrencyTransaction = exports.signCurrencyTransaction = exports.createCurrencyTransactionBatch = exports.createCurrencyTransaction = exports.TOKEN_DECIMALS = exports.isValidPublicKey = exports.isValidPrivateKey = exports.getAddress = exports.getPublicKeyId = exports.getPublicKeyHex = exports.keyPairFromPrivateKey = exports.generateKeyPair = exports.batchSign = exports.addSignature = exports.createSignedObject = exports.verifySignature = exports.verifyHash = exports.verify = exports.signHash = exports.signDataUpdate = exports.sign = exports.decodeDataUpdate = exports.computeDigest = exports.hashData = exports.hashBytes = exports.hash = exports.encodeDataUpdate = exports.toBytes = exports.canonicalize = exports.CONSTELLATION_PREFIX = exports.ALGORITHM = void 0;
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "ALGORITHM", { enumerable: true, get: function () { return types_js_1.ALGORITHM; } });
+Object.defineProperty(exports, "CONSTELLATION_PREFIX", { enumerable: true, get: function () { return types_js_1.CONSTELLATION_PREFIX; } });
+// Canonicalization
+var canonicalize_js_1 = require("./canonicalize.js");
+Object.defineProperty(exports, "canonicalize", { enumerable: true, get: function () { return canonicalize_js_1.canonicalize; } });
+// Binary encoding
+var binary_js_1 = require("./binary.js");
+Object.defineProperty(exports, "toBytes", { enumerable: true, get: function () { return binary_js_1.toBytes; } });
+Object.defineProperty(exports, "encodeDataUpdate", { enumerable: true, get: function () { return binary_js_1.encodeDataUpdate; } });
+// Hashing
+var hash_js_1 = require("./hash.js");
+Object.defineProperty(exports, "hash", { enumerable: true, get: function () { return hash_js_1.hash; } });
+Object.defineProperty(exports, "hashBytes", { enumerable: true, get: function () { return hash_js_1.hashBytes; } });
+Object.defineProperty(exports, "hashData", { enumerable: true, get: function () { return hash_js_1.hashData; } });
+Object.defineProperty(exports, "computeDigest", { enumerable: true, get: function () { return hash_js_1.computeDigest; } });
+// Codec utilities
+var codec_js_1 = require("./codec.js");
+Object.defineProperty(exports, "decodeDataUpdate", { enumerable: true, get: function () { return codec_js_1.decodeDataUpdate; } });
+// Signing
+var sign_js_1 = require("./sign.js");
+Object.defineProperty(exports, "sign", { enumerable: true, get: function () { return sign_js_1.sign; } });
+Object.defineProperty(exports, "signDataUpdate", { enumerable: true, get: function () { return sign_js_1.signDataUpdate; } });
+Object.defineProperty(exports, "signHash", { enumerable: true, get: function () { return sign_js_1.signHash; } });
+// Verification
+var verify_js_1 = require("./verify.js");
+Object.defineProperty(exports, "verify", { enumerable: true, get: function () { return verify_js_1.verify; } });
+Object.defineProperty(exports, "verifyHash", { enumerable: true, get: function () { return verify_js_1.verifyHash; } });
+Object.defineProperty(exports, "verifySignature", { enumerable: true, get: function () { return verify_js_1.verifySignature; } });
+// High-level API
+var signed_object_js_1 = require("./signed-object.js");
+Object.defineProperty(exports, "createSignedObject", { enumerable: true, get: function () { return signed_object_js_1.createSignedObject; } });
+Object.defineProperty(exports, "addSignature", { enumerable: true, get: function () { return signed_object_js_1.addSignature; } });
+Object.defineProperty(exports, "batchSign", { enumerable: true, get: function () { return signed_object_js_1.batchSign; } });
+// Wallet utilities
+var wallet_js_1 = require("./wallet.js");
+Object.defineProperty(exports, "generateKeyPair", { enumerable: true, get: function () { return wallet_js_1.generateKeyPair; } });
+Object.defineProperty(exports, "keyPairFromPrivateKey", { enumerable: true, get: function () { return wallet_js_1.keyPairFromPrivateKey; } });
+Object.defineProperty(exports, "getPublicKeyHex", { enumerable: true, get: function () { return wallet_js_1.getPublicKeyHex; } });
+Object.defineProperty(exports, "getPublicKeyId", { enumerable: true, get: function () { return wallet_js_1.getPublicKeyId; } });
+Object.defineProperty(exports, "getAddress", { enumerable: true, get: function () { return wallet_js_1.getAddress; } });
+Object.defineProperty(exports, "isValidPrivateKey", { enumerable: true, get: function () { return wallet_js_1.isValidPrivateKey; } });
+Object.defineProperty(exports, "isValidPublicKey", { enumerable: true, get: function () { return wallet_js_1.isValidPublicKey; } });
+var currency_types_js_1 = require("./currency-types.js");
+Object.defineProperty(exports, "TOKEN_DECIMALS", { enumerable: true, get: function () { return currency_types_js_1.TOKEN_DECIMALS; } });
+// Currency transaction operations
+var currency_transaction_js_1 = require("./currency-transaction.js");
+Object.defineProperty(exports, "createCurrencyTransaction", { enumerable: true, get: function () { return currency_transaction_js_1.createCurrencyTransaction; } });
+Object.defineProperty(exports, "createCurrencyTransactionBatch", { enumerable: true, get: function () { return currency_transaction_js_1.createCurrencyTransactionBatch; } });
+Object.defineProperty(exports, "signCurrencyTransaction", { enumerable: true, get: function () { return currency_transaction_js_1.signCurrencyTransaction; } });
+Object.defineProperty(exports, "verifyCurrencyTransaction", { enumerable: true, get: function () { return currency_transaction_js_1.verifyCurrencyTransaction; } });
+Object.defineProperty(exports, "encodeCurrencyTransaction", { enumerable: true, get: function () { return currency_transaction_js_1.encodeCurrencyTransaction; } });
+Object.defineProperty(exports, "hashCurrencyTransaction", { enumerable: true, get: function () { return currency_transaction_js_1.hashCurrencyTransaction; } });
+Object.defineProperty(exports, "getTransactionReference", { enumerable: true, get: function () { return currency_transaction_js_1.getTransactionReference; } });
+Object.defineProperty(exports, "isValidDagAddress", { enumerable: true, get: function () { return currency_transaction_js_1.isValidDagAddress; } });
+Object.defineProperty(exports, "tokenToUnits", { enumerable: true, get: function () { return currency_transaction_js_1.tokenToUnits; } });
+Object.defineProperty(exports, "unitsToToken", { enumerable: true, get: function () { return currency_transaction_js_1.unitsToToken; } });
+// Network operations
+var index_js_1 = require("./network/index.js");
+Object.defineProperty(exports, "CurrencyL1Client", { enumerable: true, get: function () { return index_js_1.CurrencyL1Client; } });
+Object.defineProperty(exports, "DataL1Client", { enumerable: true, get: function () { return index_js_1.DataL1Client; } });
+Object.defineProperty(exports, "HttpClient", { enumerable: true, get: function () { return index_js_1.HttpClient; } });
+Object.defineProperty(exports, "NetworkError", { enumerable: true, get: function () { return index_js_1.NetworkError; } });

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

@@ -0,0 +1,23 @@
+/**
+ * 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/metakit/network/client.js

@@ -0,0 +1,78 @@
+"use strict";
+/**
+ * Base HTTP client for network operations
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClient = void 0;
+const types_js_1 = require("./types.js");
+const DEFAULT_TIMEOUT = 30000;
+/**
+ * Simple HTTP client using native fetch
+ */
+class HttpClient {
+    constructor(baseUrl, timeout = DEFAULT_TIMEOUT) {
+        this.baseUrl = baseUrl.replace(/\/$/, '');
+        this.defaultTimeout = timeout;
+    }
+    /**
+     * Make a GET request
+     */
+    async get(path, options = {}) {
+        return this.request('GET', path, undefined, options);
+    }
+    /**
+     * Make a POST request
+     */
+    async post(path, body, options = {}) {
+        return this.request('POST', path, body, options);
+    }
+    async request(method, path, body, options = {}) {
+        const url = `${this.baseUrl}${path}`;
+        const timeout = options.timeout ?? this.defaultTimeout;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), timeout);
+        try {
+            const headers = {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                ...options.headers,
+            };
+            const response = await fetch(url, {
+                method,
+                headers,
+                body: body ? JSON.stringify(body) : undefined,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            const text = await response.text();
+            if (!response.ok) {
+                throw new types_js_1.NetworkError(`HTTP ${response.status}: ${response.statusText}`, response.status, text);
+            }
+            if (!text) {
+                return undefined;
+            }
+            try {
+                return JSON.parse(text);
+            }
+            catch {
+                return text;
+            }
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof types_js_1.NetworkError) {
+                throw error;
+            }
+            if (error instanceof Error) {
+                if (error.name === 'AbortError') {
+                    throw new types_js_1.NetworkError(`Request timeout after ${timeout}ms`);
+                }
+                throw new types_js_1.NetworkError(error.message);
+            }
+            throw new types_js_1.NetworkError('Unknown network error');
+        }
+    }
+}
+exports.HttpClient = HttpClient;

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

@@ -0,0 +1,71 @@
+/**
+ * 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/metakit/network/currency-l1-client.js

@@ -0,0 +1,101 @@
+"use strict";
+/**
+ * Currency L1 client for submitting and querying transactions
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CurrencyL1Client = void 0;
+const client_js_1 = require("./client.js");
+const types_js_1 = require("./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);
+ * ```
+ */
+class CurrencyL1Client {
+    /**
+     * Create a new CurrencyL1Client
+     *
+     * @param config - Network configuration with l1Url
+     * @throws Error if l1Url is not provided
+     */
+    constructor(config) {
+        if (!config.l1Url) {
+            throw new Error('l1Url is required for CurrencyL1Client');
+        }
+        this.client = new client_js_1.HttpClient(config.l1Url, config.timeout);
+    }
+    /**
+     * 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
+     */
+    async getLastReference(address, options) {
+        return this.client.get(`/transactions/last-reference/${address}`, options);
+    }
+    /**
+     * Submit a signed currency transaction to the L1 network
+     *
+     * @param transaction - Signed currency transaction
+     * @param options - Request options
+     * @returns Response containing the transaction hash
+     */
+    async postTransaction(transaction, options) {
+        return this.client.post('/transactions', transaction, options);
+    }
+    /**
+     * 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
+     */
+    async getPendingTransaction(hash, options) {
+        try {
+            return await this.client.get(`/transactions/${hash}`, options);
+        }
+        catch (error) {
+            if (error instanceof types_js_1.NetworkError && error.statusCode === 404) {
+                return null;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Check the health/availability of the L1 node
+     *
+     * @param options - Request options
+     * @returns True if the node is healthy
+     */
+    async checkHealth(options) {
+        try {
+            await this.client.get('/cluster/info', options);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.CurrencyL1Client = CurrencyL1Client;

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

@@ -0,0 +1,57 @@
+/**
+ * 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/metakit/network/data-l1-client.js

@@ -0,0 +1,76 @@
+"use strict";
+/**
+ * Data L1 client for submitting data transactions to metagraphs
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataL1Client = void 0;
+const client_js_1 = require("./client.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);
+ * ```
+ */
+class DataL1Client {
+    /**
+     * Create a new DataL1Client
+     *
+     * @param config - Network configuration with dataL1Url
+     * @throws Error if dataL1Url is not provided
+     */
+    constructor(config) {
+        if (!config.dataL1Url) {
+            throw new Error('dataL1Url is required for DataL1Client');
+        }
+        this.client = new client_js_1.HttpClient(config.dataL1Url, config.timeout);
+    }
+    /**
+     * 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
+     */
+    async estimateFee(data, options) {
+        return this.client.post('/data/estimate-fee', data, options);
+    }
+    /**
+     * 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
+     */
+    async postData(data, options) {
+        return this.client.post('/data', data, options);
+    }
+    /**
+     * Check the health/availability of the Data L1 node
+     *
+     * @param options - Request options
+     * @returns True if the node is healthy
+     */
+    async checkHealth(options) {
+        try {
+            await this.client.get('/cluster/info', options);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.DataL1Client = DataL1Client;

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

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

package/dist/metakit/network/index.js

@@ -0,0 +1,16 @@
+"use strict";
+/**
+ * Network operations for L1 node interactions
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkError = exports.HttpClient = exports.DataL1Client = exports.CurrencyL1Client = void 0;
+var currency_l1_client_js_1 = require("./currency-l1-client.js");
+Object.defineProperty(exports, "CurrencyL1Client", { enumerable: true, get: function () { return currency_l1_client_js_1.CurrencyL1Client; } });
+var data_l1_client_js_1 = require("./data-l1-client.js");
+Object.defineProperty(exports, "DataL1Client", { enumerable: true, get: function () { return data_l1_client_js_1.DataL1Client; } });
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "HttpClient", { enumerable: true, get: function () { return client_js_1.HttpClient; } });
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "NetworkError", { enumerable: true, get: function () { return types_js_1.NetworkError; } });

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

@@ -0,0 +1,74 @@
+/**
+ * Network types for L1 client operations
+ *
+ * @packageDocumentation
+ */
+import type { CurrencyTransaction } from '../currency-types.js';
+/**
+ * Network configuration for connecting to L1 nodes
+ */
+export interface NetworkConfig {
+    /** Currency L1 endpoint URL (e.g., 'http://localhost:9010') */
+    l1Url?: string;
+    /** Data L1 endpoint URL (e.g., 'http://localhost:8080') */
+    dataL1Url?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+}
+/**
+ * HTTP request options
+ */
+export interface RequestOptions {
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Additional headers */
+    headers?: Record<string, string>;
+}
+/**
+ * Transaction status in the network
+ */
+export type TransactionStatus = 'Waiting' | 'InProgress' | 'Accepted';
+/**
+ * Pending transaction response from L1
+ */
+export interface PendingTransaction {
+    /** Transaction hash */
+    hash: string;
+    /** Current status */
+    status: TransactionStatus;
+    /** The transaction value */
+    transaction: CurrencyTransaction;
+}
+/**
+ * Response from posting a transaction
+ */
+export interface PostTransactionResponse {
+    /** Transaction hash */
+    hash: string;
+}
+/**
+ * Response from estimating data transaction fee
+ */
+export interface EstimateFeeResponse {
+    /** Estimated fee in smallest units */
+    fee: number;
+    /** Fee destination address */
+    address: string;
+}
+/**
+ * Response from posting data
+ */
+export interface PostDataResponse {
+    /** Data hash */
+    hash: string;
+}
+/**
+ * Network error with status code and response details
+ */
+export declare class NetworkError extends Error {
+    /** HTTP status code if applicable */
+    statusCode?: number;
+    /** Raw response body */
+    responseBody?: string;
+    constructor(message: string, statusCode?: number, responseBody?: string);
+}

package/dist/metakit/network/types.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Network types for L1 client operations
+ *
+ * @packageDocumentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkError = void 0;
+/**
+ * Network error with status code and response details
+ */
+class NetworkError extends Error {
+    constructor(message, statusCode, responseBody) {
+        super(message);
+        this.name = 'NetworkError';
+        this.statusCode = statusCode;
+        this.responseBody = responseBody;
+    }
+}
+exports.NetworkError = NetworkError;