@totemsdk/chain-provider 0.1.3 → 0.1.5

package/README.md

@@ -16,13 +16,14 @@ npm install @totemsdk/chain-provider
 
 ```typescript
 interface ChainStateProvider {
-  getCoins(query: CoinQuery): Promise<Coin[]>;
-  getCoin(id: string): Promise<Coin | null>;
-  getMMRProof(coinId: string): Promise<MMRProof>;
-  getChainTip(): Promise<ChainTip>;
-  getToken(id: string): Promise<Token | null>;
-  searchTokens(query: string): Promise<Token[]>;
-  broadcastTxPoW(hex: string): Promise<BroadcastResult>;
+  getCoins(query: CoinsQuery): Promise<Coin[]>;
+  getCoin(coinId: string): Promise<Coin | null>;
+  getProof(coinId: string): Promise<MMRProof>;
+  getTip(): Promise<ChainTip>;
+  getToken(tokenId: string): Promise<TokenInfo>;
+  searchTokens(query: TokenSearchQuery): Promise<TokenInfo[]>;
+  getTokensByCreator(address: string): Promise<TokenInfo[]>;
+  broadcastTxPoW(txpowHex: string): Promise<BroadcastResult>;
 }
 ```
 
@@ -32,7 +33,7 @@ interface ChainStateProvider {
 |-------|------------|
 | `HostedProvider` | Axia / MEG hosted API (requires project credentials) |
 | `PureMinimaRpcProvider` | A local or self-hosted PureMinima node directly |
-| `LookupNodeProvider` | A personal lookup node over Hyperswarm DHT |
+| `LookupClientProvider` | A personal lookup node over Hyperswarm DHT (via `@totemsdk/lookup-client`) |
 | `CompositeProvider` | Fans out across multiple providers with fallback logic |
 
 Five other packages (`omnia`, `statechain`, `lookup-node`, `lookup-client`, `chain-provider` itself) accept `ChainStateProvider` — this is the pivot point between the upper SDK and chain data.
@@ -50,7 +51,7 @@ const provider = new HostedProvider({
   projectSecret: process.env.AXIA_SECRET,
 });
 
-const tip  = await provider.getChainTip();
+const tip   = await provider.getTip();
 const coins = await provider.getCoins({ address: 'Mx...' });
 ```
 
@@ -64,31 +65,72 @@ const provider = new PureMinimaRpcProvider({
 });
 ```
 
+### Personal lookup node (sovereign, zero-Axia-dependency)
+
+Connect directly to your own lookup node over Hyperswarm DHT. No hosted infrastructure required.
+
+```typescript
+import { LookupClientProvider } from '@totemsdk/chain-provider';
+import { connectLookupNode } from '@totemsdk/lookup-client';
+
+// Connect to your personal lookup node
+const client = await connectLookupNode({ hyperswarmTopic: 'deadbeef...' });
+
+const provider = new LookupClientProvider(client);
+
+const tip   = await provider.getTip();
+const coins = await provider.getCoins({ address: 'Mx...' });
+
+// Clean up when done
+client.disconnect();
+```
+
+`@totemsdk/lookup-client` is a peer dependency — install it separately:
+
+```bash
+npm install @totemsdk/lookup-client
+```
+
 ### Composite with fallback
 
+Fan out across providers: try sovereign first, fall back to hosted on any error.
+
 ```typescript
-import { CompositeProvider, HostedProvider, PureMinimaRpcProvider } from '@totemsdk/chain-provider';
+import { CompositeProvider, HostedProvider, LookupClientProvider } from '@totemsdk/chain-provider';
+import { connectLookupNode } from '@totemsdk/lookup-client';
 
-const provider = new CompositeProvider([
-  new PureMinimaRpcProvider({ nodeUrl: 'http://localhost:9005' }),
-  new HostedProvider({ baseUrl: 'https://api.axia.to', projectId: '...' }),
-]);
-// Queries hit the first provider; fallback to the second on error
+const client  = await connectLookupNode({ hyperswarmTopic: 'deadbeef...' });
+const hosted  = new HostedProvider({ baseUrl: 'https://api.axia.to', projectId: '...' });
+
+const provider = new CompositeProvider(
+  new LookupClientProvider(client), // primary — sovereign, no Axia dependency
+  hosted,                           // fallback — hosted, always available
+);
+
+// Queries hit the lookup node first; fall back to hosted on error
+const tip = await provider.getTip();
 ```
 
-### Personal lookup node
+## LookupClientLike interface
+
+`LookupClientProvider` accepts any object that satisfies the `LookupClientLike` structural interface exported from this package. This allows testing with a mock without importing `@totemsdk/lookup-client`:
 
 ```typescript
-import { LookupNodeProvider } from '@totemsdk/chain-provider';
+import { LookupClientProvider } from '@totemsdk/chain-provider';
+import type { LookupClientLike } from '@totemsdk/chain-provider';
 
-const provider = new LookupNodeProvider({
-  publicKey: '...your-lookup-node-pubkey...',
-});
+const mockClient: LookupClientLike = {
+  getTip: async () => ({ block: 100, hash: '0x...' }),
+  getCoins: async () => [],
+  // ... etc
+};
+
+const provider = new LookupClientProvider(mockClient);
 ```
 
 ## See also
 
 - [`@totemsdk/pureminima-rpc`](https://www.npmjs.com/package/@totemsdk/pureminima-rpc) — the RPC client used by `PureMinimaRpcProvider`
-- [`@totemsdk/lookup-client`](https://www.npmjs.com/package/@totemsdk/lookup-client) — `LookupClientProvider` implementation
+- [`@totemsdk/lookup-client`](https://www.npmjs.com/package/@totemsdk/lookup-client) — connect to a personal lookup node over Hyperswarm DHT
 - [`@totemsdk/node`](https://www.npmjs.com/package/@totemsdk/node) — Node.js `MinimaProvider`
 - [`@totemsdk/omnia`](https://www.npmjs.com/package/@totemsdk/omnia) — uses `ChainStateProvider` for coin queries

package/dist/index.d.ts

@@ -2,5 +2,6 @@ export type { ChainStateProvider, CoinsQuery, Coin, MMRProof, ChainTip, TokenInf
 export { HostedProvider } from './providers/hosted.js';
 export type { HostedProviderConfig } from './providers/hosted.js';
 export { PureMinimaRpcProvider } from './providers/pureminima.js';
-export { LookupNodeProvider, LookupNodeNotImplementedError } from './providers/lookup.js';
+export { LookupClientProvider } from './providers/lookup-client.js';
+export type { LookupClientLike } from './providers/lookup-client.js';
 export { CompositeProvider } from './providers/composite.js';

package/dist/index.js

@@ -1,12 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompositeProvider = exports.LookupNodeNotImplementedError = exports.LookupNodeProvider = exports.PureMinimaRpcProvider = exports.HostedProvider = void 0;
+exports.CompositeProvider = exports.LookupClientProvider = exports.PureMinimaRpcProvider = exports.HostedProvider = void 0;
 var hosted_js_1 = require("./providers/hosted.js");
 Object.defineProperty(exports, "HostedProvider", { enumerable: true, get: function () { return hosted_js_1.HostedProvider; } });
 var pureminima_js_1 = require("./providers/pureminima.js");
 Object.defineProperty(exports, "PureMinimaRpcProvider", { enumerable: true, get: function () { return pureminima_js_1.PureMinimaRpcProvider; } });
-var lookup_js_1 = require("./providers/lookup.js");
-Object.defineProperty(exports, "LookupNodeProvider", { enumerable: true, get: function () { return lookup_js_1.LookupNodeProvider; } });
-Object.defineProperty(exports, "LookupNodeNotImplementedError", { enumerable: true, get: function () { return lookup_js_1.LookupNodeNotImplementedError; } });
+var lookup_client_js_1 = require("./providers/lookup-client.js");
+Object.defineProperty(exports, "LookupClientProvider", { enumerable: true, get: function () { return lookup_client_js_1.LookupClientProvider; } });
 var composite_js_1 = require("./providers/composite.js");
 Object.defineProperty(exports, "CompositeProvider", { enumerable: true, get: function () { return composite_js_1.CompositeProvider; } });

package/dist/providers/hosted.d.ts

@@ -1,6 +1,13 @@
 /**
- * HostedProvider — wraps existing Axia REST API endpoints.
- * Uses fetch only; no Node.js-specific dependencies.
+ * HostedProvider — wraps Axia REST + RPC API endpoints.
+ *
+ * Endpoint map (all require x-api-key header):
+ *   GET  /v1/wallet/utxos/:address  — coin list  (totem-shared key)
+ *   POST /v1/wallet/rpc             — Minima RPC commands (totem-shared key)
+ *   POST /api/meg/postminedtxn      — broadcast mined TxPoW (no auth required)
+ *
+ * For dApp developers using custom project API keys the `/v1/wallet/*` routes
+ * require x-api-key: 'totem-shared'. Use the apiKey config option accordingly.
  */
 import type { ChainStateProvider, CoinsQuery, Coin, MMRProof, ChainTip, TokenInfo, TokenSearchQuery, BroadcastResult } from '../types.js';
 export interface HostedProviderConfig {
@@ -14,12 +21,38 @@ export declare class HostedProvider implements ChainStateProvider {
     private readonly timeoutMs;
     constructor(config: HostedProviderConfig);
     private fetchJson;
+    /**
+     * Send a Minima command to POST /v1/wallet/rpc.
+     * Returns the `response` field of the Minima envelope.
+     */
+    private rpc;
+    /**
+     * Get coins (UTXOs) for an address.
+     * Maps GET /v1/wallet/utxos/:address → Coin[].
+     */
     getCoins(query: CoinsQuery): Promise<Coin[]>;
     getCoin(coinId: string): Promise<Coin | null>;
+    /**
+     * Get MMR proof for a coin via Minima `coinproof` RPC command.
+     */
     getProof(coinId: string): Promise<MMRProof>;
+    /**
+     * Get chain tip via Minima `status` RPC — parses response.chain.
+     */
     getTip(): Promise<ChainTip>;
+    /**
+     * Get token info via Minima `tokens tokenid:X` RPC command.
+     */
     getToken(tokenId: string): Promise<TokenInfo>;
+    /**
+     * Search tokens via Minima `tokens` RPC command, then filter client-side.
+     */
     searchTokens(query: TokenSearchQuery): Promise<TokenInfo[]>;
     getTokensByCreator(address: string): Promise<TokenInfo[]>;
+    /**
+     * Broadcast a mined TxPoW hex.
+     * Uses POST /api/meg/postminedtxn (the correct Axia MEG broadcast bridge).
+     */
     broadcastTxPoW(txpowHex: string): Promise<BroadcastResult>;
+    private _mapToken;
 }

package/dist/providers/hosted.js

@@ -1,13 +1,36 @@
 "use strict";
 /**
- * HostedProvider — wraps existing Axia REST API endpoints.
- * Uses fetch only; no Node.js-specific dependencies.
+ * HostedProvider — wraps Axia REST + RPC API endpoints.
+ *
+ * Endpoint map (all require x-api-key header):
+ *   GET  /v1/wallet/utxos/:address  — coin list  (totem-shared key)
+ *   POST /v1/wallet/rpc             — Minima RPC commands (totem-shared key)
+ *   POST /api/meg/postminedtxn      — broadcast mined TxPoW (no auth required)
+ *
+ * For dApp developers using custom project API keys the `/v1/wallet/*` routes
+ * require x-api-key: 'totem-shared'. Use the apiKey config option accordingly.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HostedProvider = void 0;
+function sanitizeRpcParam(value, name) {
+    if (value.length > 1024) {
+        throw new Error(`RPC parameter ${name} exceeds maximum length (1024)`);
+    }
+    if (/[\x00-\x1f\x7f]/.test(value)) {
+        throw new Error(`RPC parameter ${name} contains control characters`);
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        throw new Error(`RPC parameter ${name} is empty after trimming`);
+    }
+    return trimmed;
+}
 class HostedProvider {
     constructor(config) {
         this.baseUrl = config.baseUrl.replace(/\/$/, '');
+        if (!this.baseUrl.startsWith('https://')) {
+            throw new Error('HostedProvider requires HTTPS — credentials sent via x-api-key header');
+        }
         this.apiKey = config.apiKey;
         this.timeoutMs = config.timeoutMs ?? 30000;
     }
@@ -33,76 +56,188 @@ class HostedProvider {
             clearTimeout(timer);
         }
     }
+    /**
+     * Send a Minima command to POST /v1/wallet/rpc.
+     * Returns the `response` field of the Minima envelope.
+     */
+    async rpc(command) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+            const res = await fetch(`${this.baseUrl}/v1/wallet/rpc`, {
+                method: 'POST',
+                signal: controller.signal,
+                headers: {
+                    'Content-Type': 'text/plain',
+                    'x-api-key': this.apiKey,
+                },
+                body: command,
+            });
+            if (!res.ok)
+                throw new Error(`HostedProvider RPC "${command}" HTTP ${res.status}`);
+            const json = await res.json();
+            if (json.status === false)
+                throw new Error(`RPC "${command}" failed: ${json.error ?? 'unknown'}`);
+            return json.response;
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+    /**
+     * Get coins (UTXOs) for an address.
+     * Maps GET /v1/wallet/utxos/:address → Coin[].
+     */
     async getCoins(query) {
-        const params = new URLSearchParams();
-        if (query.address)
-            params.set('address', query.address);
-        if (query.tokenId)
-            params.set('tokenid', query.tokenId);
-        if (query.sendable !== undefined)
-            params.set('sendable', String(query.sendable));
-        if (query.relevant !== undefined)
-            params.set('relevant', String(query.relevant));
-        if (query.coinId)
-            params.set('coinid', query.coinId);
-        if (query.megammr !== undefined)
-            params.set('megammr', String(query.megammr));
-        const qs = params.toString();
-        const result = await this.fetchJson(`/v1/wallet/coins${qs ? `?${qs}` : ''}`);
-        return Array.isArray(result) ? result : (result.coins ?? []);
+        if (!query.address && !query.coinId)
+            return [];
+        if (query.coinId) {
+            const coin = await this.getCoin(query.coinId);
+            return coin ? [coin] : [];
+        }
+        const data = await this.fetchJson(`/v1/wallet/utxos/${encodeURIComponent(query.address)}`);
+        const raw = data.utxos ?? [];
+        return raw
+            .filter((u) => {
+            if (query.tokenId && u.tokenid !== query.tokenId)
+                return false;
+            if (query.sendable !== undefined && !!u.spent !== !query.sendable)
+                return false;
+            return true;
+        })
+            .map((u) => ({
+            coinid: u.coinid ?? u.id ?? '',
+            amount: String(u.amount ?? '0'),
+            address: u.address ?? query.address ?? '',
+            miniaddress: u.miniaddress,
+            tokenid: u.tokenid ?? '0x00',
+            token: u.token,
+            storestate: u.storestate,
+            state: u.state,
+            spent: !!u.spent,
+            mmrentry: u.mmrentry,
+            created: u.created,
+        }));
     }
     async getCoin(coinId) {
         try {
-            const coins = await this.getCoins({ coinId });
-            return coins[0] ?? null;
+            const clean = sanitizeRpcParam(coinId, 'coinId');
+            const coins = await this.rpc(`coins coinid:${clean}`);
+            const u = Array.isArray(coins) ? coins[0] : null;
+            if (!u)
+                return null;
+            return {
+                coinid: u.coinid ?? coinId,
+                amount: String(u.amount ?? '0'),
+                address: u.address ?? '',
+                miniaddress: u.miniaddress,
+                tokenid: u.tokenid ?? '0x00',
+                token: u.token,
+                storestate: u.storestate,
+                state: u.state,
+                spent: !!u.spent,
+                mmrentry: u.mmrentry,
+                created: u.created,
+            };
         }
         catch {
             return null;
         }
     }
+    /**
+     * Get MMR proof for a coin via Minima `coinproof` RPC command.
+     */
     async getProof(coinId) {
-        return this.fetchJson(`/v1/wallet/proofs/${encodeURIComponent(coinId)}`);
+        const clean = sanitizeRpcParam(coinId, 'coinId');
+        const data = await this.rpc(`coinproof coinid:${clean}`);
+        return { coinid: coinId, data };
     }
+    /**
+     * Get chain tip via Minima `status` RPC — parses response.chain.
+     */
     async getTip() {
-        const result = await this.fetchJson('/v1/status/tip');
-        if ('block' in result)
-            return result;
-        const r = result;
-        return (r.chain ?? r.tip);
+        const data = await this.rpc('status');
+        const chain = data?.chain;
+        return {
+            block: chain?.block ?? 0,
+            hash: chain?.hash ?? '',
+            time: chain?.time,
+        };
     }
+    /**
+     * Get token info via Minima `tokens tokenid:X` RPC command.
+     */
     async getToken(tokenId) {
-        return this.fetchJson(`/v1/tokens/${encodeURIComponent(tokenId)}`);
+        const clean = sanitizeRpcParam(tokenId, 'tokenId');
+        const data = await this.rpc(`tokens tokenid:${clean}`);
+        const t = Array.isArray(data) ? data[0] : data;
+        if (!t)
+            throw new Error(`Token not found: ${tokenId}`);
+        return this._mapToken(t);
     }
+    /**
+     * Search tokens via Minima `tokens` RPC command, then filter client-side.
+     */
     async searchTokens(query) {
-        const params = new URLSearchParams();
-        if (query.name)
-            params.set('name', query.name);
-        if (query.category?.length)
-            params.set('category', query.category.join(','));
-        if (query.creatorAddress)
-            params.set('creator', query.creatorAddress);
-        if (query.limit !== undefined)
-            params.set('limit', String(query.limit));
-        if (query.offset !== undefined)
-            params.set('offset', String(query.offset));
-        const qs = params.toString();
-        const result = await this.fetchJson(`/v1/tokens${qs ? `?${qs}` : ''}`);
-        return Array.isArray(result) ? result : (result.tokens ?? []);
+        const data = await this.rpc('tokens');
+        const all = Array.isArray(data) ? data : [];
+        return all
+            .filter((t) => {
+            if (t.tokenid === '0x00')
+                return false; // skip native Minima
+            if (query.name) {
+                const n = typeof t.name === 'object' ? (t.name?.name ?? '') : String(t.name ?? '');
+                if (!n.toLowerCase().includes(query.name.toLowerCase()))
+                    return false;
+            }
+            return true;
+        })
+            .slice(query.offset ?? 0, query.limit ? (query.offset ?? 0) + query.limit : undefined)
+            .map(this._mapToken);
     }
     async getTokensByCreator(address) {
         return this.searchTokens({ creatorAddress: address });
     }
+    /**
+     * Broadcast a mined TxPoW hex.
+     * Uses POST /api/meg/postminedtxn (the correct Axia MEG broadcast bridge).
+     */
     async broadcastTxPoW(txpowHex) {
         try {
-            const result = await this.fetchJson('/v1/txpow/broadcast', {
-                method: 'POST',
-                body: JSON.stringify({ txpow: txpowHex }),
-            });
-            return { success: true, txpowid: result.txpowid, message: result.message };
+            const controller = new AbortController();
+            const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+            let result;
+            try {
+                const res = await fetch(`${this.baseUrl}/api/meg/postminedtxn`, {
+                    method: 'POST',
+                    signal: controller.signal,
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ data: txpowHex }),
+                });
+                result = await res.json();
+                if (!res.ok)
+                    return { success: false, message: `HTTP ${res.status}: ${result?.error ?? ''}` };
+            }
+            finally {
+                clearTimeout(timer);
+            }
+            return { success: true, txpowid: result?.txpowid, message: result?.message };
         }
         catch (e) {
             return { success: false, message: String(e) };
         }
     }
+    _mapToken(t) {
+        return {
+            tokenid: t.tokenid ?? '',
+            name: typeof t.name === 'object' ? t.name : { name: String(t.name ?? '') },
+            total: t.total,
+            confirmed: t.confirmed,
+            sendable: t.sendable,
+            coins: t.coins,
+            script: t.script,
+            description: t.description,
+        };
+    }
 }
 exports.HostedProvider = HostedProvider;

package/dist/providers/lookup-client.d.ts

@@ -0,0 +1,62 @@
+/**
+ * LookupClientProvider — ChainStateProvider backed by a @totemsdk/lookup-client instance.
+ *
+ * Accepts any object that satisfies LookupClientLike (structural duck-typing),
+ * so @totemsdk/lookup-client remains a peer dependency: chain-provider does not
+ * bundle or import it at runtime. The caller is responsible for constructing the
+ * LookupClient and passing it in.
+ *
+ * @example
+ * ```ts
+ * import { connectLookupNode, LookupClientProvider } from '@totemsdk/lookup-client';
+ *
+ * const client = await connectLookupNode({ hyperswarmTopic: 'deadbeef...' });
+ * const provider = new LookupClientProvider(client);
+ *
+ * const tip   = await provider.getTip();
+ * const coins = await provider.getCoins({ address: 'Mx...' });
+ * ```
+ *
+ * Use inside a CompositeProvider for sovereign-first / hosted-fallback:
+ *
+ * ```ts
+ * import { CompositeProvider, HostedProvider, LookupClientProvider } from '@totemsdk/chain-provider';
+ * import { connectLookupNode } from '@totemsdk/lookup-client';
+ *
+ * const client   = await connectLookupNode({ hyperswarmTopic: 'abc...' });
+ * const fallback = new HostedProvider({ baseUrl: 'https://api.axia.to', projectId: '...' });
+ *
+ * const provider = new CompositeProvider(
+ *   new LookupClientProvider(client),
+ *   fallback,
+ * );
+ * ```
+ */
+import type { BroadcastResult, ChainStateProvider, ChainTip, Coin, CoinsQuery, MMRProof, TokenInfo, TokenSearchQuery } from '../types.js';
+/**
+ * Structural interface describing the subset of LookupClient methods that
+ * LookupClientProvider requires. Any object satisfying this interface can be
+ * passed in — most commonly a `LookupClient` from @totemsdk/lookup-client.
+ */
+export interface LookupClientLike {
+    getCoins(query: CoinsQuery): Promise<Coin[]>;
+    getCoin(coinId: string): Promise<Coin | null>;
+    getProof(coinId: string): Promise<MMRProof>;
+    getTip(): Promise<ChainTip>;
+    getToken(tokenId: string): Promise<TokenInfo>;
+    searchTokens(query: TokenSearchQuery): Promise<TokenInfo[]>;
+    getTokensByCreator(address: string): Promise<TokenInfo[]>;
+    broadcastTxPoW(txpowHex: string): Promise<BroadcastResult>;
+}
+export declare class LookupClientProvider implements ChainStateProvider {
+    private readonly _client;
+    constructor(_client: LookupClientLike);
+    getCoins(query: CoinsQuery): Promise<Coin[]>;
+    getCoin(coinId: string): Promise<Coin | null>;
+    getProof(coinId: string): Promise<MMRProof>;
+    getTip(): Promise<ChainTip>;
+    getToken(tokenId: string): Promise<TokenInfo>;
+    searchTokens(query: TokenSearchQuery): Promise<TokenInfo[]>;
+    getTokensByCreator(address: string): Promise<TokenInfo[]>;
+    broadcastTxPoW(txpowHex: string): Promise<BroadcastResult>;
+}

package/dist/providers/lookup-client.js

@@ -0,0 +1,67 @@
+"use strict";
+/**
+ * LookupClientProvider — ChainStateProvider backed by a @totemsdk/lookup-client instance.
+ *
+ * Accepts any object that satisfies LookupClientLike (structural duck-typing),
+ * so @totemsdk/lookup-client remains a peer dependency: chain-provider does not
+ * bundle or import it at runtime. The caller is responsible for constructing the
+ * LookupClient and passing it in.
+ *
+ * @example
+ * ```ts
+ * import { connectLookupNode, LookupClientProvider } from '@totemsdk/lookup-client';
+ *
+ * const client = await connectLookupNode({ hyperswarmTopic: 'deadbeef...' });
+ * const provider = new LookupClientProvider(client);
+ *
+ * const tip   = await provider.getTip();
+ * const coins = await provider.getCoins({ address: 'Mx...' });
+ * ```
+ *
+ * Use inside a CompositeProvider for sovereign-first / hosted-fallback:
+ *
+ * ```ts
+ * import { CompositeProvider, HostedProvider, LookupClientProvider } from '@totemsdk/chain-provider';
+ * import { connectLookupNode } from '@totemsdk/lookup-client';
+ *
+ * const client   = await connectLookupNode({ hyperswarmTopic: 'abc...' });
+ * const fallback = new HostedProvider({ baseUrl: 'https://api.axia.to', projectId: '...' });
+ *
+ * const provider = new CompositeProvider(
+ *   new LookupClientProvider(client),
+ *   fallback,
+ * );
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LookupClientProvider = void 0;
+class LookupClientProvider {
+    constructor(_client) {
+        this._client = _client;
+    }
+    getCoins(query) {
+        return this._client.getCoins(query);
+    }
+    getCoin(coinId) {
+        return this._client.getCoin(coinId);
+    }
+    getProof(coinId) {
+        return this._client.getProof(coinId);
+    }
+    getTip() {
+        return this._client.getTip();
+    }
+    getToken(tokenId) {
+        return this._client.getToken(tokenId);
+    }
+    searchTokens(query) {
+        return this._client.searchTokens(query);
+    }
+    getTokensByCreator(address) {
+        return this._client.getTokensByCreator(address);
+    }
+    broadcastTxPoW(txpowHex) {
+        return this._client.broadcastTxPoW(txpowHex);
+    }
+}
+exports.LookupClientProvider = LookupClientProvider;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/chain-provider",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "description": "Unified ChainStateProvider interface for Totem SDK — Hosted, PureMinima, Composite",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,22 +11,27 @@
       "import": "./dist/index.js"
     }
   },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "tsc",
+    "clean": "rm -rf dist",
+    "test": "jest --passWithNoTests"
+  },
   "files": [
     "dist",
     "README.md",
     "LICENSE"
   ],
   "dependencies": {
-    "@totemsdk/core": "1.0.9",
-    "@totemsdk/pureminima-rpc": "0.1.3"
+    "@totemsdk/core": "^1.1.0",
+    "@totemsdk/pureminima-rpc": "^0.1.3"
   },
   "devDependencies": {
-    "@noble/hashes": "^2.2.0",
-    "@types/jest": "^29.0.0",
+    "@types/jest": "^30.0.0",
     "@types/node": "^20.0.0",
-    "jest": "^29.0.0",
+    "jest": "^30.4.2",
     "ts-jest": "^29.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^7.0.2"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -36,13 +41,13 @@
   },
   "license": "MIT",
   "author": "Totem SDK",
-  "homepage": "https://totemsdk.com",
+  "homepage": "https://totem.ing",
   "bugs": {
-    "url": "https://github.com/MrGheek/axia-totem/issues"
+    "url": "https://github.com/totem-sdk/totem-sdk/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/MrGheek/axia-totem.git",
+    "url": "git+https://github.com/totem-sdk/totem-sdk.git",
     "directory": "packages/totem-sdk/packages/chain-provider"
   },
   "keywords": [
@@ -59,10 +64,5 @@
     "provider",
     "chain-data",
     "strategy-pattern"
-  ],
-  "scripts": {
-    "build": "tsc",
-    "clean": "rm -rf dist",
-    "test": "jest --passWithNoTests"
-  }
-}
+  ]
+}

package/dist/providers/lookup.d.ts

@@ -1,20 +0,0 @@
-/**
- * LookupNodeProvider — stub.
- *
- * Full implementation lives in @totemsdk/lookup-client which replaces this
- * stub once the lookup node package is available.
- */
-import type { ChainStateProvider, CoinsQuery, Coin, MMRProof, ChainTip, TokenInfo, TokenSearchQuery, BroadcastResult } from '../types.js';
-export declare class LookupNodeNotImplementedError extends Error {
-    constructor();
-}
-export declare class LookupNodeProvider implements ChainStateProvider {
-    getCoins(_query: CoinsQuery): Promise<Coin[]>;
-    getCoin(_coinId: string): Promise<Coin | null>;
-    getProof(_coinId: string): Promise<MMRProof>;
-    getTip(): Promise<ChainTip>;
-    getToken(_tokenId: string): Promise<TokenInfo>;
-    searchTokens(_query: TokenSearchQuery): Promise<TokenInfo[]>;
-    getTokensByCreator(_address: string): Promise<TokenInfo[]>;
-    broadcastTxPoW(_txpowHex: string): Promise<BroadcastResult>;
-}

package/dist/providers/lookup.js

@@ -1,45 +0,0 @@
-"use strict";
-/**
- * LookupNodeProvider — stub.
- *
- * Full implementation lives in @totemsdk/lookup-client which replaces this
- * stub once the lookup node package is available.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.LookupNodeProvider = exports.LookupNodeNotImplementedError = void 0;
-class LookupNodeNotImplementedError extends Error {
-    constructor() {
-        super('LookupNodeProvider is not yet implemented. ' +
-            'Install @totemsdk/lookup-client and use LookupClientProvider instead. ' +
-            'See https://github.com/Totem/totem-sdk for setup instructions.');
-        this.name = 'LookupNodeNotImplementedError';
-    }
-}
-exports.LookupNodeNotImplementedError = LookupNodeNotImplementedError;
-class LookupNodeProvider {
-    getCoins(_query) {
-        throw new LookupNodeNotImplementedError();
-    }
-    getCoin(_coinId) {
-        throw new LookupNodeNotImplementedError();
-    }
-    getProof(_coinId) {
-        throw new LookupNodeNotImplementedError();
-    }
-    getTip() {
-        throw new LookupNodeNotImplementedError();
-    }
-    getToken(_tokenId) {
-        throw new LookupNodeNotImplementedError();
-    }
-    searchTokens(_query) {
-        throw new LookupNodeNotImplementedError();
-    }
-    getTokensByCreator(_address) {
-        throw new LookupNodeNotImplementedError();
-    }
-    broadcastTxPoW(_txpowHex) {
-        throw new LookupNodeNotImplementedError();
-    }
-}
-exports.LookupNodeProvider = LookupNodeProvider;