@arc402/sdk 0.2.0

package/src/types.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DisputeClass = exports.DisputeMode = exports.IdentityTier = exports.ReputationSignalType = exports.ArbitrationVote = exports.DirectDisputeReason = exports.EvidenceType = exports.DisputeOutcome = exports.ProviderResponseType = exports.AgreementStatus = exports.NETWORKS = void 0;
+exports.NETWORKS = {
+    "base-sepolia": {
+        chainId: 84532,
+        rpc: "https://sepolia.base.org",
+        contracts: {
+            policyEngine: "0x6B89621c94a7105c3D8e0BD8Fb06814931CA2CB2",
+            trustRegistry: "0xdA1D377991B2E580991B0DD381CdD635dd71aC39",
+            intentAttestation: "0xbB5E1809D4a94D08Bf1143131312858143D018f1",
+            settlementCoordinator: "0x7ad8db6C5f394542E8e9658F86C85cC99Cf6D460",
+        },
+    },
+    base: {
+        chainId: 8453,
+        rpc: "https://mainnet.base.org",
+        contracts: {
+            policyEngine: "0x0000000000000000000000000000000000000000",
+            trustRegistry: "0x0000000000000000000000000000000000000000",
+            intentAttestation: "0x0000000000000000000000000000000000000000",
+            settlementCoordinator: "0x0000000000000000000000000000000000000000",
+        },
+    },
+};
+var AgreementStatus;
+(function (AgreementStatus) {
+    AgreementStatus[AgreementStatus["PROPOSED"] = 0] = "PROPOSED";
+    AgreementStatus[AgreementStatus["ACCEPTED"] = 1] = "ACCEPTED";
+    AgreementStatus[AgreementStatus["PENDING_VERIFICATION"] = 2] = "PENDING_VERIFICATION";
+    AgreementStatus[AgreementStatus["FULFILLED"] = 3] = "FULFILLED";
+    AgreementStatus[AgreementStatus["DISPUTED"] = 4] = "DISPUTED";
+    AgreementStatus[AgreementStatus["CANCELLED"] = 5] = "CANCELLED";
+    AgreementStatus[AgreementStatus["REVISION_REQUESTED"] = 6] = "REVISION_REQUESTED";
+    AgreementStatus[AgreementStatus["REVISED"] = 7] = "REVISED";
+    AgreementStatus[AgreementStatus["PARTIAL_SETTLEMENT"] = 8] = "PARTIAL_SETTLEMENT";
+    AgreementStatus[AgreementStatus["MUTUAL_CANCEL"] = 9] = "MUTUAL_CANCEL";
+    AgreementStatus[AgreementStatus["ESCALATED_TO_HUMAN"] = 10] = "ESCALATED_TO_HUMAN";
+    AgreementStatus[AgreementStatus["ESCALATED_TO_ARBITRATION"] = 11] = "ESCALATED_TO_ARBITRATION";
+})(AgreementStatus || (exports.AgreementStatus = AgreementStatus = {}));
+var ProviderResponseType;
+(function (ProviderResponseType) {
+    ProviderResponseType[ProviderResponseType["NONE"] = 0] = "NONE";
+    ProviderResponseType[ProviderResponseType["REVISE"] = 1] = "REVISE";
+    ProviderResponseType[ProviderResponseType["DEFEND"] = 2] = "DEFEND";
+    ProviderResponseType[ProviderResponseType["COUNTER"] = 3] = "COUNTER";
+    ProviderResponseType[ProviderResponseType["PARTIAL_SETTLEMENT"] = 4] = "PARTIAL_SETTLEMENT";
+    ProviderResponseType[ProviderResponseType["REQUEST_HUMAN_REVIEW"] = 5] = "REQUEST_HUMAN_REVIEW";
+    ProviderResponseType[ProviderResponseType["ESCALATE"] = 6] = "ESCALATE";
+})(ProviderResponseType || (exports.ProviderResponseType = ProviderResponseType = {}));
+var DisputeOutcome;
+(function (DisputeOutcome) {
+    DisputeOutcome[DisputeOutcome["NONE"] = 0] = "NONE";
+    DisputeOutcome[DisputeOutcome["PENDING"] = 1] = "PENDING";
+    DisputeOutcome[DisputeOutcome["PROVIDER_WINS"] = 2] = "PROVIDER_WINS";
+    DisputeOutcome[DisputeOutcome["CLIENT_REFUND"] = 3] = "CLIENT_REFUND";
+    DisputeOutcome[DisputeOutcome["PARTIAL_PROVIDER"] = 4] = "PARTIAL_PROVIDER";
+    DisputeOutcome[DisputeOutcome["PARTIAL_CLIENT"] = 5] = "PARTIAL_CLIENT";
+    DisputeOutcome[DisputeOutcome["MUTUAL_CANCEL"] = 6] = "MUTUAL_CANCEL";
+    DisputeOutcome[DisputeOutcome["HUMAN_REVIEW_REQUIRED"] = 7] = "HUMAN_REVIEW_REQUIRED";
+})(DisputeOutcome || (exports.DisputeOutcome = DisputeOutcome = {}));
+var EvidenceType;
+(function (EvidenceType) {
+    EvidenceType[EvidenceType["NONE"] = 0] = "NONE";
+    EvidenceType[EvidenceType["TRANSCRIPT"] = 1] = "TRANSCRIPT";
+    EvidenceType[EvidenceType["DELIVERABLE"] = 2] = "DELIVERABLE";
+    EvidenceType[EvidenceType["ACCEPTANCE_CRITERIA"] = 3] = "ACCEPTANCE_CRITERIA";
+    EvidenceType[EvidenceType["COMMUNICATION"] = 4] = "COMMUNICATION";
+    EvidenceType[EvidenceType["EXTERNAL_REFERENCE"] = 5] = "EXTERNAL_REFERENCE";
+    EvidenceType[EvidenceType["OTHER"] = 6] = "OTHER";
+})(EvidenceType || (exports.EvidenceType = EvidenceType = {}));
+var DirectDisputeReason;
+(function (DirectDisputeReason) {
+    DirectDisputeReason[DirectDisputeReason["NONE"] = 0] = "NONE";
+    DirectDisputeReason[DirectDisputeReason["NO_DELIVERY"] = 1] = "NO_DELIVERY";
+    DirectDisputeReason[DirectDisputeReason["HARD_DEADLINE_BREACH"] = 2] = "HARD_DEADLINE_BREACH";
+    DirectDisputeReason[DirectDisputeReason["INVALID_OR_FRAUDULENT_DELIVERABLE"] = 3] = "INVALID_OR_FRAUDULENT_DELIVERABLE";
+    DirectDisputeReason[DirectDisputeReason["SAFETY_CRITICAL_VIOLATION"] = 4] = "SAFETY_CRITICAL_VIOLATION";
+})(DirectDisputeReason || (exports.DirectDisputeReason = DirectDisputeReason = {}));
+var ArbitrationVote;
+(function (ArbitrationVote) {
+    ArbitrationVote[ArbitrationVote["NONE"] = 0] = "NONE";
+    ArbitrationVote[ArbitrationVote["PROVIDER_WINS"] = 1] = "PROVIDER_WINS";
+    ArbitrationVote[ArbitrationVote["CLIENT_REFUND"] = 2] = "CLIENT_REFUND";
+    ArbitrationVote[ArbitrationVote["SPLIT"] = 3] = "SPLIT";
+    ArbitrationVote[ArbitrationVote["HUMAN_REVIEW_REQUIRED"] = 4] = "HUMAN_REVIEW_REQUIRED";
+})(ArbitrationVote || (exports.ArbitrationVote = ArbitrationVote = {}));
+var ReputationSignalType;
+(function (ReputationSignalType) {
+    ReputationSignalType[ReputationSignalType["ENDORSE"] = 0] = "ENDORSE";
+    ReputationSignalType[ReputationSignalType["WARN"] = 1] = "WARN";
+    ReputationSignalType[ReputationSignalType["BLOCK"] = 2] = "BLOCK";
+})(ReputationSignalType || (exports.ReputationSignalType = ReputationSignalType = {}));
+var IdentityTier;
+(function (IdentityTier) {
+    IdentityTier[IdentityTier["NONE"] = 0] = "NONE";
+    IdentityTier[IdentityTier["SPONSORED"] = 1] = "SPONSORED";
+    IdentityTier[IdentityTier["VERIFIED_PROVIDER"] = 2] = "VERIFIED_PROVIDER";
+    IdentityTier[IdentityTier["ENTERPRISE_PROVIDER"] = 3] = "ENTERPRISE_PROVIDER";
+})(IdentityTier || (exports.IdentityTier = IdentityTier = {}));
+// ─── DisputeArbitration types ─────────────────────────────────────────────────
+var DisputeMode;
+(function (DisputeMode) {
+    DisputeMode[DisputeMode["UNILATERAL"] = 0] = "UNILATERAL";
+    DisputeMode[DisputeMode["MUTUAL"] = 1] = "MUTUAL";
+})(DisputeMode || (exports.DisputeMode = DisputeMode = {}));
+var DisputeClass;
+(function (DisputeClass) {
+    DisputeClass[DisputeClass["HARD_FAILURE"] = 0] = "HARD_FAILURE";
+    DisputeClass[DisputeClass["AMBIGUITY_QUALITY"] = 1] = "AMBIGUITY_QUALITY";
+    DisputeClass[DisputeClass["HIGH_SENSITIVITY"] = 2] = "HIGH_SENSITIVITY";
+})(DisputeClass || (exports.DisputeClass = DisputeClass = {}));
+//# sourceMappingURL=types.js.map

package/src/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["types.ts"],"names":[],"mappings":";;;AAqEa,QAAA,QAAQ,GAAkC;IACrD,cAAc,EAAE;QACd,OAAO,EAAE,KAAK;QACd,GAAG,EAAE,0BAA0B;QAC/B,SAAS,EAAE;YACT,YAAY,EAAE,4CAA4C;YAC1D,aAAa,EAAE,4CAA4C;YAC3D,iBAAiB,EAAE,4CAA4C;YAC/D,qBAAqB,EAAE,4CAA4C;SACpE;KACF;IACD,IAAI,EAAE;QACJ,OAAO,EAAE,IAAI;QACb,GAAG,EAAE,0BAA0B;QAC/B,SAAS,EAAE;YACT,YAAY,EAAE,4CAA4C;YAC1D,aAAa,EAAE,4CAA4C;YAC3D,iBAAiB,EAAE,4CAA4C;YAC/D,qBAAqB,EAAE,4CAA4C;SACpE;KACF;CACF,CAAC;AA2BF,IAAY,eAaX;AAbD,WAAY,eAAe;IACzB,6DAAY,CAAA;IACZ,6DAAY,CAAA;IACZ,qFAAwB,CAAA;IACxB,+DAAa,CAAA;IACb,6DAAY,CAAA;IACZ,+DAAa,CAAA;IACb,iFAAsB,CAAA;IACtB,2DAAW,CAAA;IACX,iFAAsB,CAAA;IACtB,uEAAiB,CAAA;IACjB,kFAAuB,CAAA;IACvB,8FAA6B,CAAA;AAC/B,CAAC,EAbW,eAAe,+BAAf,eAAe,QAa1B;AAED,IAAY,oBAQX;AARD,WAAY,oBAAoB;IAC9B,+DAAQ,CAAA;IACR,mEAAU,CAAA;IACV,mEAAU,CAAA;IACV,qEAAW,CAAA;IACX,2FAAsB,CAAA;IACtB,+FAAwB,CAAA;IACxB,uEAAY,CAAA;AACd,CAAC,EARW,oBAAoB,oCAApB,oBAAoB,QAQ/B;AAED,IAAY,cASX;AATD,WAAY,cAAc;IACxB,mDAAQ,CAAA;IACR,yDAAW,CAAA;IACX,qEAAiB,CAAA;IACjB,qEAAiB,CAAA;IACjB,2EAAoB,CAAA;IACpB,uEAAkB,CAAA;IAClB,qEAAiB,CAAA;IACjB,qFAAyB,CAAA;AAC3B,CAAC,EATW,cAAc,8BAAd,cAAc,QASzB;AAED,IAAY,YAQX;AARD,WAAY,YAAY;IACtB,+CAAQ,CAAA;IACR,2DAAc,CAAA;IACd,6DAAe,CAAA;IACf,6EAAuB,CAAA;IACvB,iEAAiB,CAAA;IACjB,2EAAsB,CAAA;IACtB,iDAAS,CAAA;AACX,CAAC,EARW,YAAY,4BAAZ,YAAY,QAQvB;AAED,IAAY,mBAMX;AAND,WAAY,mBAAmB;IAC7B,6DAAQ,CAAA;IACR,2EAAe,CAAA;IACf,6FAAwB,CAAA;IACxB,uHAAqC,CAAA;IACrC,uGAA6B,CAAA;AAC/B,CAAC,EANW,mBAAmB,mCAAnB,mBAAmB,QAM9B;AA+ED,IAAY,eAMX;AAND,WAAY,eAAe;IACzB,qDAAQ,CAAA;IACR,uEAAiB,CAAA;IACjB,uEAAiB,CAAA;IACjB,uDAAS,CAAA;IACT,uFAAyB,CAAA;AAC3B,CAAC,EANW,eAAe,+BAAf,eAAe,QAM1B;AAkBD,IAAY,oBAIX;AAJD,WAAY,oBAAoB;IAC9B,qEAAW,CAAA;IACX,+DAAQ,CAAA;IACR,iEAAS,CAAA;AACX,CAAC,EAJW,oBAAoB,oCAApB,oBAAoB,QAI/B;AAoBD,IAAY,YAKX;AALD,WAAY,YAAY;IACtB,+CAAQ,CAAA;IACR,yDAAa,CAAA;IACb,yEAAqB,CAAA;IACrB,6EAAuB,CAAA;AACzB,CAAC,EALW,YAAY,4BAAZ,YAAY,QAKvB;AA2GD,iFAAiF;AAEjF,IAAY,WAGX;AAHD,WAAY,WAAW;IACrB,yDAAc,CAAA;IACd,iDAAU,CAAA;AACZ,CAAC,EAHW,WAAW,2BAAX,WAAW,QAGtB;AAED,IAAY,YAIX;AAJD,WAAY,YAAY;IACtB,+DAAgB,CAAA;IAChB,yEAAqB,CAAA;IACrB,uEAAoB,CAAA;AACtB,CAAC,EAJW,YAAY,4BAAZ,YAAY,QAIvB"}

package/src/types.ts

@@ -0,0 +1,484 @@
+export type Address = string;
+export type Hex = string;
+
+export interface CategoryLimit {
+  limitPerTx: bigint;
+}
+
+export interface Policy {
+  walletAddress: Address;
+  policyHash?: Hex;
+  categories: Record<string, CategoryLimit>;
+}
+
+export interface Context {
+  contextId: Hex;
+  taskType: string;
+  openedAt: number;
+  isOpen: boolean;
+}
+
+export interface TrustScore {
+  score: number;
+  level: "probationary" | "restricted" | "standard" | "elevated" | "autonomous";
+  nextLevelAt: number;
+}
+
+export interface Intent {
+  attestationId: Hex;
+  action: string;
+  reason: string;
+  recipient: Address;
+  amount: bigint;
+  wallet: Address;
+  timestamp: number;
+}
+
+export type SettlementStatus = "PENDING" | "ACCEPTED" | "REJECTED" | "EXECUTED" | "EXPIRED";
+
+export interface SettlementProposal {
+  proposalId: Hex;
+  from: Address;
+  to: Address;
+  amount: bigint;
+  intentId: Hex;
+  expiresAt: number;
+  status: SettlementStatus;
+  rejectionReason?: string;
+}
+
+export interface ContractAddresses {
+  policyEngine: Address;
+  trustRegistry: Address;
+  intentAttestation: Address;
+  settlementCoordinator: Address;
+  walletFactory?: Address;
+  agentRegistry?: Address;
+  serviceAgreement?: Address;
+  reputationOracle?: Address;
+  sponsorshipAttestation?: Address;
+  capabilityRegistry?: Address;
+  governance?: Address;
+}
+
+export interface NetworkConfig {
+  chainId: number;
+  rpc: string;
+  contracts: ContractAddresses;
+}
+
+export const NETWORKS: Record<string, NetworkConfig> = {
+  "base-sepolia": {
+    chainId: 84532,
+    rpc: "https://sepolia.base.org",
+    contracts: {
+      policyEngine: "0x6B89621c94a7105c3D8e0BD8Fb06814931CA2CB2",
+      trustRegistry: "0xdA1D377991B2E580991B0DD381CdD635dd71aC39",
+      intentAttestation: "0xbB5E1809D4a94D08Bf1143131312858143D018f1",
+      settlementCoordinator: "0x7ad8db6C5f394542E8e9658F86C85cC99Cf6D460",
+    },
+  },
+  base: {
+    chainId: 8453,
+    rpc: "https://mainnet.base.org",
+    contracts: {
+      policyEngine: "0xAA5Ef3489C929bFB3BFf5D5FE15aa62d3763c847",
+      trustRegistry: "0x22366D6dabb03062Bc0a5E893EfDff15D8E329b1",   // TrustRegistryV3 — v2
+      intentAttestation: "0x7ad8db6C5f394542E8e9658F86C85cC99Cf6D460",
+      settlementCoordinator: "0xd52d8Be9728976E0D70C89db9F8ACeb5B5e97cA2", // SettlementCoordinatorV2 ← active
+      walletFactory: "0xcB52B5d746eEc05e141039E92e3dBefeAe496051",   // WalletFactory v5 ← active (redeployed 2026-03-19, optimized bytecode, passkey P256)
+      agentRegistry: "0xD5c2851B00090c92Ba7F4723FB548bb30C9B6865",   // AgentRegistry ← discovery directory
+      serviceAgreement: "0xC98B402CAB9156da68A87a69E3B4bf167A3CCcF6",
+      reputationOracle: "0x359F76a54F9A345546E430e4d6665A7dC9DaECd4",
+      sponsorshipAttestation: "0xD6c2edE89Ea71aE19Db2Be848e172b444Ed38f22",
+      capabilityRegistry: "0x7becb642668B80502dD957A594E1dD0aC414c1a3",
+      governance: "0xE931DD2EEb9Af9353Dd5E2c1250492A0135E0EC4",
+    },
+  },
+};
+
+export interface AgentInfo {
+  wallet: Address;
+  name: string;
+  capabilities: string[];
+  serviceType: string;
+  endpoint: string;
+  metadataURI: string;
+  active: boolean;
+  registeredAt: bigint;
+  endpointChangedAt: bigint;
+  endpointChangeCount: bigint;
+  trustScore?: bigint;
+}
+
+export interface OperationalMetrics {
+  heartbeatInterval: bigint;
+  heartbeatGracePeriod: bigint;
+  lastHeartbeatAt: bigint;
+  rollingLatency: bigint;
+  heartbeatCount: bigint;
+  missedHeartbeatCount: bigint;
+  uptimeScore: bigint;
+  responseScore: bigint;
+}
+
+export enum AgreementStatus {
+  PROPOSED = 0,
+  ACCEPTED = 1,
+  PENDING_VERIFICATION = 2,
+  FULFILLED = 3,
+  DISPUTED = 4,
+  CANCELLED = 5,
+  REVISION_REQUESTED = 6,
+  REVISED = 7,
+  PARTIAL_SETTLEMENT = 8,
+  MUTUAL_CANCEL = 9,
+  ESCALATED_TO_HUMAN = 10,
+  ESCALATED_TO_ARBITRATION = 11,
+}
+
+export enum ProviderResponseType {
+  NONE = 0,
+  REVISE = 1,
+  DEFEND = 2,
+  COUNTER = 3,
+  PARTIAL_SETTLEMENT = 4,
+  REQUEST_HUMAN_REVIEW = 5,
+  ESCALATE = 6,
+}
+
+export enum DisputeOutcome {
+  NONE = 0,
+  PENDING = 1,
+  PROVIDER_WINS = 2,
+  CLIENT_REFUND = 3,
+  PARTIAL_PROVIDER = 4,
+  PARTIAL_CLIENT = 5,
+  MUTUAL_CANCEL = 6,
+  HUMAN_REVIEW_REQUIRED = 7,
+}
+
+export enum EvidenceType {
+  NONE = 0,
+  TRANSCRIPT = 1,
+  DELIVERABLE = 2,
+  ACCEPTANCE_CRITERIA = 3,
+  COMMUNICATION = 4,
+  EXTERNAL_REFERENCE = 5,
+  OTHER = 6,
+}
+
+export enum DirectDisputeReason {
+  NONE = 0,
+  NO_DELIVERY = 1,
+  HARD_DEADLINE_BREACH = 2,
+  INVALID_OR_FRAUDULENT_DELIVERABLE = 3,
+  SAFETY_CRITICAL_VIOLATION = 4,
+}
+
+export interface Agreement {
+  id: bigint;
+  client: Address;
+  provider: Address;
+  serviceType: string;
+  description: string;
+  price: bigint;
+  token: Address;
+  deadline: bigint;
+  deliverablesHash: Hex;
+  status: AgreementStatus;
+  createdAt: bigint;
+  resolvedAt: bigint;
+  verifyWindowEnd: bigint;
+  committedHash: Hex;
+}
+
+export interface ProposeParams {
+  provider: Address;
+  serviceType: string;
+  description: string;
+  price: bigint;
+  token: Address;
+  deadline: number;
+  deliverablesHash: Hex;
+}
+
+export interface RemediationCase {
+  cycleCount: number;
+  openedAt: bigint;
+  deadlineAt: bigint;
+  lastActionAt: bigint;
+  latestTranscriptHash: Hex;
+  active: boolean;
+}
+
+export interface RemediationFeedback {
+  cycle: number;
+  author: Address;
+  feedbackHash: Hex;
+  feedbackURI: string;
+  previousTranscriptHash: Hex;
+  transcriptHash: Hex;
+  timestamp: bigint;
+}
+
+export interface RemediationResponse {
+  cycle: number;
+  author: Address;
+  responseType: ProviderResponseType;
+  proposedProviderPayout: bigint;
+  responseHash: Hex;
+  responseURI: string;
+  previousTranscriptHash: Hex;
+  transcriptHash: Hex;
+  timestamp: bigint;
+}
+
+export interface DisputeCase {
+  agreementId: bigint;
+  openedAt: bigint;
+  responseDeadlineAt: bigint;
+  outcome: DisputeOutcome;
+  providerAward: bigint;
+  clientAward: bigint;
+  humanReviewRequested: boolean;
+  evidenceCount: bigint;
+}
+
+export interface DisputeEvidence {
+  submitter: Address;
+  evidenceType: EvidenceType;
+  evidenceHash: Hex;
+  evidenceURI: string;
+  timestamp: bigint;
+}
+
+export enum ArbitrationVote {
+  NONE = 0,
+  PROVIDER_WINS = 1,
+  CLIENT_REFUND = 2,
+  SPLIT = 3,
+  HUMAN_REVIEW_REQUIRED = 4,
+}
+
+export interface ArbitrationCase {
+  agreementId: bigint;
+  arbitrators: Address[];
+  arbitratorCount: number;
+  providerVotes: number;
+  clientVotes: number;
+  splitVotes: number;
+  humanVotes: number;
+  selectionDeadlineAt: bigint;
+  decisionDeadlineAt: bigint;
+  splitProviderAward: bigint;
+  splitClientAward: bigint;
+  finalized: boolean;
+  humanBackstopUsed: boolean;
+}
+
+export enum ReputationSignalType {
+  ENDORSE = 0,
+  WARN = 1,
+  BLOCK = 2,
+}
+
+export interface ReputationSignal {
+  publisher: Address;
+  subject: Address;
+  signalType: ReputationSignalType;
+  capabilityHash: Hex;
+  reason: string;
+  publisherTrustAtTime: bigint;
+  timestamp: bigint;
+  autoPublished: boolean;
+}
+
+export interface ReputationSummary {
+  endorsements: bigint;
+  warnings: bigint;
+  blocks: bigint;
+  weightedScore: bigint;
+}
+
+export enum IdentityTier {
+  NONE = 0,
+  SPONSORED = 1,
+  VERIFIED_PROVIDER = 2,
+  ENTERPRISE_PROVIDER = 3,
+}
+
+export interface SponsorshipAttestationRecord {
+  sponsor: Address;
+  agent: Address;
+  issuedAt: bigint;
+  expiresAt: bigint;
+  revoked: boolean;
+  tier: IdentityTier;
+  evidenceURI: string;
+}
+
+export interface CapabilityRoot {
+  root: string;
+  rootId: Hex;
+  active: boolean;
+}
+
+export interface GovernanceTransaction {
+  target: Address;
+  value: bigint;
+  data: Hex;
+  executed: boolean;
+  confirmationCount: bigint;
+}
+
+export interface NegotiationMessageBase {
+  from: Address;
+  to: Address;
+  timestamp: number;  // Unix seconds — receiver rejects if |now - timestamp| > 60
+  sig: Hex;           // ECDSA signature over message digest (see signNegotiationMessage)
+}
+
+export interface NegotiationProposal extends NegotiationMessageBase {
+  type: "PROPOSE";
+  serviceType: string;
+  price: string;
+  token: Address;
+  deadline: string;
+  spec: string;
+  specHash: Hex;
+  nonce: Hex;
+  expiresAt: number;  // Unix seconds, required, max timestamp + 86400
+}
+
+export interface NegotiationCounter extends NegotiationMessageBase {
+  type: "COUNTER";
+  price?: string;
+  deadline?: string;
+  justification: string;
+  refNonce: Hex;
+}
+
+export interface NegotiationAccept extends NegotiationMessageBase {
+  type: "ACCEPT";
+  agreedPrice: string;
+  agreedDeadline: string;
+  refNonce: Hex;
+}
+
+export interface NegotiationReject extends NegotiationMessageBase {
+  type: "REJECT";
+  reason: string;
+  refNonce?: Hex;
+}
+
+export type NegotiationMessage =
+  | NegotiationProposal
+  | NegotiationCounter
+  | NegotiationAccept
+  | NegotiationReject;
+
+export interface NegotiationSession {
+  sessionId: Hex;              // keccak256(initiator + responder + timestamp + nonce)
+  initiator: Address;
+  responder: Address;
+  createdAt: number;           // Unix seconds
+  messages: NegotiationMessage[];
+  state: "OPEN" | "ACCEPTED" | "REJECTED" | "EXPIRED";
+  transcriptHash?: Hex;        // set after session closes
+  agreedPrice?: string;
+  agreedDeadline?: string;
+  onChainAgreementId?: string; // set after propose() is called
+}
+
+export interface SignedNegotiationMessage<T extends NegotiationMessage = NegotiationMessage> {
+  message: T;
+  recoveredSigner: Address;
+}
+
+export type NegotiationVerificationError =
+  | "INVALID_SIGNATURE"
+  | "SIGNER_NOT_REGISTERED"
+  | "TIMESTAMP_TOO_OLD"
+  | "TIMESTAMP_IN_FUTURE"
+  | "NONCE_REPLAYED"
+  | "MESSAGE_EXPIRED"
+  | "MESSAGE_TOO_LARGE"
+  | "SCHEMA_INVALID";
+
+export interface NegotiationVerificationResult {
+  valid: boolean;
+  error?: NegotiationVerificationError;
+  recoveredSigner?: Address;
+}
+
+
+// ─── DisputeArbitration types ─────────────────────────────────────────────────
+
+export enum DisputeMode {
+  UNILATERAL = 0,
+  MUTUAL = 1,
+}
+
+export enum DisputeClass {
+  HARD_FAILURE = 0,
+  AMBIGUITY_QUALITY = 1,
+  HIGH_SENSITIVITY = 2,
+}
+
+export interface DisputeFeeState {
+  mode: DisputeMode;
+  disputeClass: DisputeClass;
+  opener: string;
+  client: string;
+  provider: string;
+  token: string;
+  agreementPrice: bigint;
+  feeRequired: bigint;
+  openerPaid: bigint;
+  respondentPaid: bigint;
+  openedAt: bigint;
+  active: boolean;
+  resolved: boolean;
+}
+
+export interface ArbitratorBondState {
+  bondAmount: bigint;
+  lockedAt: bigint;
+  locked: boolean;
+  slashed: boolean;
+  returned: boolean;
+}
+
+export type ChannelStatus = 'OPEN' | 'CLOSING' | 'CHALLENGED' | 'SETTLED';
+
+export interface ChannelState {
+  channelId: string
+  sequenceNumber: number
+  callCount: number
+  cumulativePayment: bigint
+  token: string
+  timestamp: number
+  clientSig?: string
+  providerSig?: string
+}
+
+export interface Channel {
+  client: string
+  provider: string
+  token: string
+  depositAmount: bigint
+  settledAmount: bigint
+  lastSequenceNumber: number
+  deadline: number
+  challengeExpiry: number
+  status: ChannelStatus
+}
+
+export interface OpenChannelParams {
+  provider: string
+  token: string
+  maxAmount: bigint
+  ratePerCall: bigint
+  deadline: number
+}

package/src/wallet.ts

@@ -0,0 +1,86 @@
+import { ContractRunner, ethers } from "ethers";
+import { ARC402_WALLET_ABI, INTENT_ATTESTATION_ABI, WALLET_FACTORY_ABI } from "./contracts";
+import { Context, ContractAddresses, Intent, NETWORKS, TrustScore } from "./types";
+import { PolicyClient } from "./policy";
+import { TrustClient } from "./trust";
+import { IntentAttestationClient } from "./intent";
+
+function resolveContracts(network: string): ContractAddresses {
+  const config = NETWORKS[network];
+  if (!config) throw new Error(`Unknown network: ${network}`);
+  return config.contracts;
+}
+
+export class ARC402WalletClient {
+  private walletContract: ethers.Contract;
+  private intentContract: ethers.Contract;
+  public policy: PolicyClient;
+  public trust: TrustClient;
+  public intent: IntentAttestationClient;
+
+  constructor(public walletAddress: string, private signer: ContractRunner, network = "base-sepolia") {
+    const contracts = resolveContracts(network);
+    this.walletContract = new ethers.Contract(walletAddress, ARC402_WALLET_ABI, signer);
+    this.intentContract = new ethers.Contract(contracts.intentAttestation, INTENT_ATTESTATION_ABI, signer);
+    this.policy = new PolicyClient(contracts.policyEngine, signer);
+    this.trust = new TrustClient(contracts.trustRegistry, signer);
+    this.intent = new IntentAttestationClient(contracts.intentAttestation, signer, walletAddress);
+  }
+
+  static async deploy(signer: ContractRunner, network = "base-sepolia") {
+    const contracts = resolveContracts(network);
+    if (!contracts.walletFactory) throw new Error(`WalletFactory not deployed on ${network}`);
+    const factory = new ethers.Contract(contracts.walletFactory, WALLET_FACTORY_ABI, signer);
+    const tx = await factory.createWallet();
+    const receipt = await tx.wait();
+    const iface = new ethers.Interface(WALLET_FACTORY_ABI);
+    for (const log of receipt.logs) {
+      try {
+        const parsed = iface.parseLog(log);
+        if (parsed?.name === "WalletCreated") return new ARC402WalletClient(parsed.args.walletAddress, signer, network);
+      } catch {}
+    }
+    throw new Error("Could not parse wallet address from WalletCreated event");
+  }
+
+  setPolicy(categories: Record<string, bigint>) { return this.policy.set(this.walletAddress, categories); }
+  getPolicy() { return this.policy.get(this.walletAddress); }
+
+  async openContext(taskType: string): Promise<{ contextId: string; close: () => Promise<void> }> {
+    const contextId = ethers.keccak256(ethers.toUtf8Bytes(`${taskType}:${Date.now()}:${this.walletAddress}`));
+    const tx = await this.walletContract.openContext(contextId, taskType);
+    await tx.wait();
+    return { contextId, close: () => this.closeContext() };
+  }
+
+  async closeContext() { const tx = await this.walletContract.closeContext(); return tx.wait(); }
+
+  async getActiveContext(): Promise<Context | null> {
+    const [contextId, taskType, openedAt, isOpen] = await this.walletContract.getActiveContext();
+    if (!isOpen) return null;
+    return { contextId, taskType, openedAt: Number(openedAt), isOpen };
+  }
+
+  async spend(recipient: string, amount: bigint, category: string, action: string, reason: string): Promise<string> {
+    const attestationId = await this.intent.create(action, reason, recipient, amount);
+    const tx = await this.walletContract.executeSpend(recipient, amount, category, attestationId);
+    await tx.wait();
+    return attestationId;
+  }
+
+  getTrustScore(): Promise<TrustScore> { return this.trust.getScore(this.walletAddress); }
+
+  async getAttestations(limit = 50): Promise<Intent[]> {
+    const provider = (this.signer as ethers.Signer).provider;
+    if (!provider) return [];
+    const iface = new ethers.Interface(INTENT_ATTESTATION_ABI);
+    const event = iface.getEvent("AttestationCreated");
+    const logs = await provider.getLogs({ address: this.intentContract.target as string, topics: [event.topicHash, null, ethers.zeroPadValue(this.walletAddress, 32)], fromBlock: 0 });
+    return logs.slice(-limit).reverse().map((log) => {
+      const parsed = iface.parseLog(log);
+      return { attestationId: parsed.args.id, wallet: parsed.args.wallet, action: parsed.args.action, reason: parsed.args.reason, recipient: parsed.args.recipient, amount: BigInt(parsed.args.amount), timestamp: Number(parsed.args.timestamp) };
+    });
+  }
+}
+export class ARC402Wallet extends ARC402WalletClient {}
+export type ContextBinding = Awaited<ReturnType<ARC402WalletClient["openContext"]>>;