@totemsdk/edge-adapters 0.1.0 → 0.1.1

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 Totem SDK
+Copyright (c) 2024 Totem SDK Contributors
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/index.d.ts

@@ -3,6 +3,8 @@ export type { LiquidityPortConfig } from './liquidity.js';
 export { createProofPortAdapter } from './proof.js';
 export type { ProofPortConfig } from './proof.js';
 export { createLookupPortAdapter } from './lookup.js';
+export { createLocationPortAdapter } from './location.js';
+export type { LocationPortConfig } from './location.js';
 export { createPolicyPortAdapter } from './policy.js';
 export { createIdentityPortAdapter } from './identity.js';
 export type { IdentityPortConfig } from './identity.js';
@@ -11,3 +13,7 @@ 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';
+export { createOmniaHostPort } from './omnia.js';
+export type { OmniaHostPortConfig } from './omnia.js';
+export { createStreamPortAdapter } from './stream.js';
+export { createPubSubPortAdapter } from './pubsub.js';

package/dist/index.js

@@ -1,12 +1,14 @@
 "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;
+exports.createPubSubPortAdapter = exports.createStreamPortAdapter = exports.createOmniaHostPort = exports.createOmniaL2PaymentPort = exports.createMinimaL1PaymentPort = exports.createManifestPortAdapter = exports.createIdentityPortAdapter = exports.createPolicyPortAdapter = exports.createLocationPortAdapter = 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 location_js_1 = require("./location.js");
+Object.defineProperty(exports, "createLocationPortAdapter", { enumerable: true, get: function () { return location_js_1.createLocationPortAdapter; } });
 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");
@@ -17,3 +19,9 @@ 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; } });
+var omnia_js_1 = require("./omnia.js");
+Object.defineProperty(exports, "createOmniaHostPort", { enumerable: true, get: function () { return omnia_js_1.createOmniaHostPort; } });
+var stream_js_1 = require("./stream.js");
+Object.defineProperty(exports, "createStreamPortAdapter", { enumerable: true, get: function () { return stream_js_1.createStreamPortAdapter; } });
+var pubsub_js_1 = require("./pubsub.js");
+Object.defineProperty(exports, "createPubSubPortAdapter", { enumerable: true, get: function () { return pubsub_js_1.createPubSubPortAdapter; } });

package/dist/location.d.ts

@@ -0,0 +1,48 @@
+import type { EdgeLocationPort } from '@totemsdk/edge';
+export interface LocationPortConfig {
+    /**
+     * Default issuer stamped onto created location proofs. When unset, the
+     * claim's subjectId is used.
+     */
+    issuer?: string;
+    /**
+     * 32-byte WOTS seed. Required for signing; without it only unsigned
+     * location proofs are returned, which MUST NOT be presented as completed
+     * proofs.
+     */
+    seed?: Uint8Array;
+    /**
+     * TreeKey index for direct signing (used when no leaseProvider is given).
+     * Ignored when leaseProvider is set.
+     */
+    keyIndex?: number;
+    /**
+     * WOTS lease provider for coordinated key-index reservation.
+     * When set, keyIndex is ignored and the index is reserved via the provider.
+     */
+    leaseProvider?: {
+        reserveKeyUse(params: {
+            treeId: string;
+            ttlMs?: number;
+            payloadHash?: string;
+        }): Promise<{
+            reservationId: string;
+            indices: {
+                addressIndex: number;
+                l1: number;
+                l2: number;
+            };
+        }>;
+        commitKeyUse(reservationId: string, txId: string): Promise<void>;
+        burnReservation(reservationId: string, reason: string): Promise<void>;
+    };
+    leaseTreeId?: string;
+}
+/**
+ * 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.
+ */
+export declare function createLocationPortAdapter(config?: LocationPortConfig): EdgeLocationPort;

package/dist/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/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/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/policy.d.ts

@@ -1,11 +1,13 @@
-import type { AgentPolicy } from '@totemsdk/agent-policy';
+import type { AgentPolicy, PolicyMiddleware } from '@totemsdk/agent-policy';
 import type { EdgePolicyPort } from '@totemsdk/edge';
+type PolicyLike = AgentPolicy | PolicyMiddleware;
 /**
- * Wraps an AgentPolicy as an EdgePolicyPort.
+ * Wraps an AgentPolicy or PolicyMiddleware 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).
+ * When the EdgePolicyPort receives a full `proposal` object, it delegates
+ * directly to the policy without lossy reconstruction. When only flat
+ * `action`/`subject` params are provided, it builds a minimal AgentProposal
+ * (legacy path).
  */
-export declare function createPolicyPortAdapter(policy: AgentPolicy): EdgePolicyPort;
+export declare function createPolicyPortAdapter(policy: PolicyLike): EdgePolicyPort;
+export {};

package/dist/policy.js

@@ -1,18 +1,58 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPolicyPortAdapter = createPolicyPortAdapter;
+function isMiddleware(p) {
+    return 'evaluate' in p && typeof p.evaluate === 'function';
+}
 /**
- * Wraps an AgentPolicy as an EdgePolicyPort.
+ * Wraps an AgentPolicy or PolicyMiddleware 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).
+ * When the EdgePolicyPort receives a full `proposal` object, it delegates
+ * directly to the policy without lossy reconstruction. When only flat
+ * `action`/`subject` params are provided, it builds a minimal AgentProposal
+ * (legacy path).
  */
 function createPolicyPortAdapter(policy) {
     return {
         async check(params) {
             try {
+                // Prefer full proposal when available
+                if (params.proposal) {
+                    const proposal = {
+                        id: params.proposal.id,
+                        agentId: params.proposal.agentId,
+                        intent: {
+                            type: params.proposal.intent.type,
+                            amount: params.proposal.intent.amount,
+                            tokenId: params.proposal.intent.tokenId,
+                            recipient: params.proposal.intent.recipient,
+                            reason: params.proposal.intent.reason,
+                            risk: params.proposal.intent.risk,
+                        },
+                        explanation: params.proposal.explanation,
+                        confidence: params.proposal.confidence,
+                        createdAt: params.proposal.createdAt,
+                    };
+                    if (isMiddleware(policy)) {
+                        const result = await policy.evaluate(proposal);
+                        return {
+                            ok: true,
+                            data: {
+                                allowed: result.outcome === 'approved',
+                                reason: result.reason,
+                            },
+                        };
+                    }
+                    const allowed = await policy.canAutoApprove(proposal);
+                    return {
+                        ok: true,
+                        data: {
+                            allowed,
+                            reason: allowed ? undefined : 'Action requires user approval per configured policy',
+                        },
+                    };
+                }
+                // Legacy path: build minimal proposal from flat params
                 const intentType = params.action.startsWith('pay') ? 'payment' : 'receipt';
                 const proposal = {
                     id: `edge-policy-${params.action}-${params.subject}-${Date.now()}`,
@@ -28,6 +68,16 @@ function createPolicyPortAdapter(policy) {
                     confidence: 1,
                     createdAt: Date.now(),
                 };
+                if (isMiddleware(policy)) {
+                    const result = await policy.evaluate(proposal);
+                    return {
+                        ok: true,
+                        data: {
+                            allowed: result.outcome === 'approved',
+                            reason: result.reason,
+                        },
+                    };
+                }
                 const allowed = await policy.canAutoApprove(proposal);
                 return {
                     ok: true,

package/dist/proof.d.ts

@@ -6,13 +6,43 @@ export interface ProofPortConfig {
     issuer: string;
     /** Default proof kind when callers don't specify one via context. */
     defaultKind?: ProofKind;
+    /**
+     * 32-byte WOTS seed. Required for signing; without it only unsigned
+     * proofs are returned, which MUST NOT be presented as completed proofs.
+     */
+    seed?: Uint8Array;
+    /**
+     * TreeKey index for direct signing (used when no leaseProvider is given).
+     * Ignored when leaseProvider is set.
+     */
+    keyIndex?: number;
+    /**
+     * WOTS lease provider for coordinated key-index reservation.
+     * When set, keyIndex is ignored and the index is reserved via the provider.
+     */
+    leaseProvider?: {
+        reserveKeyUse(params: {
+            treeId: string;
+            ttlMs?: number;
+            payloadHash?: string;
+        }): Promise<{
+            reservationId: string;
+            indices: {
+                addressIndex: number;
+                l1: number;
+                l2: number;
+            };
+        }>;
+        commitKeyUse(reservationId: string, txId: string): Promise<void>;
+        burnReservation(reservationId: string, reason: string): Promise<void>;
+    };
+    leaseTreeId?: string;
 }
 /**
  * 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.
+ * When config.seed is provided the returned proof is a SignedProof;
+ * without seed only an UnsignedProof is returned and MUST NOT be
+ * presented as a completed proof.
  */
 export declare function createProofPortAdapter(config: ProofPortConfig): EdgeProofPort;

package/dist/proof.js

@@ -2,13 +2,18 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createProofPortAdapter = createProofPortAdapter;
 const proof_1 = require("@totemsdk/proof");
+function rawPayloadEvidence(rawPayload) {
+    if (!rawPayload || rawPayload.length === 0)
+        return undefined;
+    const hash = (0, proof_1.toHex)((0, proof_1.sha3_256)(rawPayload));
+    return { id: 'payload:' + hash, kind: 'raw-payload', hash };
+}
 /**
  * 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.
+ * When config.seed is provided the returned proof is a SignedProof;
+ * without seed only an UnsignedProof is returned and MUST NOT be
+ * presented as a completed proof.
  */
 function createProofPortAdapter(config) {
     const { provider, issuer, defaultKind = 'attestation' } = config;
@@ -16,18 +21,42 @@ function createProofPortAdapter(config) {
         async createProof(params) {
             try {
                 const kind = params.context?.['kind'] ?? defaultKind;
+                const rawPayload = params.context?.['rawPayload'];
+                const evidence = rawPayloadEvidence(rawPayload);
                 const unsigned = (0, proof_1.createProof)({
                     kind,
                     subject: { id: params.subject, kind: 'edge-subject' },
                     issuer,
-                    payload: { claims: params.claims, ...(params.context ?? {}) },
+                    payload: {
+                        claims: params.claims,
+                        ...(rawPayload !== undefined ? { rawPayloadHash: (0, proof_1.toHex)((0, proof_1.sha3_256)(rawPayload)) } : {}),
+                        ...(params.context ?? {}),
+                    },
+                    ...(evidence !== undefined ? { evidence: [evidence] } : {}),
                 });
+                // Sign if seed is available
+                let proof;
+                let proofId;
+                if (config.seed) {
+                    if (config.leaseProvider) {
+                        proof = await (0, proof_1.signWithLease)(unsigned, config.seed, config.leaseProvider, {
+                            treeId: config.leaseTreeId,
+                        });
+                    }
+                    else {
+                        proof = (0, proof_1.signProof)(unsigned, config.seed, config.keyIndex ?? 0);
+                    }
+                    proofId = proof.proofId;
+                }
+                else {
+                    proof = unsigned;
+                    proofId = unsigned.proofId;
+                }
                 // 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 });
+                    await provider.stampHash({ hash: proofId });
                 }
-                return { ok: true, data: { proofId: unsigned.proofId, proof: unsigned } };
+                return { ok: true, data: { proofId, proof } };
             }
             catch (err) {
                 return { ok: false, error: err instanceof Error ? err.message : String(err) };

package/dist/pubsub.d.ts

@@ -0,0 +1,11 @@
+/**
+ * EdgePubSubPort adapter — wraps @totemsdk/pubsub-transport's IPubSubTransport
+ * as a first-class EdgePubSubPort for EdgeRuntimePorts.pubsub.
+ *
+ * This is the lightweight counterpart to @totemsdk/edge-mqtt — it provides
+ * the raw pub/sub port without the rule engine, sensor bridge, proof
+ * publisher, command handler, or MachinePay credit enforcement.
+ */
+import type { EdgePubSubPort } from '@totemsdk/edge';
+import type { IPubSubTransport } from '@totemsdk/pubsub-transport';
+export declare function createPubSubPortAdapter(transport: IPubSubTransport): EdgePubSubPort;

package/dist/pubsub.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * EdgePubSubPort adapter — wraps @totemsdk/pubsub-transport's IPubSubTransport
+ * as a first-class EdgePubSubPort for EdgeRuntimePorts.pubsub.
+ *
+ * This is the lightweight counterpart to @totemsdk/edge-mqtt — it provides
+ * the raw pub/sub port without the rule engine, sensor bridge, proof
+ * publisher, command handler, or MachinePay credit enforcement.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPubSubPortAdapter = createPubSubPortAdapter;
+function createPubSubPortAdapter(transport) {
+    return {
+        async connect() {
+            await transport.connect();
+        },
+        async disconnect() {
+            await transport.disconnect();
+        },
+        async subscribe(topic) {
+            return transport.subscribe(topic);
+        },
+        async publish(topic, payload) {
+            await transport.publish(topic, payload);
+        },
+        onMessage(handler) {
+            return transport.onMessage(handler);
+        },
+    };
+}

package/dist/stream.d.ts

@@ -0,0 +1,7 @@
+/**
+ * EdgeStreamPort adapter — wraps @totemsdk/stream-transport's IStreamTransport
+ * as a first-class EdgeStreamPort for EdgeRuntimePorts.stream.
+ */
+import type { EdgeStreamPort } from '@totemsdk/edge';
+import type { IStreamTransport } from '@totemsdk/stream-transport';
+export declare function createStreamPortAdapter(transport: IStreamTransport): EdgeStreamPort;

package/dist/stream.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * EdgeStreamPort adapter — wraps @totemsdk/stream-transport's IStreamTransport
+ * as a first-class EdgeStreamPort for EdgeRuntimePorts.stream.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStreamPortAdapter = createStreamPortAdapter;
+function createStreamPortAdapter(transport) {
+    return {
+        async send(data) {
+            await transport.send(data);
+        },
+        onData(handler) {
+            return transport.onData(handler);
+        },
+        onClose(handler) {
+            return transport.onClose(handler);
+        },
+        onError(handler) {
+            return transport.onError(handler);
+        },
+        close() {
+            void transport.close();
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@totemsdk/edge-adapters",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Reference adapters bridging Totem SDK packages to @totemsdk/edge port interfaces",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,26 +11,23 @@
       "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"
+    "@totemsdk/chain-provider": "^0.1.6",
+    "@totemsdk/lookup-client": "^0.1.6",
+    "@totemsdk/agent-policy": "^0.2.1",
+    "@totemsdk/identity": "^0.1.4",
+    "@totemsdk/location-proof": "^0.1.0",
+    "@totemsdk/manifest": "^0.1.3",
+    "@totemsdk/omnia-router": "^0.1.5",
+    "@totemsdk/proof": "^0.1.2",
+    "@totemsdk/pubsub-transport": "^0.1.0",
+    "@totemsdk/root-identity": "^1.0.8",
+    "@totemsdk/stream-transport": "^0.1.1"
   },
   "peerDependenciesMeta": {
     "@totemsdk/agent-policy": {
@@ -40,39 +37,51 @@
       "optional": true
     },
     "@totemsdk/identity": {
-      "optional": true
+      "optional": false
     },
     "@totemsdk/manifest": {
-      "optional": true
+      "optional": false
     },
     "@totemsdk/omnia-router": {
-      "optional": true
+      "optional": false
     },
     "@totemsdk/proof": {
-      "optional": true
+      "optional": false
     },
     "@totemsdk/lookup-client": {
       "optional": true
     },
+    "@totemsdk/location-proof": {
+      "optional": false
+    },
+    "@totemsdk/pubsub-transport": {
+      "optional": true
+    },
     "@totemsdk/root-identity": {
       "optional": true
+    },
+    "@totemsdk/stream-transport": {
+      "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/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",
+    "@totemsdk/agent-policy": "^0.2.1",
+    "@totemsdk/chain-provider": "^0.1.6",
+    "@totemsdk/edge": "^0.1.4",
+    "@totemsdk/identity": "^0.1.4",
+    "@totemsdk/lookup-client": "^0.1.6",
+    "@totemsdk/location-proof": "^0.1.0",
+    "@totemsdk/manifest": "^0.1.3",
+    "@totemsdk/omnia-router": "^0.1.5",
+    "@totemsdk/proof": "^0.1.2",
+    "@totemsdk/root-identity": "^1.0.8",
+    "@totemsdk/stream-transport": "^0.1.1",
+    "@totemsdk/pubsub-transport": "^0.1.0"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -82,17 +91,30 @@
   },
   "license": "MIT",
   "author": "Totem SDK",
-  "homepage": "https://totemsdk.com",
+  "homepage": "https://totem.ing",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/MrGheek/axia-totem.git",
-    "directory": "packages/totem-sdk/packages/edge-adapters"
+    "url": "git+https://github.com/totem-sdk/totem-sdk.git",
+    "directory": "packages/edge-adapters"
   },
   "keywords": [
     "totem",
     "totemsdk",
+    "minima",
+    "blockchain",
+    "quantum-resistant",
+    "wots",
+    "utxo",
     "edge",
     "adapters",
     "ports"
-  ]
-}
+  ],
+  "bugs": {
+    "url": "https://github.com/totem-sdk/totem-sdk/issues"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "test": "jest"
+  }
+}