@ryanrfox/sdk 0.0.2 → 2.0.3

package/src/_esm/transport/websocket.d.ts

@@ -0,0 +1,51 @@
+/**
+ * WebSocket transport for Radius SDK.
+ * Provides a wrapper around viem's WebSocket transport with Radius-specific configuration.
+ */
+import { type Chain, type Transport } from 'viem';
+/**
+ * Configuration for creating a WebSocket transport.
+ */
+export interface WebSocketTransportConfig {
+    /** The WebSocket URL (defaults to chain's WebSocket RPC URL) */
+    url?: string;
+    /** Maximum number of reconnection attempts (defaults to 3) */
+    reconnectAttempts?: number;
+    /** Reconnection delay in milliseconds (defaults to 1000) */
+    reconnectDelay?: number;
+    /** Keep-alive interval in milliseconds (optional) */
+    keepAlive?: number;
+}
+/**
+ * Creates a WebSocket transport for use with Radius clients.
+ * Uses viem's webSocket transport under the hood with Radius-specific defaults.
+ *
+ * @param chain - The chain configuration (used to determine default WebSocket URL)
+ * @param config - Optional configuration for the WebSocket transport
+ * @returns A viem Transport configured for WebSocket connections
+ *
+ * @example
+ * ```typescript
+ * import { createPublicClient } from 'viem';
+ * import { createWebSocketTransport } from '@radiustechsystems/sdk/transport';
+ * import { radiusTestnet } from '@radiustechsystems/sdk/chains';
+ *
+ * const transport = createWebSocketTransport(radiusTestnet, {
+ *   reconnectAttempts: 5,
+ *   reconnectDelay: 2000,
+ * });
+ *
+ * const client = createPublicClient({
+ *   chain: radiusTestnet,
+ *   transport,
+ * });
+ * ```
+ *
+ * @remarks
+ * - The default WebSocket URL is derived from the chain configuration
+ * - For Radius Testnet, the default is: wss://rpc.testnet.radiustech.xyz
+ * - WebSocket connections are automatically managed by viem
+ * - Subscriptions are cleaned up automatically on disconnect
+ */
+export declare function createWebSocketTransport(chain: Chain, config?: WebSocketTransportConfig): Transport;
+//# sourceMappingURL=websocket.d.ts.map

package/src/_esm/transport/websocket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.d.ts","sourceRoot":"","sources":["../../transport/websocket.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,KAAK,EAAE,KAAK,SAAS,EAAa,MAAM,MAAM,CAAC;AAE7D;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACxC,gEAAgE;IAChE,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,8DAA8D;IAC9D,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,4DAA4D;IAC5D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,qDAAqD;IACrD,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,wBAAwB,CACvC,KAAK,EAAE,KAAK,EACZ,MAAM,CAAC,EAAE,wBAAwB,GAC/B,SAAS,CAiCX"}

package/src/_esm/transport/websocket.js

@@ -0,0 +1,70 @@
+/**
+ * WebSocket transport for Radius SDK.
+ * Provides a wrapper around viem's WebSocket transport with Radius-specific configuration.
+ */
+import { webSocket } from 'viem';
+/**
+ * Creates a WebSocket transport for use with Radius clients.
+ * Uses viem's webSocket transport under the hood with Radius-specific defaults.
+ *
+ * @param chain - The chain configuration (used to determine default WebSocket URL)
+ * @param config - Optional configuration for the WebSocket transport
+ * @returns A viem Transport configured for WebSocket connections
+ *
+ * @example
+ * ```typescript
+ * import { createPublicClient } from 'viem';
+ * import { createWebSocketTransport } from '@radiustechsystems/sdk/transport';
+ * import { radiusTestnet } from '@radiustechsystems/sdk/chains';
+ *
+ * const transport = createWebSocketTransport(radiusTestnet, {
+ *   reconnectAttempts: 5,
+ *   reconnectDelay: 2000,
+ * });
+ *
+ * const client = createPublicClient({
+ *   chain: radiusTestnet,
+ *   transport,
+ * });
+ * ```
+ *
+ * @remarks
+ * - The default WebSocket URL is derived from the chain configuration
+ * - For Radius Testnet, the default is: wss://rpc.testnet.radiustech.xyz
+ * - WebSocket connections are automatically managed by viem
+ * - Subscriptions are cleaned up automatically on disconnect
+ */
+export function createWebSocketTransport(chain, config) {
+    // Determine WebSocket URL
+    let wsUrl = config?.url;
+    if (!wsUrl) {
+        // Try to get WebSocket URL from chain config
+        const chainWsUrl = chain.rpcUrls.default.webSocket?.[0];
+        if (chainWsUrl) {
+            wsUrl = chainWsUrl;
+        }
+        else {
+            // Fallback: convert HTTP URL to WebSocket URL
+            const httpUrl = chain.rpcUrls.default.http[0];
+            if (!httpUrl) {
+                throw new Error('No RPC URL configured for chain');
+            }
+            // Simple http(s) -> ws(s) conversion
+            wsUrl = httpUrl.replace(/^http/, 'ws');
+        }
+    }
+    // Create viem WebSocket transport with configuration
+    return webSocket(wsUrl, {
+        // Viem's webSocket transport accepts these options
+        reconnect: {
+            attempts: config?.reconnectAttempts ?? 3,
+            delay: config?.reconnectDelay ?? 1000,
+        },
+        keepAlive: config?.keepAlive
+            ? {
+                interval: config.keepAlive,
+            }
+            : false,
+    });
+}
+//# sourceMappingURL=websocket.js.map

package/src/_esm/transport/websocket.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket.js","sourceRoot":"","sources":["../../transport/websocket.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAA8B,SAAS,EAAE,MAAM,MAAM,CAAC;AAgB7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,UAAU,wBAAwB,CACvC,KAAY,EACZ,MAAiC;IAEjC,0BAA0B;IAC1B,IAAI,KAAK,GAAG,MAAM,EAAE,GAAG,CAAC;IAExB,IAAI,CAAC,KAAK,EAAE,CAAC;QACZ,6CAA6C;QAC7C,MAAM,UAAU,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;QACxD,IAAI,UAAU,EAAE,CAAC;YAChB,KAAK,GAAG,UAAU,CAAC;QACpB,CAAC;aAAM,CAAC;YACP,8CAA8C;YAC9C,MAAM,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;YAC9C,IAAI,CAAC,OAAO,EAAE,CAAC;gBACd,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAC;YACpD,CAAC;YACD,qCAAqC;YACrC,KAAK,GAAG,OAAO,CAAC,OAAO,CAAC,OAAO,EAAE,IAAI,CAAC,CAAC;QACxC,CAAC;IACF,CAAC;IAED,qDAAqD;IACrD,OAAO,SAAS,CAAC,KAAK,EAAE;QACvB,mDAAmD;QACnD,SAAS,EAAE;YACV,QAAQ,EAAE,MAAM,EAAE,iBAAiB,IAAI,CAAC;YACxC,KAAK,EAAE,MAAM,EAAE,cAAc,IAAI,IAAI;SACrC;QACD,SAAS,EAAE,MAAM,EAAE,SAAS;YAC3B,CAAC,CAAC;gBACA,QAAQ,EAAE,MAAM,CAAC,SAAS;aAC1B;YACF,CAAC,CAAC,KAAK;KACR,CAAC,CAAC;AACJ,CAAC"}

package/src/_types/actions/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Radius SDK Actions
+ *
+ * Standalone action functions that can be used with viem clients.
+ * These follow viem's action pattern and are composed into decorators.
+ */
+export { type SendTransactionBatchParameters, type SendTransactionBatchReturnType, sendTransactionBatch, } from './sendTransactionBatch.js';
+//# sourceMappingURL=index.d.ts.map

package/src/_types/actions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../actions/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EACN,KAAK,8BAA8B,EACnC,KAAK,8BAA8B,EACnC,oBAAoB,GACpB,MAAM,2BAA2B,CAAC"}

package/src/_types/actions/sendTransactionBatch.d.ts

@@ -0,0 +1,77 @@
+/**
+ * sendTransactionBatch action - sends multiple transactions in a single JSON-RPC batch request.
+ *
+ * Radius does not queue future-nonce transactions like Ethereum. This action ensures
+ * all transactions arrive in nonce order by using JSON-RPC batching.
+ */
+import type { Account, Address, Chain, Client, Hash, Hex, Transport } from 'viem';
+/** Default maximum number of transactions in a single batch */
+export declare const DEFAULT_MAX_BATCH_SIZE = 100;
+/** Default timeout for batch fetch requests in milliseconds (30 seconds) */
+export declare const DEFAULT_BATCH_TIMEOUT = 30000;
+/**
+ * Transaction request for batch submission.
+ */
+export interface SendTransactionBatchParameters {
+    /** Array of transactions to send in the batch */
+    transactions: Array<{
+        /** The recipient address */
+        to: Address;
+        /** The amount to send in wei (default: 0n) */
+        value?: bigint;
+        /** The transaction data (for contract calls) */
+        data?: Hex;
+        /** Gas limit (if not provided, will be estimated) */
+        gas?: bigint;
+    }>;
+    /** Maximum number of transactions allowed in the batch (default: 100) */
+    maxBatchSize?: number;
+    /** Timeout in milliseconds for the batch fetch request (default: 30000) */
+    timeout?: number;
+}
+/**
+ * Return type for sendTransactionBatch action.
+ */
+export type SendTransactionBatchReturnType = Hash[];
+/**
+ * Send multiple transactions in a single JSON-RPC batch request.
+ * Transactions are automatically assigned sequential nonces and sent atomically.
+ *
+ * @param client - The viem client (must have an account attached)
+ * @param params - The batch transaction parameters
+ * @param params.transactions - Array of transaction objects to send
+ * @param params.maxBatchSize - Maximum batch size (default: 100)
+ * @param params.timeout - Fetch timeout in milliseconds (default: 30000)
+ * @returns Array of transaction hashes in the same order as input
+ * @throws {BatchTransactionError} If any transaction in the batch fails
+ * @throws {GasEstimationError} If gas estimation fails for any transaction
+ * @throws {RadiusError} If input validation fails, HTTP request fails, or request times out
+ *
+ * @remarks
+ * **Transport Note:** This function uses a direct `fetch()` call rather than
+ * the client's configured transport. Custom transport interceptors, retry logic,
+ * or middleware will not be applied to batch requests. This is necessary because
+ * viem's transport layer does not expose batch JSON-RPC capabilities.
+ *
+ * @example
+ * ```typescript
+ * import { createWalletClient, http } from 'viem';
+ * import { privateKeyToAccount } from 'viem/accounts';
+ * import { radiusTestnet, radiusWalletActions } from '@radiustechsystems/sdk';
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: radiusTestnet,
+ *   transport: http(),
+ * }).extend(radiusWalletActions());
+ *
+ * const hashes = await client.sendTransactionBatch({
+ *   transactions: [
+ *     { to: '0x...', value: 1000000000000000000n },
+ *     { to: '0x...', data: '0x...' },
+ *   ],
+ * });
+ * ```
+ */
+export declare function sendTransactionBatch<chain extends Chain | undefined, account extends Account | undefined>(client: Client<Transport, chain, account>, params: SendTransactionBatchParameters): Promise<SendTransactionBatchReturnType>;
+//# sourceMappingURL=sendTransactionBatch.d.ts.map

package/src/_types/actions/sendTransactionBatch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendTransactionBatch.d.ts","sourceRoot":"","sources":["../../actions/sendTransactionBatch.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AASlF,+DAA+D;AAC/D,eAAO,MAAM,sBAAsB,MAAM,CAAC;AAE1C,4EAA4E;AAC5E,eAAO,MAAM,qBAAqB,QAAQ,CAAC;AAE3C;;GAEG;AACH,MAAM,WAAW,8BAA8B;IAC9C,iDAAiD;IACjD,YAAY,EAAE,KAAK,CAAC;QACnB,4BAA4B;QAC5B,EAAE,EAAE,OAAO,CAAC;QACZ,8CAA8C;QAC9C,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,gDAAgD;QAChD,IAAI,CAAC,EAAE,GAAG,CAAC;QACX,qDAAqD;QACrD,GAAG,CAAC,EAAE,MAAM,CAAC;KACb,CAAC,CAAC;IACH,yEAAyE;IACzE,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG,IAAI,EAAE,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAsB,oBAAoB,CACzC,KAAK,SAAS,KAAK,GAAG,SAAS,EAC/B,OAAO,SAAS,OAAO,GAAG,SAAS,EAEnC,MAAM,EAAE,MAAM,CAAC,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,EACzC,MAAM,EAAE,8BAA8B,GACpC,OAAO,CAAC,8BAA8B,CAAC,CAgNzC"}

package/src/_types/chains/chainConfig.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared chain configuration constants for Radius.
+ */
+/**
+ * Maximum gas limit for transactions on Radius.
+ *
+ * IMPORTANT: This constant is required because:
+ * - Radius returns gasLimit: 0 for all blocks (intentionally)
+ * - This differs from Ethereum where block.gasLimit is ~30,000,000
+ * - Dynamic fetching from blocks is not possible
+ *
+ * This value (0x13333333332) is a Radius protocol constant used to:
+ * 1. Cap gas estimates to prevent unexpectedly high values
+ * 2. Provide a safety bound for transaction gas limits
+ *
+ * Similar to how Arbitrum and zkSync SDKs use custom gas handling
+ * rather than relying on block.gasLimit.
+ *
+ * @see _research/sdk-walkthrough/GASLIMIT-ECOSYSTEM.md for full ecosystem impact analysis
+ *
+ * @example
+ * ```typescript
+ * import { MAX_GAS } from '@radiustechsystems/sdk';
+ *
+ * // Cap gas estimate at MAX_GAS
+ * const cappedGas = estimatedGas > MAX_GAS ? MAX_GAS : estimatedGas;
+ * ```
+ */
+export declare const MAX_GAS = 1319413953330n;
+//# sourceMappingURL=chainConfig.d.ts.map

package/src/_types/chains/chainConfig.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chainConfig.d.ts","sourceRoot":"","sources":["../../chains/chainConfig.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,OAAO,iBAAiB,CAAC"}

package/src/_types/chains/index.d.ts

@@ -0,0 +1,4 @@
+export { MAX_GAS } from './chainConfig.js';
+export { radius } from './radius.js';
+export { radiusTestnet } from './radiusTestnet.js';
+//# sourceMappingURL=index.d.ts.map

package/src/_types/chains/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../chains/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,OAAO,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC"}

package/src/_types/chains/radius.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Radius Mainnet chain configuration.
+ *
+ * Chain ID: 723
+ * RPC: https://rpc.radiustech.xyz
+ *
+ * @example
+ * ```typescript
+ * import { radius } from '@radiustechsystems/sdk/chains';
+ *
+ * const client = createPublicClient({
+ *   chain: radius,
+ *   transport: http(),
+ * });
+ * ```
+ */
+export declare const radius: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Radius Explorer";
+            readonly url: "https://explorer.radiustech.xyz";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts?: {
+        [x: string]: import("viem").ChainContract | {
+            [sourceId: number]: import("viem").ChainContract | undefined;
+        } | undefined;
+        ensRegistry?: import("viem").ChainContract | undefined;
+        ensUniversalResolver?: import("viem").ChainContract | undefined;
+        multicall3?: import("viem").ChainContract | undefined;
+        erc6492Verifier?: import("viem").ChainContract | undefined;
+    } | undefined;
+    ensTlds?: readonly string[] | undefined;
+    id: 723;
+    name: "Radius";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "USD";
+        readonly symbol: "USD";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.radiustech.xyz"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: false;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+};
+//# sourceMappingURL=radius.d.ts.map

package/src/_types/chains/radius.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radius.d.ts","sourceRoot":"","sources":["../../chains/radius.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoBjB,CAAC"}

package/src/_types/chains/radiusTestnet.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Radius Testnet chain configuration.
+ *
+ * Chain ID: 1223953 (0x12ad11)
+ * RPC: https://rpc.testnet.radiustech.xyz
+ *
+ * @example
+ * ```typescript
+ * import { radiusTestnet } from '@radiustechsystems/sdk/chains';
+ *
+ * const client = createPublicClient({
+ *   chain: radiusTestnet,
+ *   transport: http(),
+ * });
+ * ```
+ */
+export declare const radiusTestnet: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Radius Explorer";
+            readonly url: "https://explorer.testnet.radiustech.xyz";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly multicall3: {
+            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+            readonly blockCreated: 1768594222351;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 1223953;
+    name: "Radius Testnet";
+    nativeCurrency: {
+        readonly decimals: 18;
+        readonly name: "USD";
+        readonly symbol: "USD";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.testnet.radiustech.xyz"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    extendSchema?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    prepareTransactionRequest?: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | [fn: ((args: import("viem").PrepareTransactionRequestParameters, options: {
+        phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+    }) => Promise<import("viem").PrepareTransactionRequestParameters>) | undefined, options: {
+        runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+    }] | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    verifyHash?: ((client: import("viem").Client, parameters: import("viem").VerifyHashActionParameters) => Promise<import("viem").VerifyHashActionReturnType>) | undefined;
+};
+//# sourceMappingURL=radiusTestnet.d.ts.map

package/src/_types/chains/radiusTestnet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radiusTestnet.d.ts","sourceRoot":"","sources":["../../chains/radiusTestnet.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BxB,CAAC"}

package/src/_types/decorators/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Radius SDK Decorators
+ *
+ * Client decorators that extend viem clients with Radius-specific functionality.
+ * Follows viem's decorator pattern for composition.
+ */
+export { type RadiusWalletActions, radiusWalletActions } from './radius.js';
+//# sourceMappingURL=index.d.ts.map

package/src/_types/decorators/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../decorators/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,KAAK,mBAAmB,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC"}

package/src/_types/decorators/radius.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Radius wallet actions decorator.
+ *
+ * Extends viem wallet clients with Radius-specific functionality.
+ * Follows viem's decorator pattern (see: viem/src/zksync/decorators/walletL2.ts)
+ */
+import type { Account, Chain, Client, Transport } from 'viem';
+import { type SendTransactionBatchParameters, type SendTransactionBatchReturnType } from '../actions/sendTransactionBatch.js';
+/**
+ * Radius-specific wallet actions added by the radiusWalletActions decorator.
+ */
+export type RadiusWalletActions<_chain extends Chain | undefined = Chain | undefined, _account extends Account | undefined = Account | undefined> = {
+    /**
+     * Send multiple transactions in a single JSON-RPC batch request.
+     * Transactions are automatically assigned sequential nonces and sent atomically.
+     *
+     * @remarks
+     * Radius does not queue future-nonce transactions like Ethereum.
+     * This method ensures all transactions arrive in nonce order by using JSON-RPC batching.
+     *
+     * @param params - The batch transaction parameters
+     * @returns Array of transaction hashes in the same order as input
+     *
+     * @example
+     * ```typescript
+     * const hashes = await client.sendTransactionBatch({
+     *   transactions: [
+     *     { to: '0x...', value: 1000000000000000000n },
+     *     { to: '0x...', data: '0x...' },
+     *   ],
+     * });
+     * ```
+     */
+    sendTransactionBatch: (params: SendTransactionBatchParameters) => Promise<SendTransactionBatchReturnType>;
+};
+/**
+ * Decorator that extends a viem wallet client with Radius-specific actions.
+ *
+ * @returns A decorator function that adds Radius wallet actions to a client
+ *
+ * @example
+ * ```typescript
+ * import { createWalletClient, http } from 'viem';
+ * import { privateKeyToAccount } from 'viem/accounts';
+ * import { radiusTestnet, radiusWalletActions } from '@radiustechsystems/sdk';
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x...'),
+ *   chain: radiusTestnet,
+ *   transport: http(),
+ * }).extend(radiusWalletActions());
+ *
+ * // Standard viem for simple operations
+ * const hash = await client.sendTransaction({ to, value });
+ *
+ * // Radius-specific for batching
+ * const hashes = await client.sendTransactionBatch({
+ *   transactions: [
+ *     { to: addr1, value: 1n },
+ *     { to: addr2, value: 2n },
+ *   ],
+ * });
+ * ```
+ */
+export declare function radiusWalletActions(): <transport extends Transport, chain extends Chain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined>(client: Client<transport, chain, account>) => RadiusWalletActions<chain, account>;
+//# sourceMappingURL=radius.d.ts.map

package/src/_types/decorators/radius.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"radius.d.ts","sourceRoot":"","sources":["../../decorators/radius.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AAC9D,OAAO,EACN,KAAK,8BAA8B,EACnC,KAAK,8BAA8B,EAEnC,MAAM,oCAAoC,CAAC;AAE5C;;GAEG;AACH,MAAM,MAAM,mBAAmB,CAC9B,MAAM,SAAS,KAAK,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS,EACpD,QAAQ,SAAS,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,IACvD;IACH;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,oBAAoB,EAAE,CACrB,MAAM,EAAE,8BAA8B,KAClC,OAAO,CAAC,8BAA8B,CAAC,CAAC;CAC7C,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,mBAAmB,KAEjC,SAAS,SAAS,SAAS,EAC3B,KAAK,SAAS,KAAK,GAAG,SAAS,GAAG,KAAK,GAAG,SAAS,EACnD,OAAO,SAAS,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,EAEzD,QAAQ,MAAM,CAAC,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,KACvC,mBAAmB,CAAC,KAAK,EAAE,OAAO,CAAC,CAGtC"}

package/src/_types/errors/account.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Account and signer-related errors
+ */
+import type { Address } from 'viem';
+import { RadiusError, type RadiusErrorOptions } from './base';
+/**
+ * Error thrown when a signer is required but not available.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   // Attempting to send without an account configured
+ *   await walletClient.sendTransaction({ to, value });
+ * } catch (error) {
+ *   if (error instanceof SignerNotFoundError) {
+ *     console.log('Please connect a wallet');
+ *   }
+ * }
+ * ```
+ */
+export declare class SignerNotFoundError extends RadiusError {
+    readonly name = "SignerNotFoundError";
+    constructor(message?: string, options?: RadiusErrorOptions);
+}
+/**
+ * Error thrown when account balance is insufficient for an operation.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await walletClient.sendTransaction({ to, value });
+ * } catch (error) {
+ *   if (error instanceof InsufficientBalanceError) {
+ *     console.log(`Need ${error.required}, have ${error.balance}`);
+ *   }
+ * }
+ * ```
+ */
+export declare class InsufficientBalanceError extends RadiusError {
+    readonly name = "InsufficientBalanceError";
+    /** The account address */
+    readonly address?: Address;
+    /** Current balance (in wei) */
+    readonly balance?: bigint;
+    /** Required balance (in wei) */
+    readonly required?: bigint;
+    constructor(message: string, options?: RadiusErrorOptions & {
+        address?: Address;
+        balance?: bigint;
+        required?: bigint;
+    });
+}
+/**
+ * Error thrown when signing a message or transaction fails.
+ */
+export declare class SigningError extends RadiusError {
+    readonly name = "SigningError";
+    constructor(message: string, options?: RadiusErrorOptions);
+}
+/**
+ * Error thrown when an invalid private key is provided.
+ */
+export declare class InvalidPrivateKeyError extends RadiusError {
+    readonly name = "InvalidPrivateKeyError";
+    constructor(message?: string, options?: RadiusErrorOptions);
+}
+/**
+ * Error thrown when address validation fails.
+ */
+export declare class InvalidAddressError extends RadiusError {
+    readonly name = "InvalidAddressError";
+    /** The invalid address value */
+    readonly invalidAddress?: string;
+    constructor(message: string, options?: RadiusErrorOptions & {
+        invalidAddress?: string;
+    });
+}
+//# sourceMappingURL=account.d.ts.map

package/src/_types/errors/account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../errors/account.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,EAAE,WAAW,EAAE,KAAK,kBAAkB,EAAE,MAAM,QAAQ,CAAC;AAE9D;;;;;;;;;;;;;;GAcG;AACH,qBAAa,mBAAoB,SAAQ,WAAW;IACnD,SAAkB,IAAI,yBAAyB;gBAEnC,OAAO,SAAuB,EAAE,OAAO,GAAE,kBAAuB;CAM5E;AAED;;;;;;;;;;;;;GAaG;AACH,qBAAa,wBAAyB,SAAQ,WAAW;IACxD,SAAkB,IAAI,8BAA8B;IAEpD,0BAA0B;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC;IAC3B,+BAA+B;IAC/B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,gCAAgC;IAChC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;gBAG1B,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,kBAAkB,GAAG;QAC7B,OAAO,CAAC,EAAE,OAAO,CAAC;QAClB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACb;CAUP;AAED;;GAEG;AACH,qBAAa,YAAa,SAAQ,WAAW;IAC5C,SAAkB,IAAI,kBAAkB;gBAE5B,OAAO,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAuB;CAM7D;AAED;;GAEG;AACH,qBAAa,sBAAuB,SAAQ,WAAW;IACtD,SAAkB,IAAI,4BAA4B;gBAEtC,OAAO,SAAwB,EAAE,OAAO,GAAE,kBAAuB;CAM7E;AAED;;GAEG;AACH,qBAAa,mBAAoB,SAAQ,WAAW;IACnD,SAAkB,IAAI,yBAAyB;IAE/C,gCAAgC;IAChC,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAC;gBAGhC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,kBAAkB,GAAG;QAC7B,cAAc,CAAC,EAAE,MAAM,CAAC;KACnB;CAQP"}

package/src/_types/errors/base.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Radius SDK Error Hierarchy
+ *
+ * Extends viem's BaseError for ecosystem compatibility.
+ * All Radius errors can be caught using `instanceof BaseError` from viem.
+ */
+import { BaseError } from 'viem';
+/**
+ * Options for creating a RadiusError
+ */
+export interface RadiusErrorOptions {
+    /** Detailed error information */
+    details?: string;
+    /** URL path to relevant documentation */
+    docsPath?: string;
+    /** The underlying cause of this error */
+    cause?: BaseError | Error | undefined;
+    /** Additional hint messages to help resolve the error */
+    metaMessages?: string[];
+    /** Additional metadata about the error (Radius-specific extension) */
+    meta?: Record<string, unknown>;
+}
+/**
+ * Base error class for all Radius SDK errors.
+ *
+ * Extends viem's BaseError for ecosystem compatibility. This means:
+ * - `error instanceof BaseError` from viem will catch Radius errors
+ * - Compatible with wagmi error handling
+ * - Inherits viem's error formatting and walk() method
+ *
+ * @example
+ * ```typescript
+ * import { BaseError } from 'viem';
+ *
+ * try {
+ *   await walletClient.sendTransaction({ to, value });
+ * } catch (error) {
+ *   if (error instanceof RadiusError) {
+ *     console.log(error.shortMessage); // Quick description
+ *     console.log(error.details);      // Full details
+ *     console.log(error.docsPath);     // Link to docs
+ *   }
+ *   // Also works with viem's BaseError check
+ *   if (error instanceof BaseError) {
+ *     console.log('Caught viem-compatible error');
+ *   }
+ * }
+ * ```
+ */
+export declare class RadiusError extends BaseError {
+    /** Additional metadata (Radius-specific extension) */
+    readonly meta?: Record<string, unknown>;
+    name: string;
+    constructor(shortMessage: string, options?: RadiusErrorOptions);
+}
+//# sourceMappingURL=base.d.ts.map

package/src/_types/errors/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../errors/base.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,MAAM,CAAC;AAEjC;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC,iCAAiC;IACjC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yCAAyC;IACzC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,yCAAyC;IACzC,KAAK,CAAC,EAAE,SAAS,GAAG,KAAK,GAAG,SAAS,CAAC;IACtC,yDAAyD;IACzD,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;IACxB,sEAAsE;IACtE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qBAAa,WAAY,SAAQ,SAAS;IACzC,sDAAsD;IACtD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAE/B,IAAI,SAAiB;gBAElB,YAAY,EAAE,MAAM,EAAE,OAAO,GAAE,kBAAuB;CAYlE"}