@totemsdk/edge-adapters 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Totem SDK
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,56 @@
+# @totemsdk/edge-adapters
+
+Reference adapters bridging Totem SDK packages to `@totemsdk/edge` port interfaces.
+
+## What it does
+
+Wires the Totem SDK into Edge's composable port-based runtime. Each adapter is a factory function that takes SDK dependencies and returns an object implementing the corresponding Edge port interface.
+
+## Adapters
+
+| Adapter | Port Interface | SDK Dependency |
+|---------|---------------|----------------|
+| `createLiquidityPortAdapter` | `EdgeLiquidityPort` | `@totemsdk/chain-provider` |
+| `createProofPortAdapter` | `EdgeProofPort` | `@totemsdk/proof` |
+| `createLookupPortAdapter` | `EdgeLookupPort` | `@totemsdk/lookup-client` |
+| `createPolicyPortAdapter` | `EdgePolicyPort` | `@totemsdk/agent-policy` |
+| `createIdentityPortAdapter` | `EdgeIdentityPort` | `@totemsdk/identity` |
+| `createManifestPortAdapter` | `EdgeManifestPort` | `@totemsdk/manifest` |
+| `createMinimaL1PaymentPort` | `EdgePaymentPort` | `@totemsdk/root-identity` |
+| `createOmniaL2PaymentPort` | `EdgePaymentPort` | `@totemsdk/omnia-router` |
+
+## Installation
+
+```bash
+npm install @totemsdk/edge-adapters
+```
+
+All SDK dependencies are optional peer dependencies — install only the ones you need for the adapters you use.
+
+## Usage
+
+```ts
+import { createEdgeRuntime, createEdgeDevice, createCapabilitySet } from '@totemsdk/edge';
+import { createLiquidityPortAdapter, createProofPortAdapter } from '@totemsdk/edge-adapters';
+import { HostedProvider } from '@totemsdk/chain-provider';
+import { createProof, signProof } from '@totemsdk/proof';
+
+const chainProvider = new HostedProvider({ baseUrl: 'https://api.axia.to', apiKey: '...' });
+
+const liquidityPort = createLiquidityPortAdapter({ chainProvider });
+const proofPort = createProofPortAdapter({ createProof, signProof });
+
+const device = createEdgeDevice({ deviceId: 'my-device' });
+const capabilities = createCapabilitySet(['payment:send', 'proof:create']);
+const runtime = createEdgeRuntime({ device, capabilities, ports: { liquidityPort, proofPort } });
+```
+
+## Out of scope
+
+- Implementing port interfaces — those are defined in `@totemsdk/edge`
+- Implementing SDK functionality — each adapter delegates to the corresponding SDK package
+- Transport/networking — adapters are transport-agnostic
+
+## License
+
+MIT

package/dist/identity.d.ts

@@ -0,0 +1,19 @@
+import type { IdentityGraph } from '@totemsdk/identity';
+import type { EdgeIdentityPort } from '@totemsdk/edge';
+export interface IdentityPortConfig {
+    /**
+     * The identity graph this adapter can resolve. Callers holding multiple
+     * identities should create one adapter per graph.
+     */
+    graph: IdentityGraph;
+}
+/**
+ * Wraps an IdentityGraph (from @totemsdk/identity) as an EdgeIdentityPort.
+ *
+ * resolve: returns the resolved identity when identityId matches graph.document.id,
+ *          otherwise returns ok:false. For multi-identity setups, compose multiple
+ *          adapters or use a router above this layer.
+ * verify:  delegates to verifyIdentityClaim() for SignedIdentityClaim values.
+ *          Returns ok:false for unrecognised proof shapes.
+ */
+export declare function createIdentityPortAdapter(config: IdentityPortConfig): EdgeIdentityPort;

package/dist/identity.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createIdentityPortAdapter = createIdentityPortAdapter;
+const identity_1 = require("@totemsdk/identity");
+/**
+ * Wraps an IdentityGraph (from @totemsdk/identity) as an EdgeIdentityPort.
+ *
+ * resolve: returns the resolved identity when identityId matches graph.document.id,
+ *          otherwise returns ok:false. For multi-identity setups, compose multiple
+ *          adapters or use a router above this layer.
+ * verify:  delegates to verifyIdentityClaim() for SignedIdentityClaim values.
+ *          Returns ok:false for unrecognised proof shapes.
+ */
+function createIdentityPortAdapter(config) {
+    const { graph } = config;
+    return {
+        async resolve(identityId) {
+            try {
+                if (graph.document.id !== identityId) {
+                    return {
+                        ok: false,
+                        error: `Identity "${identityId}" not found in this adapter's graph`,
+                        errorCode: 'IDENTITY_NOT_FOUND',
+                    };
+                }
+                const result = (0, identity_1.resolveIdentityGraph)(graph);
+                if (!result.resolved) {
+                    return {
+                        ok: false,
+                        error: result.errors?.join('; ') ?? 'Identity could not be resolved',
+                        errorCode: 'IDENTITY_UNRESOLVABLE',
+                    };
+                }
+                return { ok: true, data: { identity: result.resolved } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        async verify(proof) {
+            try {
+                const claim = proof;
+                if (!claim?.proof?.address) {
+                    return {
+                        ok: false,
+                        error: 'Proof is not a recognisable SignedIdentityClaim',
+                        errorCode: 'UNSUPPORTED_PROOF_TYPE',
+                    };
+                }
+                const result = (0, identity_1.verifyIdentityClaim)(claim);
+                return {
+                    ok: true,
+                    data: { valid: result.valid, address: result.valid ? claim.proof.address : undefined },
+                };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+export { createLiquidityPortAdapter } from './liquidity.js';
+export type { LiquidityPortConfig } from './liquidity.js';
+export { createProofPortAdapter } from './proof.js';
+export type { ProofPortConfig } from './proof.js';
+export { createLookupPortAdapter } from './lookup.js';
+export { createPolicyPortAdapter } from './policy.js';
+export { createIdentityPortAdapter } from './identity.js';
+export type { IdentityPortConfig } from './identity.js';
+export { createManifestPortAdapter } from './manifest.js';
+export { createMinimaL1PaymentPort } from './payment-l1.js';
+export type { MinimaL1PaymentPortConfig } from './payment-l1.js';
+export { createOmniaL2PaymentPort } from './payment-l2.js';
+export type { OmniaL2PaymentPortConfig } from './payment-l2.js';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOmniaL2PaymentPort = exports.createMinimaL1PaymentPort = exports.createManifestPortAdapter = exports.createIdentityPortAdapter = exports.createPolicyPortAdapter = exports.createLookupPortAdapter = exports.createProofPortAdapter = exports.createLiquidityPortAdapter = void 0;
+var liquidity_js_1 = require("./liquidity.js");
+Object.defineProperty(exports, "createLiquidityPortAdapter", { enumerable: true, get: function () { return liquidity_js_1.createLiquidityPortAdapter; } });
+var proof_js_1 = require("./proof.js");
+Object.defineProperty(exports, "createProofPortAdapter", { enumerable: true, get: function () { return proof_js_1.createProofPortAdapter; } });
+var lookup_js_1 = require("./lookup.js");
+Object.defineProperty(exports, "createLookupPortAdapter", { enumerable: true, get: function () { return lookup_js_1.createLookupPortAdapter; } });
+var policy_js_1 = require("./policy.js");
+Object.defineProperty(exports, "createPolicyPortAdapter", { enumerable: true, get: function () { return policy_js_1.createPolicyPortAdapter; } });
+var identity_js_1 = require("./identity.js");
+Object.defineProperty(exports, "createIdentityPortAdapter", { enumerable: true, get: function () { return identity_js_1.createIdentityPortAdapter; } });
+var manifest_js_1 = require("./manifest.js");
+Object.defineProperty(exports, "createManifestPortAdapter", { enumerable: true, get: function () { return manifest_js_1.createManifestPortAdapter; } });
+var payment_l1_js_1 = require("./payment-l1.js");
+Object.defineProperty(exports, "createMinimaL1PaymentPort", { enumerable: true, get: function () { return payment_l1_js_1.createMinimaL1PaymentPort; } });
+var payment_l2_js_1 = require("./payment-l2.js");
+Object.defineProperty(exports, "createOmniaL2PaymentPort", { enumerable: true, get: function () { return payment_l2_js_1.createOmniaL2PaymentPort; } });

package/dist/liquidity.d.ts

@@ -0,0 +1,15 @@
+import type { ChainStateProvider } from '@totemsdk/chain-provider';
+import type { EdgeLiquidityPort } from '@totemsdk/edge';
+export interface LiquidityPortConfig {
+    provider: ChainStateProvider;
+    /** Token to sum when getBalance is called without an explicit tokenId. Defaults to '0x00' (native Minima). */
+    defaultTokenId?: string;
+}
+/**
+ * Wraps a ChainStateProvider (chain-provider, pureminima-rpc, lookup-client) as
+ * an EdgeLiquidityPort.
+ *
+ * getBalance sums sendable coins for the given address and tokenId.
+ * getUtxos returns all coins as raw UTXOs (typed as unknown[] per the port contract).
+ */
+export declare function createLiquidityPortAdapter(config: LiquidityPortConfig): EdgeLiquidityPort;

package/dist/liquidity.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLiquidityPortAdapter = createLiquidityPortAdapter;
+const _SCALE = 100000000n;
+function _toScaled(s) {
+    const [i, f = ''] = s.split('.');
+    return BigInt(i || '0') * _SCALE + BigInt(f.padEnd(8, '0').slice(0, 8));
+}
+function _fromScaled(n) {
+    if (n === 0n)
+        return '0';
+    const frac = (n % _SCALE).toString().padStart(8, '0').replace(/0+$/, '');
+    return frac ? `${n / _SCALE}.${frac}` : `${n / _SCALE}`;
+}
+/**
+ * Wraps a ChainStateProvider (chain-provider, pureminima-rpc, lookup-client) as
+ * an EdgeLiquidityPort.
+ *
+ * getBalance sums sendable coins for the given address and tokenId.
+ * getUtxos returns all coins as raw UTXOs (typed as unknown[] per the port contract).
+ */
+function createLiquidityPortAdapter(config) {
+    const { provider, defaultTokenId = '0x00' } = config;
+    return {
+        async getBalance(address) {
+            try {
+                const coins = await provider.getCoins({ address, tokenId: defaultTokenId, sendable: true });
+                const balance = _fromScaled(coins.reduce((sum, c) => sum + _toScaled(c.amount), 0n));
+                return { ok: true, data: { balance, tokenId: defaultTokenId } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        async getUtxos(address) {
+            try {
+                const coins = await provider.getCoins({ address });
+                return { ok: true, data: { utxos: coins } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    };
+}

package/dist/lookup.d.ts

@@ -0,0 +1,13 @@
+import type { LookupClient } from '@totemsdk/lookup-client';
+import type { EdgeLookupPort } from '@totemsdk/edge';
+/**
+ * Wraps a LookupClient as an EdgeLookupPort.
+ *
+ * lookup:  queries coins by address, or a single coin by ID when kind === 'coin'.
+ * watch:   registers for real-time coin-update push events.
+ * announce: encodes the caller's WOTS-signed manifest to bytes, then hands off
+ *           to announceApp() or announceAgent() on the client. The client signs
+ *           those bytes with its session Ed25519 keypair — no WOTS key index is
+ *           consumed. Fire-and-forget: the lookup node sends no ACK.
+ */
+export declare function createLookupPortAdapter(client: LookupClient): EdgeLookupPort;

package/dist/lookup.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLookupPortAdapter = createLookupPortAdapter;
+const manifest_1 = require("@totemsdk/manifest");
+/**
+ * Wraps a LookupClient as an EdgeLookupPort.
+ *
+ * lookup:  queries coins by address, or a single coin by ID when kind === 'coin'.
+ * watch:   registers for real-time coin-update push events.
+ * announce: encodes the caller's WOTS-signed manifest to bytes, then hands off
+ *           to announceApp() or announceAgent() on the client. The client signs
+ *           those bytes with its session Ed25519 keypair — no WOTS key index is
+ *           consumed. Fire-and-forget: the lookup node sends no ACK.
+ */
+function createLookupPortAdapter(client) {
+    return {
+        async lookup(params) {
+            try {
+                if (params.kind === 'coin') {
+                    const coin = await client.getCoin(params.query);
+                    return { ok: true, data: { results: coin ? [coin] : [] } };
+                }
+                const coins = await client.getCoins({ address: params.query });
+                return { ok: true, data: { results: coins } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        async watch(params) {
+            try {
+                const unsubscribe = client.subscribeCoinUpdates(params.onUpdate);
+                await client.watchAddress(params.address);
+                return { ok: true, data: { unsubscribe } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        async announce(params) {
+            try {
+                const manifestBytes = (0, manifest_1.encodeManifest)(params.signed);
+                if (params.kind === 'app') {
+                    await client.announceApp({
+                        manifest: manifestBytes,
+                        appId: params.appId,
+                        expiresAt: params.expiresAt,
+                        authorAddress: params.authorAddress,
+                        isFree: params.isFree,
+                    });
+                }
+                else {
+                    await client.announceAgent({
+                        manifest: manifestBytes,
+                        capabilityId: params.capabilityId,
+                        expiresAt: params.expiresAt,
+                        tags: params.tags,
+                        pricePerCall: params.pricePerCall,
+                        latencyMs: params.latencyMs,
+                    });
+                }
+                return { ok: true };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        async query(params) {
+            try {
+                if (params.kind === 'app') {
+                    const apps = await client.queryApps({
+                        category: params.category,
+                        authorAddress: params.authorAddress,
+                        minVersion: params.minVersion,
+                        freeOnly: params.freeOnly,
+                        limit: params.limit,
+                    });
+                    return { ok: true, data: { results: apps.map((a) => ({ id: a.appId, manifest: a.manifest, nodeId: a.nodeId })) } };
+                }
+                else {
+                    const agents = await client.queryAgents({
+                        capabilityName: params.capabilityName,
+                        tags: params.tags,
+                        maxPricePerCall: params.maxPricePerCall,
+                        maxLatencyMs: params.maxLatencyMs,
+                        limit: params.limit,
+                    });
+                    return { ok: true, data: { results: agents.map((a) => ({ id: a.capabilityId, manifest: a.manifest, nodeId: a.nodeId })) } };
+                }
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    };
+}

package/dist/manifest.d.ts

@@ -0,0 +1,11 @@
+import type { EdgeManifestPort } from '@totemsdk/edge';
+/**
+ * Wraps @totemsdk/manifest's signManifest / verifyManifest as an EdgeManifestPort.
+ *
+ * The port interface already carries seed and keyIndex at call time, so this
+ * adapter has no constructor config — it is purely a thin type bridge.
+ *
+ * Callers are responsible for key-lease reservation before calling sign().
+ * This adapter does not interact with @totemsdk/wots-lease.
+ */
+export declare function createManifestPortAdapter(): EdgeManifestPort;

package/dist/manifest.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createManifestPortAdapter = createManifestPortAdapter;
+const manifest_1 = require("@totemsdk/manifest");
+/**
+ * Wraps @totemsdk/manifest's signManifest / verifyManifest as an EdgeManifestPort.
+ *
+ * The port interface already carries seed and keyIndex at call time, so this
+ * adapter has no constructor config — it is purely a thin type bridge.
+ *
+ * Callers are responsible for key-lease reservation before calling sign().
+ * This adapter does not interact with @totemsdk/wots-lease.
+ */
+function createManifestPortAdapter() {
+    return {
+        async sign(manifest, seed, keyIndex) {
+            try {
+                const signed = await (0, manifest_1.signManifest)(manifest, seed, keyIndex);
+                return { ok: true, data: { signed } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        async verify(signed) {
+            try {
+                const result = (0, manifest_1.verifyManifest)(signed);
+                return { ok: true, data: { valid: result.valid, reason: result.reason } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    };
+}

package/dist/payment-l1.d.ts

@@ -0,0 +1,38 @@
+import type { ChainStateProvider } from '@totemsdk/chain-provider';
+import type { EdgePaymentPort } from '@totemsdk/edge';
+export interface MinimaL1PaymentPortConfig {
+    /** ChainStateProvider used to broadcast the signed TxPoW. */
+    provider: ChainStateProvider;
+    /**
+     * Injected signing function. Receives the payment intent and returns a
+     * fully mined TxPoW hex string ready for broadcast.
+     *
+     * This keeps the adapter agnostic to key management — callers wire in their
+     * own signer (e.g. @totemsdk/server's sendTransaction, a hardware wallet
+     * bridge, or a pureminima-rpc command sequence).
+     */
+    sign(params: {
+        toAddress: string;
+        amount: string;
+        tokenId: string;
+        memo?: string;
+    }): Promise<string>;
+}
+/**
+ * Minima L1 payment adapter.
+ *
+ * Delegates transaction construction and signing to the injected `sign` function,
+ * then broadcasts the result via the ChainStateProvider. This keeps key material
+ * out of the adapter entirely.
+ *
+ * For a batteries-included L1 adapter backed by @totemsdk/server's sendTransaction,
+ * wrap sendTransaction in the sign callback:
+ *
+ *   createMinimaL1PaymentPort({
+ *     provider: new PureMinimaRpcProvider(rpcConfig),
+ *     sign: ({ toAddress, amount, tokenId }) =>
+ *       sendTransaction({ seed, addressIndex, toAddress, amount, tokenId, ... })
+ *         .then(r => r.minedHex),
+ *   })
+ */
+export declare function createMinimaL1PaymentPort(config: MinimaL1PaymentPortConfig): EdgePaymentPort;

package/dist/payment-l1.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMinimaL1PaymentPort = createMinimaL1PaymentPort;
+/**
+ * Minima L1 payment adapter.
+ *
+ * Delegates transaction construction and signing to the injected `sign` function,
+ * then broadcasts the result via the ChainStateProvider. This keeps key material
+ * out of the adapter entirely.
+ *
+ * For a batteries-included L1 adapter backed by @totemsdk/server's sendTransaction,
+ * wrap sendTransaction in the sign callback:
+ *
+ *   createMinimaL1PaymentPort({
+ *     provider: new PureMinimaRpcProvider(rpcConfig),
+ *     sign: ({ toAddress, amount, tokenId }) =>
+ *       sendTransaction({ seed, addressIndex, toAddress, amount, tokenId, ... })
+ *         .then(r => r.minedHex),
+ *   })
+ */
+function createMinimaL1PaymentPort(config) {
+    return {
+        async pay(params) {
+            try {
+                const txpowHex = await config.sign({
+                    toAddress: params.recipient,
+                    amount: params.amount,
+                    tokenId: params.tokenId ?? '0x00',
+                    memo: params.memo,
+                });
+                const result = await config.provider.broadcastTxPoW(txpowHex);
+                if (!result.success) {
+                    return {
+                        ok: false,
+                        error: result.message ?? 'Broadcast failed',
+                        errorCode: 'BROADCAST_FAILED',
+                    };
+                }
+                return { ok: true, data: { txpowId: result.txpowid } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    };
+}

package/dist/payment-l2.d.ts

@@ -0,0 +1,39 @@
+import type { ChannelGraph, ChannelOps, RouterChannel, LeaseProvider, RouteOptions } from '@totemsdk/omnia-router';
+import type { EdgePaymentPort } from '@totemsdk/edge';
+export interface OmniaL2PaymentPortConfig {
+    /** Routing graph (edges + swap index). Updated externally as channels open/close. */
+    graph: ChannelGraph;
+    /**
+     * Live channel state keyed by channelId.
+     * executeMultiHopPayment mutates this map in-place as HTLCs are added/settled.
+     * Callers are responsible for keeping it in sync with the on-chain state.
+     */
+    channels: Map<string, RouterChannel>;
+    /** HTLC operations (addHTLC, fulfillHTLC, timeoutHTLC) for each channel. */
+    ops: ChannelOps;
+    /** WOTS lease providers keyed by channelId — required for HTLC signing. */
+    leaseProviders: Map<string, LeaseProvider>;
+    /** Public key digest identifying the local party in each channel. */
+    localPublicKeyDigest: string;
+    /**
+     * Returns the current chain block height. Used to compute HTLC expiry.
+     * Typically: `async () => BigInt((await provider.getTip()).block)`.
+     */
+    getCurrentBlock(): Promise<bigint>;
+    /** HTLC timeout in blocks past the current tip. Defaults to 144 (≈24h on Minima). */
+    htlcTimeoutBlocks?: bigint;
+    /** Optional pathfinding overrides forwarded to findRoute. */
+    routeOptions?: RouteOptions;
+}
+/**
+ * Omnia L2 payment adapter.
+ *
+ * Routes payments over Omnia payment channels using multi-hop HTLC execution.
+ * The local node must already have open channels forming a path to the recipient.
+ *
+ * pay() finds a route, builds a PaymentRequest, and executes atomically:
+ *  1. Forward phase — locks HTLCs across each hop.
+ *  2. Reveal phase — reveals the preimage in reverse to settle all hops.
+ *  Rollback (best-effort timeoutHTLC) fires on any failure.
+ */
+export declare function createOmniaL2PaymentPort(config: OmniaL2PaymentPortConfig): EdgePaymentPort;

package/dist/payment-l2.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOmniaL2PaymentPort = createOmniaL2PaymentPort;
+const omnia_router_1 = require("@totemsdk/omnia-router");
+const _SCALE = 100000000n;
+function _toScaled(s) {
+    const [i, f = ''] = s.split('.');
+    return BigInt(i || '0') * _SCALE + BigInt(f.padEnd(8, '0').slice(0, 8));
+}
+/**
+ * Omnia L2 payment adapter.
+ *
+ * Routes payments over Omnia payment channels using multi-hop HTLC execution.
+ * The local node must already have open channels forming a path to the recipient.
+ *
+ * pay() finds a route, builds a PaymentRequest, and executes atomically:
+ *  1. Forward phase — locks HTLCs across each hop.
+ *  2. Reveal phase — reveals the preimage in reverse to settle all hops.
+ *  Rollback (best-effort timeoutHTLC) fires on any failure.
+ */
+function createOmniaL2PaymentPort(config) {
+    const htlcTimeoutBlocks = config.htlcTimeoutBlocks ?? 144n;
+    return {
+        async pay(params) {
+            try {
+                const tokenId = params.tokenId ?? '0x00';
+                const amount = _toScaled(params.amount);
+                const route = (0, omnia_router_1.findRoute)(config.graph, config.localPublicKeyDigest, params.recipient, amount, tokenId, config.routeOptions);
+                if (!route) {
+                    return {
+                        ok: false,
+                        error: `No route found to ${params.recipient} for amount ${params.amount} (${tokenId})`,
+                        errorCode: 'NO_ROUTE',
+                    };
+                }
+                const currentBlock = await config.getCurrentBlock();
+                const expiryBlock = currentBlock + htlcTimeoutBlocks;
+                const request = (0, omnia_router_1.buildPaymentRequest)(amount, tokenId, expiryBlock);
+                const result = await (0, omnia_router_1.executeMultiHopPayment)(config.ops, config.channels, route, request, config.leaseProviders);
+                if (!result.success) {
+                    return {
+                        ok: false,
+                        error: result.error ?? 'Multi-hop payment failed',
+                        errorCode: 'PAYMENT_FAILED',
+                    };
+                }
+                return { ok: true, data: { txpowId: result.preimage } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    };
+}

package/dist/policy.d.ts

@@ -0,0 +1,11 @@
+import type { AgentPolicy } from '@totemsdk/agent-policy';
+import type { EdgePolicyPort } from '@totemsdk/edge';
+/**
+ * Wraps an AgentPolicy as an EdgePolicyPort.
+ *
+ * Builds a minimal AgentProposal from the EdgePolicyPort check() params and
+ * delegates to policy.canAutoApprove(). The intent type is inferred from the
+ * action string (actions starting with 'pay' map to 'payment'; everything
+ * else maps to 'receipt' as a catch-all).
+ */
+export declare function createPolicyPortAdapter(policy: AgentPolicy): EdgePolicyPort;

package/dist/policy.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPolicyPortAdapter = createPolicyPortAdapter;
+/**
+ * Wraps an AgentPolicy as an EdgePolicyPort.
+ *
+ * Builds a minimal AgentProposal from the EdgePolicyPort check() params and
+ * delegates to policy.canAutoApprove(). The intent type is inferred from the
+ * action string (actions starting with 'pay' map to 'payment'; everything
+ * else maps to 'receipt' as a catch-all).
+ */
+function createPolicyPortAdapter(policy) {
+    return {
+        async check(params) {
+            try {
+                const intentType = params.action.startsWith('pay') ? 'payment' : 'receipt';
+                const proposal = {
+                    id: `edge-policy-${params.action}-${params.subject}-${Date.now()}`,
+                    agentId: 'edge-policy-adapter',
+                    intent: {
+                        type: intentType,
+                        recipient: params.subject,
+                        reason: params.action,
+                        risk: params.context?.['risk'] ?? 'low',
+                        metadata: params.context,
+                    },
+                    explanation: `Policy check for action "${params.action}" by subject "${params.subject}"`,
+                    confidence: 1,
+                    createdAt: Date.now(),
+                };
+                const allowed = await policy.canAutoApprove(proposal);
+                return {
+                    ok: true,
+                    data: {
+                        allowed,
+                        reason: allowed ? undefined : 'Action requires user approval per configured policy',
+                    },
+                };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    };
+}

package/dist/proof.d.ts

@@ -0,0 +1,18 @@
+import type { ProofProvider, ProofKind } from '@totemsdk/proof';
+import type { EdgeProofPort } from '@totemsdk/edge';
+export interface ProofPortConfig {
+    provider: ProofProvider;
+    /** Issuer address or identifier stamped onto created proofs. */
+    issuer: string;
+    /** Default proof kind when callers don't specify one via context. */
+    defaultKind?: ProofKind;
+}
+/**
+ * Wraps a ProofProvider (e.g. proof-integritas) as an EdgeProofPort.
+ *
+ * createProof: builds an unsigned proof from the EdgeProofPort params, then
+ *   stamps its canonical hash via provider.stampHash if available.
+ * verifyProof: delegates to provider.verifyProof for SignedProof values,
+ *   or provider.checkProof for lightweight existence checks.
+ */
+export declare function createProofPortAdapter(config: ProofPortConfig): EdgeProofPort;

package/dist/proof.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProofPortAdapter = createProofPortAdapter;
+const proof_1 = require("@totemsdk/proof");
+/**
+ * Wraps a ProofProvider (e.g. proof-integritas) as an EdgeProofPort.
+ *
+ * createProof: builds an unsigned proof from the EdgeProofPort params, then
+ *   stamps its canonical hash via provider.stampHash if available.
+ * verifyProof: delegates to provider.verifyProof for SignedProof values,
+ *   or provider.checkProof for lightweight existence checks.
+ */
+function createProofPortAdapter(config) {
+    const { provider, issuer, defaultKind = 'attestation' } = config;
+    return {
+        async createProof(params) {
+            try {
+                const kind = params.context?.['kind'] ?? defaultKind;
+                const unsigned = (0, proof_1.createProof)({
+                    kind,
+                    subject: { id: params.subject, kind: 'edge-subject' },
+                    issuer,
+                    payload: { claims: params.claims, ...(params.context ?? {}) },
+                });
+                // Stamp the proof's canonical hash if the provider supports it.
+                if (provider.stampHash) {
+                    const hash = (0, proof_1.toHex)(new Uint8Array(await crypto.subtle.digest('SHA-256', new TextEncoder().encode((0, proof_1.canonicalJson)(unsigned)))));
+                    await provider.stampHash({ hash });
+                }
+                return { ok: true, data: { proofId: unsigned.proofId, proof: unsigned } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        async verifyProof(params) {
+            try {
+                const proof = params.proof;
+                if (provider.verifyProof) {
+                    const result = await provider.verifyProof(proof);
+                    return { ok: true, data: { valid: result.valid, reason: result.reason } };
+                }
+                if (provider.checkProof) {
+                    const result = await provider.checkProof(proof);
+                    const valid = result.ok && !result.error;
+                    return { ok: true, data: { valid, reason: result.error } };
+                }
+                return {
+                    ok: false,
+                    error: 'Provider does not support proof verification',
+                    errorCode: 'NO_VERIFY_CAPABILITY',
+                };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    };
+}

package/package.json

@@ -0,0 +1,98 @@
+{
+  "name": "@totemsdk/edge-adapters",
+  "version": "0.1.0",
+  "description": "Reference adapters bridging Totem SDK packages to @totemsdk/edge port interfaces",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.js",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "tsc",
+    "clean": "rm -rf dist",
+    "test": "jest --passWithNoTests"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "@totemsdk/agent-policy": "^0.1.3",
+    "@totemsdk/chain-provider": "^0.1.4",
+    "@totemsdk/identity": "^0.1.2",
+    "@totemsdk/lookup-client": "^0.1.4",
+    "@totemsdk/manifest": "^0.1.2",
+    "@totemsdk/omnia-router": "^0.1.4",
+    "@totemsdk/proof": "^0.1.1",
+    "@totemsdk/root-identity": "^1.0.7"
+  },
+  "peerDependenciesMeta": {
+    "@totemsdk/agent-policy": {
+      "optional": true
+    },
+    "@totemsdk/chain-provider": {
+      "optional": true
+    },
+    "@totemsdk/identity": {
+      "optional": true
+    },
+    "@totemsdk/manifest": {
+      "optional": true
+    },
+    "@totemsdk/omnia-router": {
+      "optional": true
+    },
+    "@totemsdk/proof": {
+      "optional": true
+    },
+    "@totemsdk/lookup-client": {
+      "optional": true
+    },
+    "@totemsdk/root-identity": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@totemsdk/agent-policy": "^0.1.3",
+    "@totemsdk/chain-provider": "^0.1.4",
+    "@totemsdk/edge": "^0.1.3",
+    "@totemsdk/identity": "^0.1.2",
+    "@totemsdk/lookup-client": "^0.1.5",
+    "@totemsdk/manifest": "^0.1.2",
+    "@totemsdk/omnia-router": "^0.1.4",
+    "@totemsdk/proof": "^0.1.1",
+    "@totemsdk/root-identity": "^1.0.7",
+    "@types/jest": "^29.0.0",
+    "@types/node": "^20.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "license": "MIT",
+  "author": "Totem SDK",
+  "homepage": "https://totemsdk.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/MrGheek/axia-totem.git",
+    "directory": "packages/totem-sdk/packages/edge-adapters"
+  },
+  "keywords": [
+    "totem",
+    "totemsdk",
+    "edge",
+    "adapters",
+    "ports"
+  ]
+}