@totemsdk/chain-provider 0.1.3 → 0.1.4

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,7 +1,14 @@
 "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;
@@ -33,76 +40,185 @@ 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 coins = await this.rpc(`coins coinid:${coinId}`);
+            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 data = await this.rpc(`coinproof coinid:${coinId}`);
+        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 data = await this.rpc(`tokens tokenid:${tokenId}`);
+        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.4",
   "description": "Unified ChainStateProvider interface for Totem SDK — Hosted, PureMinima, Composite",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -17,7 +17,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@totemsdk/core": "1.0.9",
+    "@totemsdk/core": "1.1.0",
     "@totemsdk/pureminima-rpc": "0.1.3"
   },
   "devDependencies": {