@totemsdk/edge-adapters 0.2.0 → 0.3.0

package/dist/cjs/location.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLocationPortAdapter = createLocationPortAdapter;
+const location_proof_1 = require("@totemsdk/location-proof");
+const DEVICE_CLASSES = [
+    'drone',
+    'vehicle',
+    'robot',
+    'ship',
+    'tractor',
+    'phone',
+    'sensor',
+    'gateway',
+    'camera',
+    'weather-station',
+    'security-device',
+    'other',
+];
+const SOURCE_TYPES = [
+    'gnss',
+    'gps',
+    'rtk',
+    'cell',
+    'wifi',
+    'ble',
+    'lorawan',
+    'gateway',
+    'network',
+    'manual',
+    'derived',
+    'other',
+];
+function assertLocationClaim(claim) {
+    if (!claim || typeof claim !== 'object') {
+        throw new Error('claim is not a LocationClaim');
+    }
+    const c = claim;
+    if (typeof c.subjectId !== 'string' || typeof c.deviceId !== 'string' || !c.location) {
+        throw new Error('claim is not a valid LocationClaim');
+    }
+}
+function toSourceType(type) {
+    if (type !== undefined && SOURCE_TYPES.includes(type)) {
+        return type;
+    }
+    return 'other';
+}
+/**
+ * Wraps @totemsdk/location-proof as an EdgeLocationPort.
+ *
+ * createClaim/createTrail build content-derived Totem-location claims/trails.
+ * createProof returns a SignedProof when config.seed is set; otherwise it
+ * returns an UnsignedProof that MUST NOT be presented as a completed proof.
+ */
+function createLocationPortAdapter(config = {}) {
+    return {
+        async createClaim(params) {
+            try {
+                const deviceClass = DEVICE_CLASSES.includes(params.deviceClass)
+                    ? params.deviceClass
+                    : undefined;
+                const sourceType = toSourceType(params.source.type);
+                const claim = (0, location_proof_1.createLocationClaim)({
+                    subjectId: params.subjectId,
+                    deviceId: params.deviceId,
+                    ...(deviceClass !== undefined ? { deviceClass } : {}),
+                    ...(params.operatorId !== undefined ? { operatorId: params.operatorId } : {}),
+                    observedAt: params.observedAt ?? Date.now(),
+                    location: {
+                        lat: params.location.lat,
+                        lon: params.location.lon,
+                        ...(params.location.altitudeM !== undefined ? { altitudeM: params.location.altitudeM } : {}),
+                        ...(params.location.accuracyM !== undefined ? { accuracyM: params.location.accuracyM } : {}),
+                    },
+                    source: {
+                        type: sourceType,
+                        ...(params.source.fixType !== undefined ? { fixType: params.source.fixType } : {}),
+                        ...(params.source.satellitesUsed !== undefined ? { satellitesUsed: params.source.satellitesUsed } : {}),
+                        ...(params.source.hdop !== undefined ? { hdop: params.source.hdop } : {}),
+                        ...(params.source.vdop !== undefined ? { vdop: params.source.vdop } : {}),
+                        ...(params.source.pdop !== undefined ? { pdop: params.source.pdop } : {}),
+                        ...(params.source.rawPayloadHash !== undefined ? { rawPayloadHash: params.source.rawPayloadHash } : {}),
+                        ...(params.source.nmeaPayloadHash !== undefined ? { nmeaPayloadHash: params.source.nmeaPayloadHash } : {}),
+                        ...(params.source.spoofingFlag !== undefined ? { spoofingFlag: params.source.spoofingFlag } : {}),
+                        ...(params.source.jammingFlag !== undefined ? { jammingFlag: params.source.jammingFlag } : {}),
+                        ...(params.source.metadata !== undefined ? { metadata: params.source.metadata } : {}),
+                    },
+                    ...(params.challenge !== undefined ? { challenge: params.challenge } : {}),
+                    ...(params.corroboration !== undefined ? { corroboration: params.corroboration } : {}),
+                    ...(params.metadata !== undefined ? { metadata: params.metadata } : {}),
+                });
+                const validation = (0, location_proof_1.validateLocationClaim)(claim);
+                if (!validation.valid) {
+                    return {
+                        ok: false,
+                        error: 'invalid location claim: ' + validation.errors.join('; '),
+                    };
+                }
+                return { ok: true, data: { claimId: claim.claimId, claim } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        async scoreClaim(params) {
+            try {
+                assertLocationClaim(params.claim);
+                const result = (0, location_proof_1.scoreLocationClaim)(params.claim, params.options);
+                return {
+                    ok: true,
+                    data: {
+                        score: result.score,
+                        level: result.level,
+                        positiveSignals: result.positiveSignals,
+                        negativeSignals: result.negativeSignals,
+                    },
+                };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        async createTrail(params) {
+            try {
+                const trail = (0, location_proof_1.createMovementTrail)({
+                    subjectId: params.subjectId,
+                    deviceId: params.deviceId,
+                    samples: params.samples.map((sample) => ({
+                        observedAt: sample.observedAt,
+                        location: {
+                            lat: sample.location.lat,
+                            lon: sample.location.lon,
+                            ...(sample.location.altitudeM !== undefined ? { altitudeM: sample.location.altitudeM } : {}),
+                            ...(sample.location.accuracyM !== undefined ? { accuracyM: sample.location.accuracyM } : {}),
+                        },
+                        ...(sample.headingDeg !== undefined ? { headingDeg: sample.headingDeg } : {}),
+                        ...(sample.speedMps !== undefined ? { speedMps: sample.speedMps } : {}),
+                        ...(sample.accuracyM !== undefined ? { accuracyM: sample.accuracyM } : {}),
+                        ...(sample.source !== undefined
+                            ? {
+                                source: {
+                                    ...sample.source,
+                                    type: toSourceType(sample.source.type),
+                                },
+                            }
+                            : {}),
+                    })),
+                    ...(params.metadata !== undefined ? { metadata: params.metadata } : {}),
+                    ...(params.maxSpeedMps !== undefined ? { maxSpeedMps: params.maxSpeedMps } : {}),
+                });
+                return { ok: true, data: { trailId: trail.trailId, trail } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        async createProof(params) {
+            try {
+                assertLocationClaim(params.claim);
+                const claim = params.claim;
+                const issuer = params.context?.['issuer'] ?? config.issuer;
+                const unsigned = (0, location_proof_1.createUnsignedLocationProof)({
+                    claim,
+                    ...(issuer !== undefined ? { issuer } : {}),
+                });
+                let proof;
+                let proofId;
+                if (config.seed) {
+                    if (config.leaseProvider) {
+                        proof = await (0, location_proof_1.signLocationProofWithLease)(unsigned, config.seed, config.leaseProvider, {
+                            treeId: config.leaseTreeId,
+                        });
+                    }
+                    else {
+                        proof = (0, location_proof_1.signLocationProof)(unsigned, config.seed, config.keyIndex ?? 0);
+                    }
+                    proofId = proof.proofId;
+                }
+                else {
+                    proof = unsigned;
+                    proofId = unsigned.proofId;
+                }
+                return { ok: true, data: { proofId, proof } };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+        async verifyProof(params) {
+            try {
+                const result = (0, location_proof_1.verifyLocationProof)(params.proof, { now: params.now });
+                return {
+                    ok: true,
+                    data: {
+                        valid: result.valid,
+                        ...(result.reason !== undefined ? { reason: result.reason } : {}),
+                        ...(result.expired !== undefined ? { expired: result.expired } : {}),
+                        ...(result.signerAddress !== undefined ? { signerAddress: result.signerAddress } : {}),
+                        ...(result.claimId !== undefined ? { claimId: result.claimId } : {}),
+                    },
+                };
+            }
+            catch (err) {
+                return { ok: false, error: err instanceof Error ? err.message : String(err) };
+            }
+        },
+    };
+}

package/dist/cjs/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/cjs/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/cjs/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/cjs/manifest.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createManifestPortAdapter = createManifestPortAdapter;
+const manifest_1 = require("@totemsdk/manifest");
+const core_1 = require("@totemsdk/core");
+/**
+ * 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, (0, core_1.createUnifiedChildTreeKey)(seed, 0), 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/cjs/negotiation-transport.d.ts

@@ -0,0 +1,50 @@
+/**
+ * negotiation-transport.ts — NegotiationTransport adapters over Edge ports.
+ *
+ * Two adapters:
+ *   - createStreamNegotiationTransport: raw byte stream (EdgeStreamPort).
+ *     Messages are framed as length-prefixed JSON. The sender address is
+ *     resolved by the caller (the stream is a single authenticated peer).
+ *   - createPubSubNegotiationTransport: topic-based (EdgePubSubPort).
+ *     Each negotiation uses a topic derived from the negotiationId; the
+ *     sender address is carried in the envelope.
+ *
+ * Transport metadata stays separate from economic protocol objects. The
+ * NegotiationEngine never sees sockets/topics/connection IDs.
+ */
+import type { NegotiationTransport } from '@totemsdk/edge';
+import type { EdgePubSubPort, EdgeStreamPort } from '@totemsdk/edge';
+export interface StreamNegotiationTransportConfig {
+    stream: EdgeStreamPort;
+    /** The authenticated sender address for this stream (resolved by caller). */
+    sender: string;
+    /** The local recipient address. */
+    recipient: string;
+    /** Max message size in bytes (default 64 KiB). */
+    maxBytes?: number;
+}
+/**
+ * Create a NegotiationTransport over a raw byte stream.
+ *
+ * Messages are framed as `[4-byte BE length][JSON bytes]`. The stream is
+ * assumed to be a single authenticated peer connection, so the sender address
+ * is fixed by the caller.
+ */
+export declare function createStreamNegotiationTransport(config: StreamNegotiationTransportConfig): NegotiationTransport;
+export interface PubSubNegotiationTransportConfig {
+    pubsub: EdgePubSubPort;
+    /** The local recipient address. */
+    recipient: string;
+    /** Topic prefix (default 'totem.negotiation'). */
+    topicPrefix?: string;
+    /** Max message size in bytes (default 64 KiB). */
+    maxBytes?: number;
+}
+/**
+ * Create a NegotiationTransport over a pub/sub transport.
+ *
+ * Each negotiation uses a topic derived from its negotiationId. The sender
+ * address is carried in the envelope (a `sender` field on the message), so
+ * the ingress pipeline can authenticate it.
+ */
+export declare function createPubSubNegotiationTransport(config: PubSubNegotiationTransportConfig): NegotiationTransport;

package/dist/cjs/negotiation-transport.js

@@ -0,0 +1,122 @@
+"use strict";
+/**
+ * negotiation-transport.ts — NegotiationTransport adapters over Edge ports.
+ *
+ * Two adapters:
+ *   - createStreamNegotiationTransport: raw byte stream (EdgeStreamPort).
+ *     Messages are framed as length-prefixed JSON. The sender address is
+ *     resolved by the caller (the stream is a single authenticated peer).
+ *   - createPubSubNegotiationTransport: topic-based (EdgePubSubPort).
+ *     Each negotiation uses a topic derived from the negotiationId; the
+ *     sender address is carried in the envelope.
+ *
+ * Transport metadata stays separate from economic protocol objects. The
+ * NegotiationEngine never sees sockets/topics/connection IDs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStreamNegotiationTransport = createStreamNegotiationTransport;
+exports.createPubSubNegotiationTransport = createPubSubNegotiationTransport;
+/**
+ * Create a NegotiationTransport over a raw byte stream.
+ *
+ * Messages are framed as `[4-byte BE length][JSON bytes]`. The stream is
+ * assumed to be a single authenticated peer connection, so the sender address
+ * is fixed by the caller.
+ */
+function createStreamNegotiationTransport(config) {
+    const { stream, sender, recipient } = config;
+    const maxBytes = config.maxBytes ?? 64 * 1024;
+    return {
+        async send(_recipient, message) {
+            const bytes = new TextEncoder().encode(JSON.stringify(message));
+            if (bytes.length > maxBytes) {
+                throw new Error(`negotiation message exceeds ${maxBytes} bytes`);
+            }
+            const frame = new Uint8Array(4 + bytes.length);
+            new DataView(frame.buffer).setUint32(0, bytes.length);
+            frame.set(bytes, 4);
+            // Raw byte-stream send does NOT prove durable remote processing —
+            // return no receipt so the outbox drainer does not mark delivered.
+            stream.send(frame);
+            return undefined;
+        },
+        subscribe(handler) {
+            let buffer = new Uint8Array(0);
+            const off = stream.onData((chunk) => {
+                buffer = concatBytes(buffer, chunk);
+                while (buffer.length >= 4) {
+                    const view = new DataView(buffer.buffer, buffer.byteOffset, 4);
+                    const len = view.getUint32(0);
+                    if (buffer.length < 4 + len)
+                        break;
+                    const payload = buffer.slice(4, 4 + len);
+                    buffer = buffer.slice(4 + len);
+                    try {
+                        const message = JSON.parse(new TextDecoder().decode(payload));
+                        void handler(message, { sender, recipient });
+                    }
+                    catch {
+                        // Malformed frame — drop.
+                    }
+                }
+            });
+            return off;
+        },
+    };
+}
+function topicFor(topicPrefix, negotiationId) {
+    return `${topicPrefix}.${negotiationId}`;
+}
+/**
+ * Create a NegotiationTransport over a pub/sub transport.
+ *
+ * Each negotiation uses a topic derived from its negotiationId. The sender
+ * address is carried in the envelope (a `sender` field on the message), so
+ * the ingress pipeline can authenticate it.
+ */
+function createPubSubNegotiationTransport(config) {
+    const { pubsub, recipient } = config;
+    const topicPrefix = config.topicPrefix ?? 'totem.negotiation';
+    const maxBytes = config.maxBytes ?? 64 * 1024;
+    return {
+        async send(recipientAddress, message) {
+            const negotiationId = message.negotiationId;
+            if (!negotiationId)
+                throw new Error('negotiation message missing negotiationId');
+            const topic = topicFor(topicPrefix, negotiationId);
+            const envelope = { ...message, sender: recipientAddress, recipient };
+            const bytes = new TextEncoder().encode(JSON.stringify(envelope));
+            if (bytes.length > maxBytes) {
+                throw new Error(`negotiation message exceeds ${maxBytes} bytes`);
+            }
+            // Pub/sub publish() proves local broker transmission, not durable remote
+            // processing — return no receipt so the outbox drainer does not mark
+            // delivered on local send alone.
+            await pubsub.publish(topic, bytes);
+            return undefined;
+        },
+        subscribe(handler) {
+            return pubsub.onMessage(({ topic, payload }) => {
+                if (!topic.startsWith(topicPrefix))
+                    return;
+                try {
+                    const envelope = JSON.parse(new TextDecoder().decode(payload));
+                    const sender = envelope.sender ?? 'unknown';
+                    void handler(envelope, { sender, recipient });
+                }
+                catch {
+                    // Malformed message — drop.
+                }
+            });
+        },
+    };
+}
+// ─────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+function concatBytes(a, b) {
+    const out = new Uint8Array(a.length + b.length);
+    out.set(a, 0);
+    out.set(b, a.length);
+    return out;
+}

package/dist/cjs/omnia.d.ts

@@ -0,0 +1,7 @@
+import type { EdgeOmniaPort } from '@totemsdk/edge';
+export interface OmniaHostPortConfig {
+    endpoint: string;
+    fetch?: typeof globalThis.fetch;
+    headers?: Record<string, string>;
+}
+export declare function createOmniaHostPort(config: OmniaHostPortConfig): EdgeOmniaPort;

package/dist/cjs/omnia.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createOmniaHostPort = createOmniaHostPort;
+function methodName(operation) {
+    return `totem_omnia${operation[0].toUpperCase()}${operation.slice(1)}`;
+}
+function createOmniaHostPort(config) {
+    const request = config.fetch ?? globalThis.fetch;
+    const endpoint = config.endpoint.replace(/\/$/, '');
+    async function call(operation, params = {}) {
+        try {
+            const response = await request(`${endpoint}/rpc`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json', ...config.headers },
+                body: JSON.stringify({ jsonrpc: '2.0', id: Date.now(), method: methodName(operation), params }),
+            });
+            const body = await response.json();
+            if (!response.ok || body.error) {
+                return {
+                    ok: false,
+                    error: body.error?.message ?? `Omnia host returned HTTP ${response.status}`,
+                    errorCode: body.error?.code ? String(body.error.code) : 'OMNIA_HOST_ERROR',
+                };
+            }
+            return { ok: true, data: body.result };
+        }
+        catch (error) {
+            return { ok: false, error: error instanceof Error ? error.message : String(error), errorCode: 'OMNIA_HOST_UNAVAILABLE' };
+        }
+    }
+    return {
+        getChannels: (params) => call('getChannels', params),
+        openChannel: (params) => call('openChannel', params),
+        pay: (params) => call('pay', params),
+        settle: (params) => call('settle', params),
+        closeChannel: (params) => call('closeChannel', params),
+        getRoute: (params) => call('getRoute', params),
+        payMultiHop: (params) => call('payMultiHop', params),
+        getSwapRate: (params) => call('getSwapRate', params),
+        createFactory: (params) => call('createFactory', params),
+        openVirtualChannel: (params) => call('openVirtualChannel', params),
+        closeFactory: (params) => call('closeFactory', params),
+        spliceIn: (params) => call('spliceIn', params),
+        spliceOut: (params) => call('spliceOut', params),
+    };
+}

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/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 minima-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;