@arc402/sdk 0.2.0

package/dist/negotiation.d.ts

@@ -0,0 +1,25 @@
+import { ethers } from "ethers";
+import type { NegotiationMessage, NegotiationProposal, NegotiationCounter, NegotiationAccept, NegotiationReject } from "./types";
+export declare function computeMessageDigest(message: NegotiationMessage | (Omit<NegotiationMessage, "sig"> & {
+    sig?: string;
+})): string;
+export declare function signNegotiationMessage<T extends NegotiationMessage>(message: Omit<T, "sig">, signer: ethers.Wallet | ethers.Signer): Promise<T>;
+export declare function createSignedProposal(input: Omit<NegotiationProposal, "type" | "nonce" | "sig" | "timestamp" | "expiresAt"> & {
+    nonce?: string;
+    expiresAt?: number;
+}, signer: ethers.Wallet | ethers.Signer): Promise<NegotiationProposal>;
+export declare function createSignedCounter(input: Omit<NegotiationCounter, "type" | "sig" | "timestamp">, signer: ethers.Wallet | ethers.Signer): Promise<NegotiationCounter>;
+export declare function createSignedAccept(input: Omit<NegotiationAccept, "type" | "sig" | "timestamp">, signer: ethers.Wallet | ethers.Signer): Promise<NegotiationAccept>;
+export declare function createSignedReject(input: Omit<NegotiationReject, "type" | "sig" | "timestamp">, signer: ethers.Wallet | ethers.Signer): Promise<NegotiationReject>;
+/** @deprecated Use createSignedProposal instead */
+export declare function createNegotiationProposal(input: Omit<NegotiationProposal, "type" | "nonce" | "sig" | "timestamp" | "expiresAt"> & {
+    nonce?: string;
+}): NegotiationProposal;
+/** @deprecated Use createSignedCounter instead */
+export declare function createNegotiationCounter(input: Omit<NegotiationCounter, "type" | "sig" | "timestamp">): NegotiationCounter;
+/** @deprecated Use createSignedAccept instead */
+export declare function createNegotiationAccept(input: Omit<NegotiationAccept, "type" | "sig" | "timestamp">): NegotiationAccept;
+/** @deprecated Use createSignedReject instead */
+export declare function createNegotiationReject(input: Omit<NegotiationReject, "type" | "sig" | "timestamp">): NegotiationReject;
+export declare function parseNegotiationMessage(json: string): NegotiationMessage;
+//# sourceMappingURL=negotiation.d.ts.map

package/dist/negotiation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negotiation.d.ts","sourceRoot":"","sources":["../src/negotiation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EACV,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,SAAS,CAAC;AAOjB,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,kBAAkB,GAAG,CAAC,IAAI,CAAC,kBAAkB,EAAE,KAAK,CAAC,GAAG;IAAE,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,GAAG,MAAM,CAU/H;AAID,wBAAsB,sBAAsB,CAAC,CAAC,SAAS,kBAAkB,EACvE,OAAO,EAAE,IAAI,CAAC,CAAC,EAAE,KAAK,CAAC,EACvB,MAAM,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,GACpC,OAAO,CAAC,CAAC,CAAC,CAIZ;AAID,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,IAAI,CAAC,mBAAmB,EAAE,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,WAAW,GAAG,WAAW,CAAC,GAAG;IACvF,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,EACD,MAAM,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,GACpC,OAAO,CAAC,mBAAmB,CAAC,CAU9B;AAED,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,IAAI,CAAC,kBAAkB,EAAE,MAAM,GAAG,KAAK,GAAG,WAAW,CAAC,EAC7D,MAAM,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,GACpC,OAAO,CAAC,kBAAkB,CAAC,CAO7B;AAED,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,KAAK,GAAG,WAAW,CAAC,EAC5D,MAAM,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,GACpC,OAAO,CAAC,iBAAiB,CAAC,CAO5B;AAED,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,KAAK,GAAG,WAAW,CAAC,EAC5D,MAAM,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,GACpC,OAAO,CAAC,iBAAiB,CAAC,CAO5B;AAID,mDAAmD;AACnD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,IAAI,CAAC,mBAAmB,EAAE,MAAM,GAAG,OAAO,GAAG,KAAK,GAAG,WAAW,GAAG,WAAW,CAAC,GAAG;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GAC1G,mBAAmB,CAWrB;AAED,kDAAkD;AAClD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,IAAI,CAAC,kBAAkB,EAAE,MAAM,GAAG,KAAK,GAAG,WAAW,CAAC,GAAG,kBAAkB,CAG1H;AAED,iDAAiD;AACjD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,KAAK,GAAG,WAAW,CAAC,GAAG,iBAAiB,CAGvH;AAED,iDAAiD;AACjD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,KAAK,GAAG,WAAW,CAAC,GAAG,iBAAiB,CAGvH;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAKxE"}

package/dist/negotiation.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeMessageDigest = computeMessageDigest;
+exports.signNegotiationMessage = signNegotiationMessage;
+exports.createSignedProposal = createSignedProposal;
+exports.createSignedCounter = createSignedCounter;
+exports.createSignedAccept = createSignedAccept;
+exports.createSignedReject = createSignedReject;
+exports.createNegotiationProposal = createNegotiationProposal;
+exports.createNegotiationCounter = createNegotiationCounter;
+exports.createNegotiationAccept = createNegotiationAccept;
+exports.createNegotiationReject = createNegotiationReject;
+exports.parseNegotiationMessage = parseNegotiationMessage;
+const ethers_1 = require("ethers");
+const MAX_MESSAGE_BYTES = 64 * 1024; // 64KB
+// --- Digest computation ---
+// digest = keccak256(abi.encodePacked(type, from, to, nonce, timestamp))
+// nonce is message.nonce (PROPOSE) or message.refNonce (COUNTER/ACCEPT/REJECT) or bytes32(0) if absent
+function computeMessageDigest(message) {
+    const m = message;
+    const rawNonce = m.nonce || m.refNonce || ethers_1.ethers.ZeroHash;
+    // solidityPackedKeccak256 requires exactly 32 bytes for bytes32 — pad to 32 bytes
+    const nonce = ethers_1.ethers.zeroPadValue(rawNonce, 32);
+    return ethers_1.ethers.solidityPackedKeccak256(["string", "address", "address", "bytes32", "uint256"], [message.type, message.from, message.to, nonce, message.timestamp]);
+}
+// --- Signing ---
+async function signNegotiationMessage(message, signer) {
+    const digest = computeMessageDigest(message);
+    const sig = await signer.signMessage(ethers_1.ethers.getBytes(digest));
+    return { ...message, sig };
+}
+// --- Signed factory functions ---
+async function createSignedProposal(input, signer) {
+    const now = Math.floor(Date.now() / 1000);
+    const unsigned = {
+        type: "PROPOSE",
+        nonce: input.nonce ?? ethers_1.ethers.hexlify(ethers_1.ethers.randomBytes(16)),
+        timestamp: now,
+        expiresAt: input.expiresAt ?? now + 3600,
+        ...input,
+    };
+    return signNegotiationMessage(unsigned, signer);
+}
+async function createSignedCounter(input, signer) {
+    const unsigned = {
+        type: "COUNTER",
+        timestamp: Math.floor(Date.now() / 1000),
+        ...input,
+    };
+    return signNegotiationMessage(unsigned, signer);
+}
+async function createSignedAccept(input, signer) {
+    const unsigned = {
+        type: "ACCEPT",
+        timestamp: Math.floor(Date.now() / 1000),
+        ...input,
+    };
+    return signNegotiationMessage(unsigned, signer);
+}
+async function createSignedReject(input, signer) {
+    const unsigned = {
+        type: "REJECT",
+        timestamp: Math.floor(Date.now() / 1000),
+        ...input,
+    };
+    return signNegotiationMessage(unsigned, signer);
+}
+// --- Deprecated unsigned factories (backwards compat) ---
+/** @deprecated Use createSignedProposal instead */
+function createNegotiationProposal(input) {
+    console.warn("createNegotiationProposal: unsigned messages are deprecated. Use createSignedProposal instead.");
+    const now = Math.floor(Date.now() / 1000);
+    return {
+        type: "PROPOSE",
+        nonce: input.nonce ?? ethers_1.ethers.hexlify(ethers_1.ethers.randomBytes(16)),
+        timestamp: now,
+        expiresAt: now + 3600,
+        sig: "0x",
+        ...input,
+    };
+}
+/** @deprecated Use createSignedCounter instead */
+function createNegotiationCounter(input) {
+    console.warn("createNegotiationCounter: unsigned messages are deprecated. Use createSignedCounter instead.");
+    return { type: "COUNTER", timestamp: Math.floor(Date.now() / 1000), sig: "0x", ...input };
+}
+/** @deprecated Use createSignedAccept instead */
+function createNegotiationAccept(input) {
+    console.warn("createNegotiationAccept: unsigned messages are deprecated. Use createSignedAccept instead.");
+    return { type: "ACCEPT", timestamp: Math.floor(Date.now() / 1000), sig: "0x", ...input };
+}
+/** @deprecated Use createSignedReject instead */
+function createNegotiationReject(input) {
+    console.warn("createNegotiationReject: unsigned messages are deprecated. Use createSignedReject instead.");
+    return { type: "REJECT", timestamp: Math.floor(Date.now() / 1000), sig: "0x", ...input };
+}
+function parseNegotiationMessage(json) {
+    if (Buffer.byteLength(json, "utf8") > MAX_MESSAGE_BYTES) {
+        throw new Error("NegotiationMessage exceeds 64KB size limit");
+    }
+    return JSON.parse(json);
+}

package/dist/policy.d.ts

@@ -0,0 +1,33 @@
+import { ContractRunner, ethers } from "ethers";
+import { Policy } from "./types";
+export declare class PolicyClient {
+    private contract;
+    constructor(address: string, runner: ContractRunner);
+    set(walletAddress: string, categories: Record<string, bigint>): Promise<void>;
+    get(walletAddress: string): Promise<Policy>;
+    validate(walletAddress: string, category: string, amount: bigint): Promise<{
+        valid: any;
+        reason: any;
+    }>;
+    /** Freeze spend for a wallet. Callable by the wallet, its owner, or an authorized freeze agent. */
+    freezeSpend(wallet: string): Promise<ethers.TransactionReceipt>;
+    /** Unfreeze spend for a wallet. Only callable by the wallet or its registered owner. */
+    unfreeze(wallet: string): Promise<ethers.TransactionReceipt>;
+    /** Authorize a watchtower agent to freeze this wallet's spending. Caller must be the wallet. */
+    authorizeFreezeAgent(agent: string): Promise<ethers.TransactionReceipt>;
+    /** Revoke a watchtower agent's freeze authorization. */
+    revokeFreezeAgent(agent: string): Promise<ethers.TransactionReceipt>;
+    /**
+     * Queue a daily-limit reduction for wallet+category. Only reductions (newCap < current) are allowed.
+     * A 24-hour timelock applies before the new cap can be applied.
+     */
+    queueCapReduction(wallet: string, category: string, newCap: bigint): Promise<ethers.TransactionReceipt>;
+    /** Apply a queued cap reduction after the 24-hour timelock has elapsed. */
+    applyCapReduction(wallet: string, category: string): Promise<ethers.TransactionReceipt>;
+}
+export declare class PolicyObject extends PolicyClient {
+}
+export declare class PolicyValidator {
+    static validate(policy: Policy, category: string, amount: bigint): boolean;
+}
+//# sourceMappingURL=policy.d.ts.map

package/dist/policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.d.ts","sourceRoot":"","sources":["../src/policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhD,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEjC,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAkB;gBACtB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc;IAC7C,GAAG,CAAC,aAAa,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAS7D,GAAG,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAS3C,QAAQ,CAAC,aAAa,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;;IAKtE,mGAAmG;IAC7F,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAC;IAKrE,wFAAwF;IAClF,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAC;IAKlE,gGAAgG;IAC1F,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAC;IAK7E,wDAAwD;IAClD,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAC;IAK1E;;;OAGG;IACG,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAC;IAK7G,2EAA2E;IACrE,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAAC;CAI9F;AACD,qBAAa,YAAa,SAAQ,YAAY;CAAG;AACjD,qBAAa,eAAe;IAAG,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;CAAiG"}

package/dist/policy.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyValidator = exports.PolicyObject = exports.PolicyClient = void 0;
+const ethers_1 = require("ethers");
+const contracts_1 = require("./contracts");
+class PolicyClient {
+    constructor(address, runner) { this.contract = new ethers_1.ethers.Contract(address, contracts_1.POLICY_ENGINE_ABI, runner); }
+    async set(walletAddress, categories) {
+        const policyData = JSON.stringify(Object.fromEntries(Object.entries(categories).map(([k, v]) => [k, v.toString()])));
+        const tx = await this.contract.setPolicy(ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(policyData)), ethers_1.ethers.toUtf8Bytes(policyData));
+        await tx.wait();
+        for (const [category, limit] of Object.entries(categories)) {
+            const updateTx = await this.contract.setCategoryLimitFor(walletAddress, category, limit);
+            await updateTx.wait();
+        }
+    }
+    async get(walletAddress) {
+        const [policyHash, policyDataBytes] = await this.contract.getPolicy(walletAddress);
+        const categories = {};
+        if (policyDataBytes && policyDataBytes !== "0x") {
+            const parsed = JSON.parse(ethers_1.ethers.toUtf8String(policyDataBytes));
+            for (const [key, value] of Object.entries(parsed))
+                categories[key] = { limitPerTx: BigInt(value) };
+        }
+        return { walletAddress, policyHash, categories };
+    }
+    async validate(walletAddress, category, amount) {
+        const [valid, reason] = await this.contract.validateSpend(walletAddress, category, amount, ethers_1.ethers.ZeroHash);
+        return { valid, reason: valid ? undefined : reason };
+    }
+    /** Freeze spend for a wallet. Callable by the wallet, its owner, or an authorized freeze agent. */
+    async freezeSpend(wallet) {
+        const tx = await this.contract.freezeSpend(wallet);
+        return (await tx.wait());
+    }
+    /** Unfreeze spend for a wallet. Only callable by the wallet or its registered owner. */
+    async unfreeze(wallet) {
+        const tx = await this.contract.unfreeze(wallet);
+        return (await tx.wait());
+    }
+    /** Authorize a watchtower agent to freeze this wallet's spending. Caller must be the wallet. */
+    async authorizeFreezeAgent(agent) {
+        const tx = await this.contract.authorizeFreezeAgent(agent);
+        return (await tx.wait());
+    }
+    /** Revoke a watchtower agent's freeze authorization. */
+    async revokeFreezeAgent(agent) {
+        const tx = await this.contract.revokeFreezeAgent(agent);
+        return (await tx.wait());
+    }
+    /**
+     * Queue a daily-limit reduction for wallet+category. Only reductions (newCap < current) are allowed.
+     * A 24-hour timelock applies before the new cap can be applied.
+     */
+    async queueCapReduction(wallet, category, newCap) {
+        const tx = await this.contract.queueCapReduction(wallet, category, newCap);
+        return (await tx.wait());
+    }
+    /** Apply a queued cap reduction after the 24-hour timelock has elapsed. */
+    async applyCapReduction(wallet, category) {
+        const tx = await this.contract.applyCapReduction(wallet, category);
+        return (await tx.wait());
+    }
+}
+exports.PolicyClient = PolicyClient;
+class PolicyObject extends PolicyClient {
+}
+exports.PolicyObject = PolicyObject;
+class PolicyValidator {
+    static validate(policy, category, amount) { return !!policy.categories[category] && amount <= policy.categories[category].limitPerTx; }
+}
+exports.PolicyValidator = PolicyValidator;

package/dist/reputation.d.ts

@@ -0,0 +1,13 @@
+import { ContractRunner } from "ethers";
+import { ReputationSignal, ReputationSignalType, ReputationSummary } from "./types";
+export declare class ReputationOracleClient {
+    private contract;
+    constructor(address: string, runner: ContractRunner);
+    publishSignal(subject: string, signalType: ReputationSignalType, capabilityHash?: string, reason?: string): Promise<any>;
+    getReputation(subject: string): Promise<ReputationSummary>;
+    getCapabilityReputation(subject: string, capabilityHash: string): Promise<bigint>;
+    getSignalCount(subject: string): Promise<bigint>;
+    getSignal(subject: string, index: bigint): Promise<ReputationSignal>;
+    listSignals(subject: string): Promise<ReputationSignal[]>;
+}
+//# sourceMappingURL=reputation.d.ts.map

package/dist/reputation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reputation.d.ts","sourceRoot":"","sources":["../src/reputation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAU,MAAM,QAAQ,CAAC;AAEhD,OAAO,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEpF,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAkB;gBACtB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc;IAC7C,aAAa,CAAC,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,oBAAoB,EAAE,cAAc,SAAkB,EAAE,MAAM,SAAK;IAC9G,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAIhE,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM;IAC/D,cAAc,CAAC,OAAO,EAAE,MAAM;IACxB,SAAS,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAIpE,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC;CAChE"}

package/dist/reputation.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ReputationOracleClient = void 0;
+const ethers_1 = require("ethers");
+const contracts_1 = require("./contracts");
+class ReputationOracleClient {
+    constructor(address, runner) { this.contract = new ethers_1.ethers.Contract(address, contracts_1.REPUTATION_ORACLE_ABI, runner); }
+    async publishSignal(subject, signalType, capabilityHash = ethers_1.ethers.ZeroHash, reason = "") { const tx = await this.contract.publishSignal(subject, signalType, capabilityHash, reason); return tx.wait(); }
+    async getReputation(subject) {
+        const [endorsements, warnings, blocks, weightedScore] = await this.contract.getReputation(subject);
+        return { endorsements: BigInt(endorsements), warnings: BigInt(warnings), blocks: BigInt(blocks), weightedScore: BigInt(weightedScore) };
+    }
+    getCapabilityReputation(subject, capabilityHash) { return this.contract.getCapabilityReputation(subject, capabilityHash).then(BigInt); }
+    getSignalCount(subject) { return this.contract.getSignalCount(subject).then(BigInt); }
+    async getSignal(subject, index) {
+        const raw = await this.contract.getSignal(subject, index);
+        return { publisher: raw.publisher, subject: raw.subject, signalType: Number(raw.signalType), capabilityHash: raw.capabilityHash, reason: raw.reason, publisherTrustAtTime: BigInt(raw.publisherTrustAtTime), timestamp: BigInt(raw.timestamp), autoPublished: raw.autoPublished };
+    }
+    async listSignals(subject) { const count = Number(await this.getSignalCount(subject)); return Promise.all(Array.from({ length: count }, (_, i) => this.getSignal(subject, BigInt(i)))); }
+}
+exports.ReputationOracleClient = ReputationOracleClient;

package/dist/session-manager.d.ts

@@ -0,0 +1,13 @@
+import type { NegotiationMessage, NegotiationSession } from "./types";
+export declare class SessionManager {
+    private sessionsDir;
+    constructor(sessionsDir?: string);
+    createSession(initiator: string, responder: string): NegotiationSession;
+    addMessage(sessionId: string, message: NegotiationMessage): void;
+    computeTranscriptHash(messages: NegotiationMessage[]): `0x${string}`;
+    load(sessionId: string): NegotiationSession;
+    save(session: NegotiationSession): void;
+    list(): NegotiationSession[];
+    setOnChainId(sessionId: string, agreementId: string): void;
+}
+//# sourceMappingURL=session-manager.d.ts.map

package/dist/session-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-manager.d.ts","sourceRoot":"","sources":["../src/session-manager.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAC;AAItE,qBAAa,cAAc;IACb,OAAO,CAAC,WAAW;gBAAX,WAAW,SAAe;IAI9C,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,kBAAkB;IAoBvE,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAgBhE,qBAAqB,CAAC,QAAQ,EAAE,kBAAkB,EAAE,GAAG,KAAK,MAAM,EAAE;IAKpE,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,kBAAkB;IAM3C,IAAI,CAAC,OAAO,EAAE,kBAAkB,GAAG,IAAI;IAOvC,IAAI,IAAI,kBAAkB,EAAE;IAO5B,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;CAK3D"}

package/dist/session-manager.js

@@ -0,0 +1,102 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const ethers_1 = require("ethers");
+const SESSIONS_DIR = path.join(os.homedir(), ".arc402", "sessions");
+class SessionManager {
+    constructor(sessionsDir = SESSIONS_DIR) {
+        this.sessionsDir = sessionsDir;
+        fs.mkdirSync(this.sessionsDir, { recursive: true });
+    }
+    createSession(initiator, responder) {
+        const nonce = ethers_1.ethers.hexlify(ethers_1.ethers.randomBytes(16));
+        const sessionId = ethers_1.ethers.keccak256(ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(["address", "address", "uint256", "bytes16"], [initiator, responder, Math.floor(Date.now() / 1000), nonce]));
+        const session = {
+            sessionId,
+            initiator: initiator,
+            responder: responder,
+            createdAt: Math.floor(Date.now() / 1000),
+            messages: [],
+            state: "OPEN",
+        };
+        this.save(session);
+        return session;
+    }
+    addMessage(sessionId, message) {
+        const session = this.load(sessionId);
+        session.messages.push(message);
+        if (message.type === "ACCEPT") {
+            session.state = "ACCEPTED";
+            session.agreedPrice = message.agreedPrice;
+            session.agreedDeadline = message.agreedDeadline;
+            session.transcriptHash = this.computeTranscriptHash(session.messages);
+        }
+        if (message.type === "REJECT") {
+            session.state = "REJECTED";
+            session.transcriptHash = this.computeTranscriptHash(session.messages);
+        }
+        this.save(session);
+    }
+    computeTranscriptHash(messages) {
+        const transcript = JSON.stringify(messages);
+        return ethers_1.ethers.keccak256(ethers_1.ethers.toUtf8Bytes(transcript));
+    }
+    load(sessionId) {
+        const file = path.join(this.sessionsDir, `${sessionId}.json`);
+        if (!fs.existsSync(file))
+            throw new Error(`Session not found: ${sessionId}`);
+        return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+    save(session) {
+        fs.writeFileSync(path.join(this.sessionsDir, `${session.sessionId}.json`), JSON.stringify(session, null, 2));
+    }
+    list() {
+        if (!fs.existsSync(this.sessionsDir))
+            return [];
+        return fs.readdirSync(this.sessionsDir)
+            .filter(f => f.endsWith(".json"))
+            .map(f => JSON.parse(fs.readFileSync(path.join(this.sessionsDir, f), "utf8")));
+    }
+    setOnChainId(sessionId, agreementId) {
+        const session = this.load(sessionId);
+        session.onChainAgreementId = agreementId;
+        this.save(session);
+    }
+}
+exports.SessionManager = SessionManager;

package/dist/settlement.d.ts

@@ -0,0 +1,14 @@
+import { ContractRunner } from "ethers";
+import { SettlementProposal } from "./types";
+export declare class SettlementClient {
+    private contract;
+    constructor(address: string, runner: ContractRunner);
+    propose(fromWallet: string, toWallet: string, amount: bigint, intentId: string, ttlSeconds?: number): Promise<string>;
+    accept(id: string): Promise<any>;
+    reject(id: string, reason: string): Promise<any>;
+    execute(id: string): Promise<any>;
+    getProposal(id: string): Promise<SettlementProposal>;
+}
+export declare class MultiAgentSettlement extends SettlementClient {
+}
+//# sourceMappingURL=settlement.d.ts.map

package/dist/settlement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settlement.d.ts","sourceRoot":"","sources":["../src/settlement.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAU,MAAM,QAAQ,CAAC;AAEhD,OAAO,EAAE,kBAAkB,EAAoB,MAAM,SAAS,CAAC;AAI/D,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAkB;gBACtB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc;IAC7C,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,UAAU,SAAO;IAajG,MAAM,CAAC,EAAE,EAAE,MAAM;IACjB,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;IACjC,OAAO,CAAC,EAAE,EAAE,MAAM;IAClB,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAI3D;AACD,qBAAa,oBAAqB,SAAQ,gBAAgB;CAAG"}

package/dist/settlement.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MultiAgentSettlement = exports.SettlementClient = void 0;
+const ethers_1 = require("ethers");
+const contracts_1 = require("./contracts");
+const STATUS_MAP = ["PENDING", "ACCEPTED", "REJECTED", "EXECUTED", "EXPIRED"];
+class SettlementClient {
+    constructor(address, runner) { this.contract = new ethers_1.ethers.Contract(address, contracts_1.SETTLEMENT_COORDINATOR_ABI, runner); }
+    async propose(fromWallet, toWallet, amount, intentId, ttlSeconds = 3600) {
+        const expiresAt = Math.floor(Date.now() / 1000) + ttlSeconds;
+        const tx = await this.contract.propose(fromWallet, toWallet, amount, intentId, expiresAt);
+        const receipt = await tx.wait();
+        const iface = new ethers_1.ethers.Interface(contracts_1.SETTLEMENT_COORDINATOR_ABI);
+        for (const log of receipt.logs) {
+            try {
+                const parsed = iface.parseLog(log);
+                if (parsed?.name === "ProposalCreated")
+                    return parsed.args.proposalId;
+            }
+            catch { }
+        }
+        throw new Error("Could not parse proposalId from receipt");
+    }
+    async accept(id) { const tx = await this.contract.accept(id); return tx.wait(); }
+    async reject(id, reason) { const tx = await this.contract.reject(id, reason); return tx.wait(); }
+    async execute(id) { const proposal = await this.getProposal(id); const tx = await this.contract.execute(id, { value: proposal.amount }); return tx.wait(); }
+    async getProposal(id) {
+        const [from, to, amount, intentId, expiresAt, statusNum, rejectionReason] = await this.contract.getProposal(id);
+        return { proposalId: id, from, to, amount: BigInt(amount), intentId, expiresAt: Number(expiresAt), status: STATUS_MAP[Number(statusNum)] ?? "PENDING", rejectionReason };
+    }
+}
+exports.SettlementClient = SettlementClient;
+class MultiAgentSettlement extends SettlementClient {
+}
+exports.MultiAgentSettlement = MultiAgentSettlement;

package/dist/sponsorship.d.ts

@@ -0,0 +1,17 @@
+import { ContractRunner } from "ethers";
+import { IdentityTier, SponsorshipAttestationRecord } from "./types";
+export declare class SponsorshipAttestationClient {
+    private contract;
+    constructor(address: string, runner: ContractRunner);
+    publish(agent: string, expiresAt?: number): Promise<any>;
+    publishWithTier(agent: string, expiresAt: number, tier: IdentityTier, evidenceURI?: string): Promise<any>;
+    revoke(attestationId: string): Promise<any>;
+    isActive(attestationId: string): Promise<any>;
+    getActiveAttestation(sponsor: string, agent: string): Promise<any>;
+    getAttestation(attestationId: string): Promise<SponsorshipAttestationRecord>;
+    getSponsorAttestations(sponsor: string): Promise<any>;
+    getAgentAttestations(agent: string): Promise<any>;
+    activeSponsorCount(sponsor: string): Promise<bigint>;
+    getHighestTier(agent: string): Promise<IdentityTier>;
+}
+//# sourceMappingURL=sponsorship.d.ts.map

package/dist/sponsorship.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sponsorship.d.ts","sourceRoot":"","sources":["../src/sponsorship.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAU,MAAM,QAAQ,CAAC;AAEhD,OAAO,EAAE,YAAY,EAAE,4BAA4B,EAAE,MAAM,SAAS,CAAC;AAErE,qBAAa,4BAA4B;IACvC,OAAO,CAAC,QAAQ,CAAkB;gBACtB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc;IAC7C,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,SAAI;IACpC,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,WAAW,SAAK;IACtF,MAAM,CAAC,aAAa,EAAE,MAAM;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM;IAC9B,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;IAC7C,cAAc,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,4BAA4B,CAAC;IAClF,sBAAsB,CAAC,OAAO,EAAE,MAAM;IACtC,oBAAoB,CAAC,KAAK,EAAE,MAAM;IAClC,kBAAkB,CAAC,OAAO,EAAE,MAAM;IAClC,cAAc,CAAC,KAAK,EAAE,MAAM;CAC7B"}

package/dist/sponsorship.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SponsorshipAttestationClient = void 0;
+const ethers_1 = require("ethers");
+const contracts_1 = require("./contracts");
+class SponsorshipAttestationClient {
+    constructor(address, runner) { this.contract = new ethers_1.ethers.Contract(address, contracts_1.SPONSORSHIP_ATTESTATION_ABI, runner); }
+    async publish(agent, expiresAt = 0) { const tx = await this.contract.publish(agent, expiresAt); return tx.wait(); }
+    async publishWithTier(agent, expiresAt, tier, evidenceURI = "") { const tx = await this.contract.publishWithTier(agent, expiresAt, tier, evidenceURI); return tx.wait(); }
+    async revoke(attestationId) { const tx = await this.contract.revoke(attestationId); return tx.wait(); }
+    isActive(attestationId) { return this.contract.isActive(attestationId); }
+    getActiveAttestation(sponsor, agent) { return this.contract.getActiveAttestation(sponsor, agent); }
+    async getAttestation(attestationId) { const raw = await this.contract.getAttestation(attestationId); return { sponsor: raw.sponsor, agent: raw.agent, issuedAt: BigInt(raw.issuedAt), expiresAt: BigInt(raw.expiresAt), revoked: raw.revoked, tier: Number(raw.tier), evidenceURI: raw.evidenceURI }; }
+    getSponsorAttestations(sponsor) { return this.contract.getSponsorAttestations(sponsor); }
+    getAgentAttestations(agent) { return this.contract.getAgentAttestations(agent); }
+    activeSponsorCount(sponsor) { return this.contract.activeSponsorCount(sponsor).then(BigInt); }
+    getHighestTier(agent) { return this.contract.getHighestTier(agent).then((value) => Number(value)); }
+}
+exports.SponsorshipAttestationClient = SponsorshipAttestationClient;

package/dist/trust.d.ts

@@ -0,0 +1,22 @@
+import { ContractRunner } from "ethers";
+import { TrustScore } from "./types";
+declare function getTrustLevel(score: number): TrustScore["level"];
+declare function getNextLevelAt(score: number): number;
+export declare class TrustClient {
+    private contract;
+    constructor(address: string, runner: ContractRunner);
+    getScore(walletAddress: string): Promise<TrustScore>;
+    /**
+     * Returns the effective trust score for a wallet, accounting for any decay or bonus adjustments
+     * applied by the TrustRegistry (e.g. velocity bonuses, anomaly penalties).
+     * Prefer this over getScore for policy decisions.
+     */
+    getEffectiveScore(walletAddress: string): Promise<TrustScore>;
+    init(walletAddress: string): Promise<any>;
+    getTrustLevel: typeof getTrustLevel;
+    getNextLevelAt: typeof getNextLevelAt;
+}
+export declare class TrustPrimitive extends TrustClient {
+}
+export {};
+//# sourceMappingURL=trust.d.ts.map

package/dist/trust.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trust.d.ts","sourceRoot":"","sources":["../src/trust.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAU,MAAM,QAAQ,CAAC;AAEhD,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAErC,iBAAS,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,UAAU,CAAC,OAAO,CAAC,CAMzD;AAED,iBAAS,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAM7C;AAED,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAkB;gBACtB,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc;IAC7C,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAK1D;;;;OAIG;IACG,iBAAiB,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAK7D,IAAI,CAAC,aAAa,EAAE,MAAM;IAChC,aAAa,uBAAiB;IAC9B,cAAc,wBAAkB;CACjC;AACD,qBAAa,cAAe,SAAQ,WAAW;CAAG"}

package/dist/trust.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrustPrimitive = exports.TrustClient = void 0;
+const ethers_1 = require("ethers");
+const contracts_1 = require("./contracts");
+function getTrustLevel(score) {
+    if (score < 100)
+        return "probationary";
+    if (score < 300)
+        return "restricted";
+    if (score < 600)
+        return "standard";
+    if (score < 800)
+        return "elevated";
+    return "autonomous";
+}
+function getNextLevelAt(score) {
+    if (score < 100)
+        return 100;
+    if (score < 300)
+        return 300;
+    if (score < 600)
+        return 600;
+    if (score < 800)
+        return 800;
+    return 0;
+}
+class TrustClient {
+    constructor(address, runner) {
+        this.getTrustLevel = getTrustLevel;
+        this.getNextLevelAt = getNextLevelAt;
+        this.contract = new ethers_1.ethers.Contract(address, contracts_1.TRUST_REGISTRY_ABI, runner);
+    }
+    async getScore(walletAddress) {
+        const score = Number(await this.contract.getScore(walletAddress));
+        return { score, level: getTrustLevel(score), nextLevelAt: getNextLevelAt(score) };
+    }
+    /**
+     * Returns the effective trust score for a wallet, accounting for any decay or bonus adjustments
+     * applied by the TrustRegistry (e.g. velocity bonuses, anomaly penalties).
+     * Prefer this over getScore for policy decisions.
+     */
+    async getEffectiveScore(walletAddress) {
+        const score = Number(await this.contract.getEffectiveScore(walletAddress));
+        return { score, level: getTrustLevel(score), nextLevelAt: getNextLevelAt(score) };
+    }
+    async init(walletAddress) { const tx = await this.contract.initWallet(walletAddress); return tx.wait(); }
+}
+exports.TrustClient = TrustClient;
+class TrustPrimitive extends TrustClient {
+}
+exports.TrustPrimitive = TrustPrimitive;