@engramx/client 0.1.0

package/dist/EngramClient.js

@@ -0,0 +1,1168 @@
+import { Actor, HttpAgent } from '@icp-sdk/core/agent';
+import { Principal } from '@icp-sdk/core/principal';
+import { Ic402Client } from '@ic402/client';
+import { LRUCache } from './cache';
+import { OfflineQueue } from './offline';
+import { loadSessionKey, identityFromSeed } from './auth';
+import { EncryptionManager } from './encryption';
+// Only operator-safe, append-only methods may be queued offline. writeMemory is
+// owner-only and intentionally not on the SDK surface, so it must never be
+// replayable from a (tamperable) on-disk queue.
+const ALLOWED_OFFLINE_METHODS = new Set(['appendMemory']);
+function validateMemoryPath(p) {
+    if (p.includes('\0'))
+        throw new Error('Path contains null byte');
+    if (p.includes('..'))
+        throw new Error('Path contains traversal sequence');
+}
+// Minimal Candid IDL factory — in production, use generated declarations
+const idlFactory = ({ IDL }) => {
+    const OperatorPermissions = IDL.Record({
+        canReadMemory: IDL.Bool,
+        canAppendMemory: IDL.Bool,
+        canReadWallet: IDL.Bool,
+        callsPerMinute: IDL.Nat,
+        canReadBackup: IDL.Opt(IDL.Bool),
+    });
+    const OperatorRecord = IDL.Record({
+        principal: IDL.Principal,
+        name: IDL.Text,
+        registeredAt: IDL.Int,
+        lastSeen: IDL.Int,
+        permissions: OperatorPermissions,
+        status: IDL.Variant({
+            Active: IDL.Null,
+            Revoked: IDL.Null,
+            Expired: IDL.Null,
+        }),
+        publicKeyHash: IDL.Opt(IDL.Text),
+        keyRotatedAt: IDL.Int,
+        keyRotationCount: IDL.Nat,
+    });
+    const MemoryFile = IDL.Record({
+        path: IDL.Text,
+        content: IDL.Vec(IDL.Nat8),
+        version: IDL.Nat,
+        lastModifiedBy: IDL.Principal,
+        lastModifiedAt: IDL.Int,
+    });
+    const MemoryVersion = IDL.Record({
+        version: IDL.Nat,
+        modifiedBy: IDL.Principal,
+        modifiedAt: IDL.Int,
+        operation: IDL.Variant({
+            Set: IDL.Null,
+            Append: IDL.Null,
+            Rollback: IDL.Null,
+        }),
+        contentSnapshot: IDL.Vec(IDL.Nat8),
+    });
+    // ic402 types
+    const Eip3009Authorization = IDL.Record({
+        from: IDL.Text,
+        to: IDL.Text,
+        value: IDL.Nat,
+        validAfter: IDL.Nat,
+        validBefore: IDL.Nat,
+        nonce: IDL.Vec(IDL.Nat8),
+        v: IDL.Nat8,
+        r: IDL.Vec(IDL.Nat8),
+        s: IDL.Vec(IDL.Nat8),
+    });
+    const PaymentSignature = IDL.Record({
+        scheme: IDL.Text,
+        network: IDL.Text,
+        signature: IDL.Vec(IDL.Nat8),
+        asset: IDL.Opt(IDL.Text), // ic402 2.5.3: optional asset (token) hint
+        publicKey: IDL.Opt(IDL.Vec(IDL.Nat8)),
+        sender: IDL.Text,
+        nonce: IDL.Vec(IDL.Nat8),
+        authorization: IDL.Opt(Eip3009Authorization),
+    });
+    const PaymentRequirement = IDL.Record({
+        scheme: IDL.Text,
+        network: IDL.Text,
+        token: IDL.Text,
+        amount: IDL.Nat,
+        recipient: IDL.Text,
+        nonce: IDL.Vec(IDL.Nat8),
+        expiry: IDL.Int,
+        tokenName: IDL.Opt(IDL.Text),
+        tokenVersion: IDL.Opt(IDL.Text),
+    });
+    const SessionStatus = IDL.Variant({
+        open: IDL.Null,
+        closing: IDL.Null,
+        closed: IDL.Null,
+        expired: IDL.Null,
+    });
+    const SessionIntent = IDL.Record({
+        network: IDL.Text,
+        token: IDL.Text,
+        recipient: IDL.Text,
+        suggestedDeposit: IDL.Nat,
+        minDeposit: IDL.Opt(IDL.Nat),
+        expiry: IDL.Int,
+        costPerCall: IDL.Opt(IDL.Nat),
+        description: IDL.Opt(IDL.Text),
+    });
+    const SessionConfig = IDL.Record({
+        maxDeposit: IDL.Nat,
+        autoClose: IDL.Bool,
+        idleTimeout: IDL.Opt(IDL.Int),
+    });
+    const SessionState = IDL.Record({
+        id: IDL.Text,
+        payer: IDL.Principal,
+        deposited: IDL.Nat,
+        consumed: IDL.Nat,
+        remaining: IDL.Nat,
+        voucherCount: IDL.Nat,
+        status: SessionStatus,
+        openedAt: IDL.Int,
+        lastActivityAt: IDL.Int,
+    });
+    const Voucher = IDL.Record({
+        sessionId: IDL.Text,
+        cumulativeAmount: IDL.Nat,
+        sequence: IDL.Nat,
+        signature: IDL.Vec(IDL.Nat8),
+    });
+    const SpendingPolicy = IDL.Record({
+        maxPerTransaction: IDL.Opt(IDL.Nat),
+        maxPerDay: IDL.Opt(IDL.Nat),
+        rateLimitPerMinute: IDL.Opt(IDL.Nat),
+        maxSessionDeposit: IDL.Opt(IDL.Nat),
+        maxConcurrentSessions: IDL.Opt(IDL.Nat),
+        maxSessionDuration: IDL.Opt(IDL.Int),
+        sessionIdleTimeout: IDL.Opt(IDL.Int),
+        allowedCallers: IDL.Opt(IDL.Vec(IDL.Principal)),
+        blockedCallers: IDL.Opt(IDL.Vec(IDL.Principal)),
+    });
+    const ContentEntry = IDL.Record({
+        id: IDL.Text,
+        mimeType: IDL.Text,
+        totalSize: IDL.Nat,
+        chunkCount: IDL.Nat,
+        createdAt: IDL.Int,
+    });
+    const ContentRef = IDL.Record({
+        id: IDL.Text,
+        mimeType: IDL.Opt(IDL.Text),
+        sizeBytes: IDL.Opt(IDL.Nat),
+        metadata: IDL.Opt(IDL.Vec(IDL.Tuple(IDL.Text, IDL.Text))),
+    });
+    const AccessGrant = IDL.Record({
+        grantId: IDL.Text,
+        contentRef: ContentRef,
+        grantee: IDL.Principal,
+        receiptId: IDL.Text,
+        issuedAt: IDL.Int,
+        expiresAt: IDL.Int,
+        hmac: IDL.Vec(IDL.Nat8),
+    });
+    const DeliveryMethod = IDL.Variant({
+        inline: IDL.Vec(IDL.Nat8),
+        canisterQuery: IDL.Record({ method: IDL.Text, chunkCount: IDL.Nat }),
+        httpUrl: IDL.Text,
+        assetCanister: IDL.Record({ canisterId: IDL.Principal, path: IDL.Text }),
+    });
+    const ContentDelivery = IDL.Record({
+        grant: AccessGrant,
+        delivery: DeliveryMethod,
+    });
+    const PaymentReceipt = IDL.Record({
+        id: IDL.Text,
+        amount: IDL.Nat,
+        token: IDL.Text,
+        sender: IDL.Text,
+        recipient: IDL.Text,
+        network: IDL.Text,
+        timestamp: IDL.Int,
+        txHash: IDL.Opt(IDL.Text),
+        sessionId: IDL.Opt(IDL.Text),
+        refunded: IDL.Opt(IDL.Nat),
+    });
+    const PaymentResult = IDL.Variant({
+        ok: PaymentReceipt,
+        insufficientFunds: IDL.Text,
+        invalidSignature: IDL.Text,
+        expired: IDL.Text,
+        policyDenied: IDL.Text,
+        tokenNotAccepted: IDL.Text,
+        networkNotSupported: IDL.Text,
+        settlementFailed: IDL.Text,
+        reputationTooLow: IDL.Nat,
+        depositBelowMinimum: IDL.Nat,
+    });
+    const AgentCard = IDL.Record({
+        name: IDL.Text,
+        description: IDL.Text,
+        services: IDL.Vec(IDL.Record({
+            name: IDL.Text,
+            endpoint: IDL.Text,
+            version: IDL.Text,
+            skills: IDL.Vec(IDL.Text),
+            domains: IDL.Vec(IDL.Text),
+        })),
+        x402Support: IDL.Bool,
+    });
+    const AccessGrantResult = IDL.Variant({
+        ok: IDL.Null,
+        expired: IDL.Text,
+        revoked: IDL.Text,
+        invalidGrant: IDL.Text,
+    });
+    const AuditEntry = IDL.Record({
+        id: IDL.Nat,
+        timestamp: IDL.Int,
+        caller: IDL.Principal,
+        callerRole: IDL.Variant({ Owner: IDL.Null, Operator: IDL.Null, Guardian: IDL.Null }),
+        operation: IDL.Text,
+        details: IDL.Text,
+        success: IDL.Bool,
+    });
+    const GuardianPermissions = IDL.Record({
+        canRevokeOperators: IDL.Bool,
+        canFreezePayments: IDL.Bool,
+        canPauseWrites: IDL.Bool,
+    });
+    const GuardianRecord = IDL.Record({
+        principal: IDL.Principal,
+        name: IDL.Text,
+        addedAt: IDL.Int,
+        permissions: GuardianPermissions,
+    });
+    const VerificationLevel = IDL.Variant({
+        Orb: IDL.Null,
+        Device: IDL.Null,
+        Document: IDL.Null,
+    });
+    const WorldIdProof = IDL.Record({
+        nullifierHash: IDL.Text,
+        merkleRoot: IDL.Text,
+        proof: IDL.Text,
+        verificationLevel: VerificationLevel,
+        verifiedAt: IDL.Int,
+    });
+    const BackupType = IDL.Variant({
+        FullSnapshot: IDL.Null,
+        PartialSnapshot: IDL.Null,
+        IncrementalDiff: IDL.Null,
+    });
+    const BackupStatus = IDL.Variant({
+        Uploading: IDL.Null,
+        Finalized: IDL.Null,
+        Failed: IDL.Null,
+    });
+    const BackupMetadata = IDL.Record({
+        backupId: IDL.Text,
+        dbType: IDL.Text,
+        backupType: BackupType,
+        parentBackupId: IDL.Opt(IDL.Text),
+        totalSize: IDL.Nat,
+        chunkCount: IDL.Nat,
+        sha256: IDL.Text,
+        createdAt: IDL.Int,
+        createdBy: IDL.Principal,
+        backupLabel: IDL.Opt(IDL.Text),
+        status: BackupStatus,
+    });
+    const ApprovalStatus = IDL.Variant({
+        Pending: IDL.Null,
+        Approved: IDL.Null,
+        Denied: IDL.Null,
+        Used: IDL.Null,
+        Expired: IDL.Null,
+    });
+    const ApprovalRequest = IDL.Record({
+        id: IDL.Text,
+        caller: IDL.Principal,
+        operation: IDL.Text,
+        amount: IDL.Nat,
+        policyLimit: IDL.Nat,
+        policyField: IDL.Text,
+        rationale: IDL.Text,
+        createdAt: IDL.Int,
+        expiresAt: IDL.Int,
+        status: ApprovalStatus,
+        approvedBy: IDL.Opt(IDL.Principal),
+        approvedAt: IDL.Opt(IDL.Int),
+        denialReason: IDL.Opt(IDL.Text),
+    });
+    // ic402 service-marketplace types (minimal — Candid record decoding tolerates the
+    // canister's extra fields, so these read enough for the SDK's job/service flows).
+    const ServiceType = IDL.Variant({ Sync: IDL.Null, Async: IDL.Null });
+    const PricingScheme = IDL.Variant({ Exact: IDL.Nat, Upto: IDL.Nat, Session: IDL.Null });
+    const ServiceDeliveryMethod = IDL.Variant({ Both: IDL.Null, Poll: IDL.Null, Callback: IDL.Null });
+    const JobStatus = IDL.Variant({
+        Disputed: IDL.Null,
+        Refunded: IDL.Null,
+        Computing: IDL.Null,
+        Settling: IDL.Null,
+        Submitted: IDL.Null,
+        Assigned: IDL.Null,
+        Verified: IDL.Null,
+        Expired: IDL.Null,
+        Settled: IDL.Null,
+        Pending: IDL.Null,
+    });
+    const Job = IDL.Record({
+        id: IDL.Text,
+        status: JobStatus,
+        serviceId: IDL.Text,
+        amount: IDL.Nat,
+        result: IDL.Opt(IDL.Vec(IDL.Nat8)),
+    });
+    return IDL.Service({
+        init: IDL.Func([IDL.Principal], [], []),
+        createOperatorInvite: IDL.Func([IDL.Text, OperatorPermissions], [IDL.Variant({ Ok: IDL.Text, Err: IDL.Text })], []),
+        revokeOperator: IDL.Func([IDL.Principal], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        listOperators: IDL.Func([], [IDL.Vec(OperatorRecord)], ['query']),
+        updateOperatorPermissions: IDL.Func([IDL.Principal, OperatorPermissions], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        setProtectedPaths: IDL.Func([IDL.Vec(IDL.Text)], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        getProtectedPaths: IDL.Func([], [IDL.Vec(IDL.Text)], ['query']),
+        writeMemory: IDL.Func([IDL.Text, IDL.Vec(IDL.Nat8)], [IDL.Variant({ Ok: IDL.Nat, Err: IDL.Text })], []),
+        deleteMemoryFile: IDL.Func([IDL.Text], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        rollbackMemory: IDL.Func([IDL.Text, IDL.Nat], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        registerOperator: IDL.Func([IDL.Text], [IDL.Variant({ Ok: OperatorRecord, Err: IDL.Text })], []),
+        readMemory: IDL.Func([IDL.Text], [IDL.Variant({ Ok: MemoryFile, Err: IDL.Text })], ['query']),
+        listMemoryFiles: IDL.Func([], [IDL.Vec(IDL.Record({ path: IDL.Text, version: IDL.Nat, lastModifiedAt: IDL.Int }))], ['query']),
+        appendMemory: IDL.Func([IDL.Text, IDL.Vec(IDL.Nat8)], [IDL.Variant({ Ok: IDL.Nat, Err: IDL.Text })], []),
+        readMemoryBatch: IDL.Func([IDL.Vec(IDL.Text)], [IDL.Vec(IDL.Tuple(IDL.Text, IDL.Variant({ Ok: MemoryFile, Err: IDL.Text })))], ['query']),
+        getMemoryHistory: IDL.Func([IDL.Text], [IDL.Vec(MemoryVersion)], ['query']),
+        walletBalance: IDL.Func([], [IDL.Variant({ Ok: IDL.Nat, Err: IDL.Text })], []),
+        readAuditLog: IDL.Func([IDL.Nat, IDL.Nat], [IDL.Vec(AuditEntry)], ['query']),
+        auditLogSize: IDL.Func([], [IDL.Nat], ['query']),
+        status: IDL.Func([], [
+            IDL.Record({
+                owner: IDL.Opt(IDL.Principal),
+                memoryFileCount: IDL.Nat,
+                auditLogSize: IDL.Nat,
+                operatorCount: IDL.Nat,
+                cyclesBalance: IDL.Nat,
+                version: IDL.Text,
+                guardianCount: IDL.Nat,
+                paymentsFrozen: IDL.Bool,
+                writesPaused: IDL.Bool,
+                backupCount: IDL.Nat,
+                totalBackupSize: IDL.Nat,
+            }),
+        ], ['query']),
+        wasmHash: IDL.Func([], [IDL.Text], ['query']),
+        addGuardian: IDL.Func([IDL.Principal, IDL.Text, GuardianPermissions], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        removeGuardian: IDL.Func([IDL.Principal], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        listGuardians: IDL.Func([], [IDL.Vec(GuardianRecord)], ['query']),
+        guardianRevokeOperator: IDL.Func([IDL.Principal], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        guardianFreezePayments: IDL.Func([], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        guardianPauseWrites: IDL.Func([], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        unfreezePayments: IDL.Func([], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        resumeWrites: IDL.Func([], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        rotateOperatorKey: IDL.Func([IDL.Text], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        // ic402: Payment Gateway
+        getPaymentRequirements: IDL.Func([IDL.Nat], [IDL.Vec(PaymentRequirement)], ['query']),
+        // ic402: Service Marketplace (minimal — full ServiceDefinition has nested
+        // types ServiceType/PricingScheme/etc. The decoder tolerates extra record
+        // fields, so a minimal {id, name, enabled} shape lets us read enough for
+        // most uses. The full IDL lives in src/generated/engram.idl.js for the
+        // dashboard's raw-IDL access.)
+        listServices: IDL.Func([], [IDL.Vec(IDL.Record({ id: IDL.Text, name: IDL.Text, enabled: IDL.Bool }))], ['query']),
+        // Owner/operator view: includes disabled service drafts.
+        listAllServices: IDL.Func([], [IDL.Vec(IDL.Record({ id: IDL.Text, name: IDL.Text, enabled: IDL.Bool }))], ['query']),
+        registerService: IDL.Func([
+            IDL.Text,
+            IDL.Text,
+            ServiceType,
+            PricingScheme,
+            IDL.Text,
+            IDL.Opt(IDL.Text),
+            IDL.Opt(IDL.Vec(IDL.Nat8)),
+            ServiceDeliveryMethod,
+            IDL.Nat,
+        ], [IDL.Variant({ ok: IDL.Text, err: IDL.Text })], []),
+        submitServiceRequest: IDL.Func([
+            IDL.Text,
+            IDL.Vec(IDL.Nat8),
+            IDL.Opt(PaymentSignature),
+            IDL.Opt(IDL.Text),
+            IDL.Opt(IDL.Text),
+        ], [
+            IDL.Variant({
+                ok: IDL.Record({ jobId: IDL.Text }),
+                error: IDL.Text,
+                paymentRequired: IDL.Vec(PaymentRequirement),
+                approvalPending: IDL.Record({ requestId: IDL.Text, reason: IDL.Text }),
+            }),
+        ], []),
+        claimJob: IDL.Func([IDL.Text], [IDL.Variant({ ok: IDL.Null, err: IDL.Text })], []),
+        submitJobResult: IDL.Func([IDL.Text, IDL.Vec(IDL.Nat8), IDL.Opt(IDL.Vec(IDL.Nat8)), IDL.Opt(IDL.Nat)], [IDL.Variant({ ok: IDL.Null, err: IDL.Text })], []),
+        confirmJob: IDL.Func([IDL.Text], [IDL.Variant({ ok: IDL.Null, err: IDL.Text })], []),
+        disputeJob: IDL.Func([IDL.Text, IDL.Text], [IDL.Variant({ ok: IDL.Null, err: IDL.Text })], []),
+        getJob: IDL.Func([IDL.Text], [IDL.Opt(Job)], ['query']),
+        getJobStatus: IDL.Func([IDL.Text], [IDL.Opt(JobStatus)], ['query']),
+        getJobResult: IDL.Func([IDL.Text], [IDL.Opt(IDL.Vec(IDL.Nat8))], ['query']),
+        keccak256: IDL.Func([IDL.Vec(IDL.Nat8)], [IDL.Vec(IDL.Nat8)], ['query']),
+        // ic402: Sessions
+        requestSession: IDL.Func([], [SessionIntent], []),
+        openSession: IDL.Func([SessionConfig, PaymentSignature, IDL.Opt(IDL.Text), IDL.Opt(IDL.Text)], [IDL.Variant({ ok: SessionState, err: IDL.Text, approvalPending: ApprovalRequest })], []),
+        sessionReadMemory: IDL.Func([Voucher, IDL.Text], [IDL.Variant({ ok: MemoryFile, error: IDL.Text })], []),
+        sessionAppendMemory: IDL.Func([Voucher, IDL.Text, IDL.Vec(IDL.Nat8)], [IDL.Variant({ ok: IDL.Nat, error: IDL.Text })], []),
+        endSession: IDL.Func([IDL.Text], [PaymentResult], []),
+        forceCloseSession: IDL.Func([IDL.Text], [PaymentResult], []),
+        // ic402: Content Store
+        uploadContent: IDL.Func([IDL.Text, IDL.Text, IDL.Vec(IDL.Nat8)], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        uploadContentInit: IDL.Func([IDL.Text, IDL.Text, IDL.Nat, IDL.Nat], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        uploadContentChunk: IDL.Func([IDL.Text, IDL.Nat, IDL.Vec(IDL.Nat8)], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        deleteContent: IDL.Func([IDL.Text], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        listContent: IDL.Func([], [IDL.Vec(ContentEntry)], ['query']),
+        getContent: IDL.Func([IDL.Text, IDL.Opt(PaymentSignature), IDL.Opt(IDL.Text), IDL.Opt(IDL.Text)], [
+            IDL.Variant({
+                paymentRequired: IDL.Vec(PaymentRequirement),
+                ok: ContentDelivery,
+                error: IDL.Text,
+                approvalPending: ApprovalRequest,
+            }),
+        ], []),
+        getChunk: IDL.Func([AccessGrant, IDL.Nat], [IDL.Opt(IDL.Vec(IDL.Nat8))], ['query']),
+        // EVM wallet management
+        setOwnerEvmAddress: IDL.Func([IDL.Text], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        getOwnerEvmAddress: IDL.Func([], [IDL.Opt(IDL.Text)], ['query']),
+        // ic402: ERC-8004 Identity
+        getAgentCard: IDL.Func([], [AgentCard], ['query']),
+        getAgentRegistrationId: IDL.Func([], [IDL.Opt(IDL.Nat)], ['query']),
+        getEvmAddress: IDL.Func([], [IDL.Text], []),
+        // ic402: Policy
+        setPaymentPolicy: IDL.Func([SpendingPolicy], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        setCallerPolicy: IDL.Func([IDL.Principal, SpendingPolicy], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        getPaymentPolicy: IDL.Func([], [SpendingPolicy], ['query']),
+        // ic402: Grants
+        verifyGrant: IDL.Func([AccessGrant], [AccessGrantResult], ['query']),
+        // ic402: Approval Management
+        listApprovalRequests: IDL.Func([IDL.Opt(ApprovalStatus)], [IDL.Vec(ApprovalRequest)], ['query']),
+        approveRequest: IDL.Func([IDL.Text], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        denyRequest: IDL.Func([IDL.Text, IDL.Text], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        setWorldIdProof: IDL.Func([WorldIdProof], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        getWorldIdProof: IDL.Func([], [IDL.Opt(WorldIdProof)], ['query']),
+        // ic402: Endpoint Registry
+        createEndpoint: IDL.Func([IDL.Text, IDL.Text, IDL.Variant({ Content: IDL.Null }), IDL.Opt(IDL.Text), IDL.Nat], [
+            IDL.Variant({
+                Ok: IDL.Record({
+                    id: IDL.Text,
+                    name: IDL.Text,
+                    description: IDL.Text,
+                    endpointType: IDL.Variant({ Content: IDL.Null }),
+                    contentId: IDL.Opt(IDL.Text),
+                    suggestedPrice: IDL.Nat,
+                    price: IDL.Nat,
+                    createdBy: IDL.Principal,
+                    createdAt: IDL.Int,
+                    status: IDL.Variant({ Disabled: IDL.Null, Enabled: IDL.Null, Deleted: IDL.Null }),
+                    enabledBy: IDL.Opt(IDL.Principal),
+                    enabledAt: IDL.Opt(IDL.Int),
+                    totalRevenue: IDL.Nat,
+                    totalPurchases: IDL.Nat,
+                }),
+                Err: IDL.Text,
+            }),
+        ], []),
+        enableEndpoint: IDL.Func([IDL.Text], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        disableEndpoint: IDL.Func([IDL.Text], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        deleteEndpoint: IDL.Func([IDL.Text], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        setEndpointPrice: IDL.Func([IDL.Text, IDL.Nat], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        listEndpoints: IDL.Func([IDL.Opt(IDL.Variant({ Disabled: IDL.Null, Enabled: IDL.Null, Deleted: IDL.Null }))], [
+            IDL.Vec(IDL.Record({
+                id: IDL.Text,
+                name: IDL.Text,
+                description: IDL.Text,
+                endpointType: IDL.Variant({ Content: IDL.Null }),
+                contentId: IDL.Opt(IDL.Text),
+                suggestedPrice: IDL.Nat,
+                price: IDL.Nat,
+                createdBy: IDL.Principal,
+                createdAt: IDL.Int,
+                status: IDL.Variant({ Disabled: IDL.Null, Enabled: IDL.Null, Deleted: IDL.Null }),
+                enabledBy: IDL.Opt(IDL.Principal),
+                enabledAt: IDL.Opt(IDL.Int),
+                totalRevenue: IDL.Nat,
+                totalPurchases: IDL.Nat,
+            })),
+        ], ['query']),
+        getEndpointPurchases: IDL.Func([IDL.Text, IDL.Nat, IDL.Nat], [
+            IDL.Vec(IDL.Record({
+                id: IDL.Text,
+                endpointId: IDL.Text,
+                buyer: IDL.Text,
+                amount: IDL.Nat,
+                network: IDL.Text,
+                timestamp: IDL.Int,
+                receiptId: IDL.Text,
+                txHash: IDL.Opt(IDL.Text),
+            })),
+        ], ['query']),
+        getRevenueSummary: IDL.Func([], [
+            IDL.Record({
+                totalRevenue: IDL.Nat,
+                totalPurchases: IDL.Nat,
+                endpointBreakdown: IDL.Vec(IDL.Record({
+                    endpointId: IDL.Text,
+                    name: IDL.Text,
+                    revenue: IDL.Nat,
+                    purchases: IDL.Nat,
+                })),
+            }),
+        ], ['query']),
+        // Backup
+        initBackup: IDL.Func([IDL.Text, BackupType, IDL.Opt(IDL.Text), IDL.Text, IDL.Opt(IDL.Text)], [IDL.Variant({ Ok: IDL.Text, Err: IDL.Text })], []),
+        pushBackupChunk: IDL.Func([IDL.Text, IDL.Nat, IDL.Vec(IDL.Nat8)], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        finalizeBackup: IDL.Func([IDL.Text], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        abortBackup: IDL.Func([IDL.Text], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        listBackups: IDL.Func([IDL.Opt(IDL.Text)], [IDL.Vec(BackupMetadata)], ['query']),
+        pullBackupChunk: IDL.Func([IDL.Text, IDL.Nat], [IDL.Variant({ Ok: IDL.Vec(IDL.Nat8), Err: IDL.Text })], ['query']),
+        getBackupMetadata: IDL.Func([IDL.Text], [IDL.Variant({ Ok: BackupMetadata, Err: IDL.Text })], ['query']),
+        deleteBackup: IDL.Func([IDL.Text], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        setBackupRetention: IDL.Func([IDL.Text, IDL.Nat], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+        storageStats: IDL.Func([], [
+            IDL.Record({
+                totalFiles: IDL.Nat,
+                totalContentSize: IDL.Nat,
+                memoryFilesSize: IDL.Nat,
+                memoryFilesCount: IDL.Nat,
+                sessionFilesSize: IDL.Nat,
+                sessionFilesCount: IDL.Nat,
+                versionHistorySize: IDL.Nat,
+                versionHistoryCount: IDL.Nat,
+                backupSize: IDL.Nat,
+                backupCount: IDL.Nat,
+                fileLimit: IDL.Nat,
+                auditLogSize: IDL.Nat,
+            }),
+        ], ['query']),
+        // Encryption (vetKeys): derive the shared memory-encryption key.
+        getEncryptedMemoryKey: IDL.Func([IDL.Vec(IDL.Nat8)], [IDL.Variant({ ok: IDL.Vec(IDL.Nat8), err: IDL.Text })], []),
+        getMemoryKeyVerificationKey: IDL.Func([], [IDL.Vec(IDL.Nat8)], []),
+        isEncryptionEnabled: IDL.Func([], [IDL.Bool], ['query']),
+        setEncryptionEnabled: IDL.Func([IDL.Bool], [IDL.Variant({ Ok: IDL.Null, Err: IDL.Text })], []),
+    });
+};
+// Minimal ICRC-2 ledger IDL for auto-payment approval
+const icrc2LedgerIdlFactory = ({ IDL }) => {
+    const Account = IDL.Record({ owner: IDL.Principal, subaccount: IDL.Opt(IDL.Vec(IDL.Nat8)) });
+    return IDL.Service({
+        icrc1_balance_of: IDL.Func([Account], [IDL.Nat], ['query']),
+        icrc2_approve: IDL.Func([
+            IDL.Record({
+                spender: Account,
+                amount: IDL.Nat,
+                fee: IDL.Opt(IDL.Nat),
+                memo: IDL.Opt(IDL.Vec(IDL.Nat8)),
+                from_subaccount: IDL.Opt(IDL.Vec(IDL.Nat8)),
+                created_at_time: IDL.Opt(IDL.Nat64),
+                expected_allowance: IDL.Opt(IDL.Nat),
+                expires_at: IDL.Opt(IDL.Nat64),
+            }),
+        ], [IDL.Variant({ Ok: IDL.Nat, Err: IDL.Record({ message: IDL.Text }) })], []),
+    });
+};
+export class EngramClient {
+    unwrap(result) {
+        if ('Err' in result)
+            throw new Error(result.Err);
+        if (!('Ok' in result))
+            throw new Error('Invalid canister response: missing Ok and Err');
+        return result.Ok;
+    }
+    constructor(config) {
+        this.encryptionModeSynced = false;
+        if (config.sessionKeyPath) {
+            this.identity = loadSessionKey(config.sessionKeyPath);
+        }
+        else if (config.sessionKeySeed) {
+            this.identity = identityFromSeed(config.sessionKeySeed);
+        }
+        else {
+            throw new Error('Either sessionKeyPath or sessionKeySeed must be provided');
+        }
+        this.canisterId = config.canisterId;
+        const host = config.host || 'https://ic0.app';
+        const isLocal = (() => {
+            try {
+                const hostname = new URL(host).hostname;
+                return hostname === 'localhost' || hostname === '127.0.0.1';
+            }
+            catch {
+                return false;
+            }
+        })();
+        this.agent = HttpAgent.createSync({
+            identity: this.identity,
+            host,
+            shouldFetchRootKey: isLocal,
+        });
+        this.actor = Actor.createActor(idlFactory, {
+            agent: this.agent,
+            canisterId: config.canisterId,
+        });
+        this.cache = new LRUCache(config.cacheMaxSize ?? 100, config.cacheMaxAge ?? 60000);
+        this.encryption = new EncryptionManager(config.encryptMemory ?? false);
+        // If the caller didn't force a mode, sync it from the canister's flag lazily.
+        this.encryptionModeSynced = config.encryptMemory !== undefined;
+        if (config.offlineQueuePath) {
+            this.offlineQueue = new OfflineQueue(config.offlineQueuePath);
+        }
+    }
+    async readMemory(path) {
+        validateMemoryPath(path);
+        const cached = this.cache.get(`mem:${path}`);
+        if (cached)
+            return cached;
+        const raw = this.unwrap(await this.actor.readMemory(path));
+        const decrypted = await this.encryption.decrypt(this.actor, new Uint8Array(raw.content));
+        const file = {
+            path: raw.path,
+            content: decrypted,
+            version: raw.version,
+            lastModifiedBy: raw.lastModifiedBy,
+            lastModifiedAt: raw.lastModifiedAt,
+        };
+        this.cache.set(`mem:${path}`, file);
+        return file;
+    }
+    async appendMemory(path, content) {
+        validateMemoryPath(path);
+        try {
+            // Client-side read-modify-write: read → decrypt → append → encrypt → write
+            let existing = '';
+            try {
+                const file = await this.readMemory(path);
+                existing = file.content;
+            }
+            catch {
+                // File doesn't exist yet — start fresh
+            }
+            const newContent = existing ? `${existing}\n${content}` : content;
+            await this.ensureEncryptionMode();
+            const ciphertext = await this.encryption.encrypt(this.actor, newContent);
+            const version = this.unwrap(await this.actor.appendMemory(path, ciphertext));
+            this.cache.invalidate(`mem:${path}`);
+            return version;
+        }
+        catch (err) {
+            if (this.offlineQueue) {
+                this.offlineQueue.enqueue('appendMemory', [path, content]);
+                return BigInt(0);
+            }
+            throw err;
+        }
+    }
+    async listMemoryFiles() {
+        return await this.actor.listMemoryFiles();
+    }
+    async readMemoryBatch(paths) {
+        for (const p of paths)
+            validateMemoryPath(p);
+        const result = await this.actor.readMemoryBatch(paths);
+        return await Promise.all(result.map(async ([p, r]) => {
+            if ('Err' in r)
+                return [p, new Error(r.Err)];
+            const raw = r.Ok;
+            try {
+                const decrypted = await this.encryption.decrypt(this.actor, new Uint8Array(raw.content));
+                const file = {
+                    path: raw.path,
+                    content: decrypted,
+                    version: raw.version,
+                    lastModifiedBy: raw.lastModifiedBy,
+                    lastModifiedAt: raw.lastModifiedAt,
+                };
+                return [p, file];
+            }
+            catch (err) {
+                return [p, err instanceof Error ? err : new Error(String(err))];
+            }
+        }));
+    }
+    async getMemoryHistory(path) {
+        const rawVersions = await this.actor.getMemoryHistory(path);
+        return await Promise.all(rawVersions.map(async (raw) => ({
+            version: raw.version,
+            modifiedBy: raw.modifiedBy,
+            modifiedAt: raw.modifiedAt,
+            operation: raw.operation,
+            contentSnapshot: await this.encryption.decrypt(this.actor, new Uint8Array(raw.contentSnapshot)),
+        })));
+    }
+    // writeMemory removed: owner-only by design. The @engramx/client SDK runs on
+    // operator-credentialed agent hosts where this would always fail. Owner uses
+    // the dashboard at engramx.ai or the canister IDL via Internet Identity.
+    async walletBalance() {
+        return this.unwrap(await this.actor.walletBalance());
+    }
+    async readAuditLog(fromIndex = 0, limit = 50) {
+        return await this.actor.readAuditLog(BigInt(fromIndex), BigInt(limit));
+    }
+    async auditLogSize() {
+        return await this.actor.auditLogSize();
+    }
+    async status() {
+        // Canister returns a record directly; do not destructure as array.
+        return await this.actor.status();
+    }
+    // addGuardian, removeGuardian removed: owner-only.
+    // setWorldIdProof removed: owner-only.
+    async listGuardians() {
+        return await this.actor.listGuardians();
+    }
+    async rotateOperatorKey(newPublicKeyHash) {
+        this.unwrap(await this.actor.rotateOperatorKey(newPublicKeyHash));
+    }
+    async getWorldIdProof() {
+        const result = await this.actor.getWorldIdProof();
+        return result.length > 0 ? result[0] : null;
+    }
+    // === ic402 Payment Gateway ===
+    async getPaymentRequirements(amount) {
+        return await this.actor.getPaymentRequirements(amount);
+    }
+    // === ic402 Sessions ===
+    async requestSession() {
+        return await this.actor.requestSession();
+    }
+    async openSession(config, sig, rationale, approvalId) {
+        const result = await this.actor.openSession(config, sig, rationale ? [rationale] : [], approvalId ? [approvalId] : []);
+        if ('err' in result)
+            throw new Error(result.err);
+        if ('approvalPending' in result)
+            return { approvalPending: result.approvalPending };
+        return result.ok;
+    }
+    async sessionReadMemory(voucher, path) {
+        const result = await this.actor.sessionReadMemory(voucher, path);
+        if ('error' in result)
+            throw new Error(result.error);
+        return result.ok;
+    }
+    async sessionAppendMemory(voucher, path, content) {
+        const result = await this.actor.sessionAppendMemory(voucher, path, content);
+        if ('error' in result)
+            throw new Error(result.error);
+        return result.ok;
+    }
+    async endSession(sessionId) {
+        return await this.actor.endSession(sessionId);
+    }
+    async forceCloseSession(sessionId) {
+        return await this.actor.forceCloseSession(sessionId);
+    }
+    // === ic402 Content Store ===
+    async uploadContent(id, mimeType, data) {
+        this.unwrap(await this.actor.uploadContent(id, mimeType, data));
+    }
+    async listContent() {
+        return await this.actor.listContent();
+    }
+    async getContent(contentId, paymentSig, rationale, approvalId) {
+        const result = await this.actor.getContent(contentId, paymentSig ? [paymentSig] : [], rationale ? [rationale] : [], approvalId ? [approvalId] : []);
+        if ('paymentRequired' in result)
+            return { paymentRequired: result.paymentRequired };
+        if ('ok' in result)
+            return { delivery: result.ok };
+        if ('approvalPending' in result)
+            return { approvalPending: result.approvalPending };
+        return { error: result.error };
+    }
+    async deleteContent(id) {
+        this.unwrap(await this.actor.deleteContent(id));
+    }
+    // === ic402 Endpoint Registry ===
+    async createEndpoint(name, description, endpointType, contentId, suggestedPrice) {
+        const result = await this.actor.createEndpoint(name, description, endpointType, contentId ? [contentId] : [], suggestedPrice);
+        if ('Err' in result)
+            throw new Error(result.Err);
+        return result.Ok;
+    }
+    // enableEndpoint, disableEndpoint, deleteEndpoint, setEndpointPrice removed:
+    // owner-only. Operators create endpoints (disabled); the owner enables and
+    // adjusts pricing via the dashboard.
+    async listEndpoints(statusFilter) {
+        return this.actor.listEndpoints(statusFilter ? [statusFilter] : []);
+    }
+    async getEndpointPurchases(endpointId, fromIndex, limit) {
+        return this.actor.getEndpointPurchases(endpointId, fromIndex, limit);
+    }
+    async getRevenueSummary() {
+        return this.actor.getRevenueSummary();
+    }
+    // === ic402 Policy (read-only on operator hosts) ===
+    // setPaymentPolicy, setCallerPolicy removed: owner-only.
+    async getPaymentPolicy() {
+        return await this.actor.getPaymentPolicy();
+    }
+    // listApprovalRequests, approveRequest, denyRequest removed: owner-only.
+    // The dashboard surfaces the approval queue for the owner.
+    // === ic402 ERC-8004 Agent Identity ===
+    async getAgentCard() {
+        return await this.actor.getAgentCard();
+    }
+    async getEvmAddress() {
+        return await this.actor.getEvmAddress();
+    }
+    // === EVM Wallet Management (read-only on operator hosts) ===
+    // setOwnerEvmAddress removed: owner-only.
+    async getOwnerEvmAddress() {
+        const result = await this.actor.getOwnerEvmAddress();
+        return result.length > 0 ? result[0] : null;
+    }
+    async initBackup(dbType, backupType, parentBackupId, sha256, backupLabel) {
+        return this.unwrap(await this.actor.initBackup(dbType, backupType, parentBackupId ? [parentBackupId] : [], sha256, backupLabel ? [backupLabel] : []));
+    }
+    async pushBackupChunk(backupId, chunkIndex, data) {
+        this.unwrap(await this.actor.pushBackupChunk(backupId, BigInt(chunkIndex), data));
+    }
+    async finalizeBackup(backupId) {
+        this.unwrap(await this.actor.finalizeBackup(backupId));
+    }
+    async abortBackup(backupId) {
+        this.unwrap(await this.actor.abortBackup(backupId));
+    }
+    async listBackups(dbTypeFilter) {
+        return await this.actor.listBackups(dbTypeFilter ? [dbTypeFilter] : []);
+    }
+    async pullBackupChunk(backupId, chunkIndex) {
+        return this.unwrap(await this.actor.pullBackupChunk(backupId, BigInt(chunkIndex)));
+    }
+    async getBackupMetadata(backupId) {
+        return this.unwrap(await this.actor.getBackupMetadata(backupId));
+    }
+    async deleteBackup(backupId) {
+        this.unwrap(await this.actor.deleteBackup(backupId));
+    }
+    // setBackupRetention removed: owner-only.
+    async latestBackupMatchesHash(dbType, sha256) {
+        const backups = await this.listBackups(dbType);
+        const finalized = backups
+            .filter((b) => 'Finalized' in b.status)
+            .sort((a, b) => Number(b.createdAt) - Number(a.createdAt));
+        const latest = finalized[0];
+        if (!latest)
+            return null;
+        return latest.sha256 === sha256 ? latest : null;
+    }
+    async storageStats() {
+        return await this.actor.storageStats();
+    }
+    /** Warm the vetKeys memory-encryption key cache (one vetKD derivation). Optional —
+     *  read/append derive lazily on first use. */
+    async initEncryption() {
+        await this.encryption.prepare(this.actor);
+    }
+    clearEncryptionCache() {
+        this.encryption.clearCache();
+    }
+    /** Sync the write-time encryption mode from the canister flag (once, cached),
+     *  unless an explicit `encryptMemory` was given at construction. */
+    async ensureEncryptionMode() {
+        if (this.encryptionModeSynced)
+            return;
+        const enabled = await this.actor.isEncryptionEnabled();
+        this.encryption.setEnabled(enabled);
+        this.encryptionModeSynced = true;
+    }
+    /** Whether this engram has memory encryption enabled (reads the canister flag). */
+    async isMemoryEncryptionEnabled() {
+        return await this.actor.isEncryptionEnabled();
+    }
+    /** Owner-only: turn memory encryption on/off on the canister. Updates the local
+     *  write mode immediately. Turning ON does not re-encrypt existing files — call
+     *  migrateMemoryToEncrypted() for that. */
+    async setMemoryEncryption(enabled) {
+        this.unwrap(await this.actor.setEncryptionEnabled(enabled));
+        this.encryption.setEnabled(enabled);
+        this.encryptionModeSynced = true;
+    }
+    /** Owner-only: re-encrypt all existing memory files under the current key. Reads
+     *  each file (decrypting any that are already encrypted), then rewrites it via
+     *  writeMemory so it is stored as ciphertext. Idempotent and resumable — files
+     *  already encrypted are simply re-written identically. Requires encryption to be
+     *  enabled (canister flag) and an owner identity (writeMemory is owner-only). */
+    async migrateMemoryToEncrypted() {
+        await this.ensureEncryptionMode();
+        if (!this.encryption.isEnabled()) {
+            throw new Error('Enable encryption first (setMemoryEncryption(true)) before migrating');
+        }
+        const files = await this.listMemoryFiles();
+        const failed = [];
+        let migrated = 0;
+        for (const info of files) {
+            try {
+                // Byte-exact: read the RAW stored bytes (not the string read API) so binary /
+                // non-UTF-8 content is never corrupted by a TextDecoder round-trip.
+                const raw = this.unwrap(await this.actor.readMemory(info.path));
+                const bytes = new Uint8Array(raw.content);
+                if (this.encryption.isEncrypted(bytes)) {
+                    migrated += 1; // already encrypted — idempotent skip
+                    continue;
+                }
+                const ciphertext = await this.encryption.encryptBytes(this.actor, bytes);
+                this.unwrap(await this.actor.writeMemory(info.path, ciphertext));
+                this.cache.invalidate(`mem:${info.path}`);
+                migrated += 1;
+            }
+            catch (err) {
+                failed.push(`${info.path}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        return { migrated, total: files.length, failed };
+    }
+    async syncOfflineQueue() {
+        if (!this.offlineQueue)
+            return { synced: 0, failed: 0 };
+        return this.offlineQueue.flush(async (method, args) => {
+            if (!ALLOWED_OFFLINE_METHODS.has(method)) {
+                console.error(`engramx: offline queue contains unknown method "${method}" — operation dropped`);
+                return;
+            }
+            const fn = this.actor[method];
+            if (!fn)
+                throw new Error(`Unknown method: ${method}`);
+            const result = await fn(...args);
+            if (result && typeof result === 'object' && 'Err' in result) {
+                throw new Error(result.Err);
+            }
+        });
+    }
+    async registerOperator(inviteCode) {
+        return this.unwrap(await this.actor.registerOperator(inviteCode));
+    }
+    // setProtectedPaths removed: owner-only.
+    async getProtectedPaths() {
+        return await this.actor.getProtectedPaths();
+    }
+    // === ic402 Payment Client Integration ===
+    /**
+     * Create a pre-configured Ic402Client for auto-payment operations.
+     * The client handles 402 → ICRC-2 approve → retry automatically.
+     */
+    createPaymentClient(options) {
+        return new Ic402Client({
+            canisterId: this.canisterId,
+            actorFactory: (id) => Actor.createActor(idlFactory, { agent: this.agent, canisterId: id }),
+            identity: this.identity,
+            network: 'icp:1',
+            autoPayment: options?.autoPayment ?? true,
+            ledger: options?.ledger || 'xevnm-gaaaa-aaaar-qafnq-cai', // ckUSDC mainnet
+            ledgerActorFactory: (ledgerId) => Actor.createActor(icrc2LedgerIdlFactory, { agent: this.agent, canisterId: ledgerId }),
+        });
+    }
+    /**
+     * Auto-pay bridge for the engramx x402 methods. The stock ic402 client injects the
+     * payment signature into the LAST argument, but the engramx canister appends
+     * `rationale` + `approvalId` AFTER `paymentSig` (for the owner approval workflow), so the
+     * signature must land at a FIXED index, not last. Flow: call with no sig → on
+     * #paymentRequired, icrc2_approve the amount (+ fee buffer) → build the ICP payment
+     * signature (a nonce-carrier; the real authorization is the ICRC-2 allowance the canister
+     * spends via transfer_from) → retry with the sig at `sigIndex`. Returns the raw canister
+     * result; the caller unwraps ok/error/approvalPending.
+     */
+    async payAndCall(method, baseArgs, sigIndex, options) {
+        const actor = this.actor;
+        const first = (await actor[method](...baseArgs));
+        if (!first || typeof first !== 'object' || !('paymentRequired' in first)) {
+            return first;
+        }
+        const reqs = first['paymentRequired'];
+        const requirement = Array.isArray(reqs)
+            ? reqs[0]
+            : reqs;
+        if (!requirement)
+            throw new Error('Malformed paymentRequired response');
+        const ledger = options?.ledger || 'xevnm-gaaaa-aaaar-qafnq-cai'; // ckUSDC mainnet
+        const ledgerActor = Actor.createActor(icrc2LedgerIdlFactory, {
+            agent: this.agent,
+            canisterId: ledger,
+        });
+        const buffer = options?.approvalFeeBuffer ?? 100000n;
+        const approve = await ledgerActor.icrc2_approve({
+            spender: { owner: Principal.fromText(this.canisterId), subaccount: [] },
+            amount: BigInt(requirement['amount']) + buffer,
+            fee: [],
+            memo: [],
+            from_subaccount: [],
+            created_at_time: [],
+            expected_allowance: [],
+            expires_at: [],
+        });
+        if (approve && typeof approve === 'object' && 'Err' in approve) {
+            throw new Error(`ICRC-2 approve failed: ${JSON.stringify(approve.Err, (_k, v) => (typeof v === 'bigint' ? v.toString() : v))}`);
+        }
+        // Candid may decode `vec nat8` as Uint8Array | number[] | indexed object — normalize.
+        const rawNonce = (requirement['nonce'] ?? new Uint8Array(32));
+        const nonce = rawNonce instanceof Uint8Array
+            ? Array.from(rawNonce)
+            : Array.isArray(rawNonce)
+                ? rawNonce
+                : Object.values(rawNonce);
+        const sig = {
+            scheme: 'exact',
+            network: 'icp:1',
+            signature: nonce,
+            asset: [], // ic402 2.5.3: optional asset hint (unused on the ICP rail)
+            publicKey: [],
+            sender: this.identity.getPrincipal().toText(),
+            nonce,
+            authorization: [],
+        };
+        const retryArgs = [...baseArgs];
+        retryArgs[sigIndex] = [sig];
+        return (await actor[method](...retryArgs));
+    }
+    /**
+     * Get paid content with auto-payment. Handles #paymentRequired → approve → retry.
+     * @param contentId Content identifier
+     * @param options Optional ledger override
+     */
+    async getContentWithPayment(contentId, options) {
+        const result = await this.payAndCall('getContent', [contentId, [], [], []], 1, options);
+        if ('ok' in result)
+            return result['ok'];
+        if ('error' in result)
+            throw new Error(String(result['error']));
+        if ('approvalPending' in result) {
+            const ap = result['approvalPending'];
+            throw new Error(`Owner approval required: ${ap.reason ?? ''}`);
+        }
+        throw new Error('Payment required (auto-payment did not settle)');
+    }
+    /**
+     * Open a streaming payment session with auto-escrow and voucher signing.
+     * Returns a SessionHandle that auto-signs vouchers on each call.
+     *
+     * Usage:
+     *   const session = await engram.openPaymentSession({ maxDeposit: 50_000n });
+     *   const file = await session.call('sessionReadMemory', ['SOUL.md']);
+     *   const receipt = await session.close();
+     */
+    async openPaymentSession(options) {
+        const client = this.createPaymentClient({
+            ledger: options?.ledger,
+        });
+        return await client.openSession({
+            maxDeposit: options?.maxDeposit,
+            autoClose: options?.autoClose ?? true,
+        }, {
+            sign: (payload) => this.identity.sign(payload),
+            getPublicKey: async () => new Uint8Array(this.identity.getPublicKey().toRaw()),
+        });
+    }
+    // === ic402 Service Marketplace ===
+    async registerService(name, description, serviceType, pricing, verificationMethod, delivery, timeout, verifierCanisterId, verificationKey) {
+        const result = await this.actor.registerService(name, description, serviceType, pricing, verificationMethod, verifierCanisterId ? [verifierCanisterId] : [], verificationKey ? [verificationKey] : [], delivery, timeout);
+        if ('err' in result)
+            throw new Error(result.err);
+        return result.ok;
+    }
+    // enableService, disableService removed: owner-only. Operators register
+    // services (disabled); owner enables them via the dashboard.
+    async listServices() {
+        return await this.actor.listServices();
+    }
+    /** Owner/operator view — includes disabled service drafts (others get enabled-only). */
+    async listAllServices() {
+        return await this.actor.listAllServices();
+    }
+    async submitServiceRequest(serviceId, params, paymentSig, rationale, approvalId) {
+        const result = await this.actor.submitServiceRequest(serviceId, params, paymentSig ? [paymentSig] : [], rationale ? [rationale] : [], approvalId ? [approvalId] : []);
+        if ('error' in result)
+            throw new Error(result.error);
+        if ('paymentRequired' in result)
+            throw new Error('Payment required');
+        if ('approvalPending' in result)
+            return { approvalPending: result.approvalPending };
+        return { jobId: result.ok.jobId };
+    }
+    /**
+     * Submit a paid service request with auto-payment (the marketplace counterpart of
+     * getContentWithPayment). Handles #paymentRequired → approve → retry, injecting the
+     * signature at the correct index for the engramx submitServiceRequest signature
+     * (serviceId, params, paymentSig, rationale, approvalId). Returns the jobId, or an
+     * approval-pending handle when the charge exceeds policy and the owner must approve.
+     */
+    async submitServiceRequestWithPayment(serviceId, params, options) {
+        const rationale = options?.rationale ? [options.rationale] : [];
+        const result = await this.payAndCall('submitServiceRequest', [serviceId, params, [], rationale, []], 2, options);
+        if ('ok' in result)
+            return { jobId: result['ok'].jobId };
+        if ('approvalPending' in result)
+            return { approvalPending: result['approvalPending'] };
+        if ('error' in result)
+            throw new Error(String(result['error']));
+        if ('paymentRequired' in result) {
+            throw new Error('Payment required (auto-payment did not settle)');
+        }
+        throw new Error('Unexpected submitServiceRequest result');
+    }
+    async claimJob(jobId) {
+        const result = await this.actor.claimJob(jobId);
+        if ('err' in result)
+            throw new Error(result.err);
+    }
+    async submitJobResult(jobId, result, proof, actualCost) {
+        const r = await this.actor.submitJobResult(jobId, result, proof ? [proof] : [], actualCost ? [actualCost] : []);
+        if ('err' in r)
+            throw new Error(r.err);
+    }
+    async confirmJob(jobId) {
+        const result = await this.actor.confirmJob(jobId);
+        if ('err' in result)
+            throw new Error(result.err);
+    }
+    async disputeJob(jobId, reason) {
+        const result = await this.actor.disputeJob(jobId, reason);
+        if ('err' in result)
+            throw new Error(result.err);
+    }
+    async getJobStatus(jobId) {
+        const result = await this.actor.getJobStatus(jobId);
+        return result.length > 0 ? result[0] : null;
+    }
+    async getJob(jobId) {
+        const result = await this.actor.getJob(jobId);
+        return result.length > 0 ? result[0] : null;
+    }
+    async getJobResult(jobId) {
+        const result = await this.actor.getJobResult(jobId);
+        return result.length > 0 ? new Uint8Array(result[0]) : null;
+    }
+    async pollJobResult(jobId, maxAttempts = 30, intervalMs = 2000) {
+        for (let i = 0; i < maxAttempts; i++) {
+            const job = await this.getJob(jobId);
+            if (!job)
+                throw new Error('Job not found');
+            const jobObj = job;
+            const status = jobObj['status'];
+            if (status &&
+                typeof status === 'object' &&
+                ('Settled' in status ||
+                    'Verified' in status ||
+                    'Refunded' in status ||
+                    'Expired' in status ||
+                    'Disputed' in status)) {
+                return job;
+            }
+            await new Promise((resolve) => setTimeout(resolve, intervalMs));
+        }
+        throw new Error('Job did not reach terminal status');
+    }
+    // === ic402 EIP-712 Signing ===
+    // signTypedData removed: owner-only. Cryptographic agent-identity signing is
+    // a value-bearing operation that operators must not perform.
+    async keccak256(data) {
+        return await this.actor.keccak256(data);
+    }
+    clearCache() {
+        this.cache.clear();
+    }
+    getPrincipal() {
+        return this.identity.getPrincipal();
+    }
+}
+//# sourceMappingURL=EngramClient.js.map