example.did

type Voucher = 
 record {
   cumulativeAmount: nat;
   sequence: nat;
   sessionId: text;
   signature: blob;
 };
type VerificationMethod = 
 variant {
   AutoSettle;
   BuyerConfirm: record {disputeWindowSeconds: nat;};
   HashMatch;
   ZkGroth16:
    record {
      bindResult: bool;
      verificationKey: blob;
      verifierCanister: principal;
    };
 };
type SpendingPolicy = 
 record {
   allowedCallers: opt vec principal;
   blockedCallers: opt vec principal;
   maxConcurrentSessions: opt nat;
   maxPerDay: opt nat;
   maxPerTransaction: opt nat;
   maxSessionDeposit: opt nat;
   maxSessionDuration: opt int;
   rateLimitPerMinute: opt nat;
   sessionIdleTimeout: opt int;
 };
type SignedTypedData = 
 record {
   digest: text;
   r: text;
   s: text;
   signature: text;
   signer: text;
   v: nat8;
 };
type SignedTransaction = 
 record {
   rawTx: text;
   txHash: text;
 };
type SignedAuthorization = 
 record {
   authorization:
    record {
      from: text;
      nonce: text;
      signature: text;
      to: text;
      validAfter: nat;
      validBefore: nat;
      value: nat;
    };
   header: text;
   paidAmount: nat;
 };
type SessionStatus = 
 variant {
   closed;
   closing;
   expired;
   open;
 };
type SessionState = 
 record {
   consumed: nat;
   deposited: nat;
   id: text;
   lastActivityAt: int;
   openedAt: int;
   payer: principal;
   remaining: nat;
   status: SessionStatus;
   voucherCount: nat;
 };
type SessionIntent = 
 record {
   costPerCall: opt nat;
   description: opt text;
   expiry: int;
   minDeposit: opt nat;
   network: text;
   recipient: text;
   suggestedDeposit: nat;
   token: text;
 };
type SessionConfig = 
 record {
   autoClose: bool;
   idleTimeout: opt int;
   maxDeposit: nat;
 };
type ServiceType = 
 variant {
   Async;
   Sync;
 };
type ServiceEntry = 
 record {
   domains: vec text;
   endpoint: text;
   name: text;
   skills: vec text;
   version: text;
 };
type ServiceDeliveryMethod = 
 variant {
   Both;
   Callback;
   Poll;
 };
type ServiceDefinition = 
 record {
   createdAt: int;
   delivery: ServiceDeliveryMethod;
   description: text;
   enabled: bool;
   id: text;
   name: text;
   operatorId: principal;
   pricing: PricingScheme;
   serviceType: ServiceType;
   timeout: nat;
   verification: VerificationMethod;
 };
type PricingScheme = 
 variant {
   Exact: nat;
   Session;
   Upto: nat;
 };
type PaymentSignature = 
 record {
   asset: opt text;
   authorization: opt Eip3009Authorization;
   network: text;
   nonce: blob;
   publicKey: opt blob;
   scheme: text;
   sender: text;
   signature: blob;
 };
type PaymentResult = 
 variant {
   depositBelowMinimum: nat;
   expired: text;
   insufficientFunds: text;
   invalidSignature: text;
   networkNotSupported: text;
   ok: PaymentReceipt;
   policyDenied: text;
   reputationTooLow: nat;
   settlementFailed: text;
   settlementPending: text;
   tokenNotAccepted: text;
 };
type PaymentRequirement = 
 record {
   amount: nat;
   expiry: int;
   network: text;
   nonce: blob;
   recipient: text;
   scheme: text;
   token: text;
   tokenName: opt text;
   tokenVersion: opt text;
 };
type PaymentReceipt = 
 record {
   amount: nat;
   id: text;
   network: text;
   recipient: text;
   refunded: opt nat;
   sender: text;
   sessionId: opt text;
   timestamp: int;
   token: text;
   txHash: opt text;
 };
type ParkedTx = 
 record {
   chainId: nat;
   leg: ParkedLeg;
   parkedAt: int;
   token: text;
   txHash: text;
 };
type ParkedLeg = 
 variant {
   Refund;
   Settle;
   UptoRemainder;
 };
type JobStatus = 
 variant {
   Assigned;
   Computing;
   Disputed;
   Expired;
   Pending;
   Refunded;
   Settled;
   Settling;
   Submitted;
   Verified;
 };
type Job = 
 record {
   actualCost: opt nat;
   amount: nat;
   buyer: text;
   completedAt: opt int;
   createdAt: int;
   deliveryCallback: opt text;
   expiresAt: int;
   id: text;
   operator: opt principal;
   params: blob;
   parkedTx: opt ParkedTx;
   paymentReceiptId: text;
   proof: opt blob;
   result: opt blob;
   serviceId: text;
   status: JobStatus;
 };
type HttpResponse = 
 record {
   body: blob;
   headers: vec record {
                  text;
                  text;
                };
   status_code: nat16;
   upgrade: opt bool;
 };
type HttpRequest = 
 record {
   body: blob;
   headers: vec record {
                  text;
                  text;
                };
   method: text;
   url: text;
 };
type Eip3009Authorization = 
 record {
   from: text;
   nonce: blob;
   r: blob;
   s: blob;
   to: text;
   v: nat8;
   validAfter: nat;
   validBefore: nat;
   value: nat;
 };
type DeliveryMethod = 
 variant {
   assetCanister: record {
                    canisterId: principal;
                    path: text;
                  };
   canisterQuery: record {
                    chunkCount: nat;
                    method: text;
                  };
   httpUrl: text;
   inline: blob;
 };
type ContentStoreResult = 
 variant {
   chunkNotFound: nat;
   chunkTooLarge: nat;
   contentAlreadyExists;
   contentNotFound;
   ok;
 };
type ContentRef = 
 record {
   id: text;
   metadata: opt vec record {
                       text;
                       text;
                     };
   mimeType: opt text;
   sizeBytes: opt nat;
 };
type ContentEntry = 
 record {
   chunkCount: nat;
   createdAt: int;
   id: text;
   mimeType: text;
   totalSize: nat;
 };
type ContentDelivery = 
 record {
   delivery: DeliveryMethod;
   grant: AccessGrant;
   settlementTxHash: opt text;
 };
type AgentCard = 
 record {
   description: text;
   name: text;
   services: vec ServiceEntry;
   x402Support: bool;
 };
type AccessGrantResult = 
 variant {
   expired: text;
   invalidGrant: text;
   ok;
   revoked: text;
 };
type AccessGrant = 
 record {
   contentRef: ContentRef;
   expiresAt: int;
   grantId: text;
   grantee: principal;
   hmac: blob;
   issuedAt: int;
   receiptId: text;
 };
/// ic402 Example Canister
/// 
/// Demonstrates a paid knowledge base API with multiple optional features.
/// The required core is small — everything marked OPTIONAL can be removed.
/// 
/// Structure:
///   1. REQUIRED: Gateway + paid endpoint + HTTP 402 serving
///   2. OPTIONAL: Streaming sessions (escrow + vouchers)
///   3. OPTIONAL: Encrypted content store (in-canister)
///   4. OPTIONAL: EVM remote signer (canister signs, client broadcasts)
///   5. OPTIONAL: ERC-8004 identity metadata
service : {
  claimJob: (jobId: text) -> (variant {
                                err: text;
                                ok;
                              });
  confirmJob: (jobId: text) -> (variant {
                                  err: text;
                                  ok;
                                });
  deleteContent: (id: text) -> (ContentStoreResult);
  disableService: (id: text) -> (variant {
                                   err: text;
                                   ok;
                                 });
  disputeJob: (jobId: text, reason: text) -> (variant {
                                                err: text;
                                                ok;
                                              });
  enableService: (id: text) -> (variant {
                                  err: text;
                                  ok;
                                });
  endSession: (sessionId: text) -> (PaymentResult);
  forceCloseSession: (sessionId: text) -> (PaymentResult);
  forceResolveSession: (sessionId: text) -> (variant {
                                               err: text;
                                               ok;
                                             });
  getAgentCard: () -> (AgentCard) query;
  getAgentId: () -> (opt nat) query;
  getChunk: (grant: AccessGrant, index: nat) -> (opt blob) query;
  getContent: (contentId: text, paymentSig: opt PaymentSignature) ->
   (variant {
      error: text;
      ok: ContentDelivery;
      paymentRequired: vec PaymentRequirement;
    });
  getEvmAddress: () -> (text);
  getEvmDrainMode: () -> (bool) query;
  getEvmPublicKey: () -> (blob);
  getJob: (jobId: text) -> (opt Job) query;
  getJobResult: (jobId: text) -> (opt blob) query;
  getJobStatus: (jobId: text) -> (opt JobStatus) query;
  getPolicyConfig: () -> (SpendingPolicy) query;
  health: () ->
   (record {
      cyclesBalance: nat;
      jobs:
       record {
         active: nat;
         expired: nat;
         parked: nat;
         refunded: nat;
         settled: nat;
         settling: nat;
         total: nat;
       };
      sessions:
       record {
         closed: nat;
         closing: nat;
         expired: nat;
         open: nat;
         total: nat;
       };
    }) query;
  http_request: (request: HttpRequest) -> (HttpResponse) query;
  http_request_update: (request: HttpRequest) -> (HttpResponse);
  /// Helper: compute keccak256 hash of a byte array. Useful for building type hashes.
  keccak256: (data: vec nat8) -> (vec nat8) query;
  listContent: () -> (vec ContentEntry) query;
  listJobs: (serviceId: text, statusFilter: opt JobStatus) -> (vec Job) query;
  listPendingEvmDeposits: () ->
   (vec
     record {
       amount: nat;
       chainId: nat;
       createdAt: int;
       payer: principal;
       payerEvmAddress: text;
       token: text;
       txHash: text;
     }) query;
  listServices: () -> (vec ServiceDefinition) query;
  openSession: (config: SessionConfig, sig: PaymentSignature) ->
   (variant {
      err: text;
      ok: SessionState;
    });
  pendingEvmDepositCount: () -> (nat) query;
  quoteServiceRequest: (serviceId: text) ->
   (variant {
      err: text;
      ok:
       record {
         amount: nat;
         enabled: bool;
         fee: nat;
         pricingKind: text;
         total: nat;
       };
    }) query;
  reconcileEvmDeposit: (txHash: text) ->
   (variant {
      err: text;
      notFound;
      refunded: text;
      reverted;
      stillPending;
    });
  reconcileJob: (jobId: text) -> (variant {
                                    err: text;
                                    ok: text;
                                  });
  reconcileSession: (sessionId: text) -> (variant {
                                            err: text;
                                            ok: text;
                                          });
  registerService: (name: text, description: text, serviceType: ServiceType,
   pricing: PricingScheme, verificationMethod: text, verifierCanisterId:
   opt text, verificationKey: opt blob, delivery: ServiceDeliveryMethod,
   timeout: nat) -> (variant {
                       err: text;
                       ok: text;
                     });
  requestSession: () -> (SessionIntent);
  resolveJob: (jobId: text, terminal: JobStatus) -> (variant {
                                                       err: text;
                                                       ok;
                                                     });
  search: (searchQuery: text, paymentSig: opt PaymentSignature) ->
   (variant {
      error: text;
      ok: vec text;
      paymentRequired: vec PaymentRequirement;
    });
  sessionQuery: (voucher: Voucher, question: text) ->
   (variant {
      error: text;
      ok: text;
    });
  setEvmDrainMode: (on: bool) -> ();
  setEvmPayout: (address: text) -> (variant {
                                      err: text;
                                      ok;
                                    });
  setPolicy: (p: SpendingPolicy) -> ();
  /// Sign an ERC-8004 agent registration tx.
  /// Client provides nonce + gas from their RPC, broadcasts + polls receipt.
  signAgentRegistration: (nonce: nat, maxFeePerGas: nat,
   maxPriorityFeePerGas: nat) -> (variant {
                                    err: text;
                                    ok: SignedTransaction;
                                  });
  /// Sign an ERC-20 transfer. Client provides nonce + gas from their RPC.
  signErc20Transfer: (chainId: nat, tokenAddress: text, recipientAddress:
   text, amount: nat, nonce: nat, maxFeePerGas: nat, maxPriorityFeePerGas:
   nat) -> (variant {
              err: text;
              ok: SignedTransaction;
            });
  /// Sign a native ETH transfer. Client provides nonce + gas from their RPC.
  signEthTransfer: (chainId: nat, recipientAddress: text, amountWei: 
   nat, gasLimit: nat, nonce: nat, maxFeePerGas: nat, maxPriorityFeePerGas:
   nat) -> (variant {
              err: text;
              ok: SignedTransaction;
            });
  /// Sign arbitrary EIP-712 typed data. The generic primitive for DEX integration.
  /// The caller provides pre-computed domainSeparator and structHash (32 bytes each).
  /// The canister computes the EIP-712 digest and signs with tECDSA.
  signTypedData: (domainSeparator: vec nat8, structHash: vec nat8) ->
   (variant {
      err: text;
      ok: SignedTypedData;
    });
  /// Sign an EIP-3009 authorization for x402 payment.
  /// Client probes the URL, extracts chain/token/recipient/amount from the 402, and calls this.
  /// Canister signs → returns header → client retries with header.
  signX402Payment: (chainId: nat, tokenAddress: text, recipient: text,
   amount: nat, tokenName: text, tokenVersion: text) ->
   (variant {
      err: text;
      ok: SignedAuthorization;
    });
  submitJobResult: (jobId: text, result: blob, proof: opt blob, actualCost:
   opt nat) -> (variant {
                  err: text;
                  ok;
                });
  submitServiceRequest: (serviceId: text, params: blob, paymentSig:
   opt PaymentSignature) ->
   (variant {
      error: text;
      ok: record {jobId: text;};
      paymentRequired: vec PaymentRequirement;
    });
  sweepEvm: (chainId: nat, token: text, to: text, amount: nat) ->
   (variant {
      confirmed: text;
      err: text;
      pending: text;
      reverted: text;
    });
  uploadContent: (id: text, mimeType: text, data: blob) ->
   (ContentStoreResult);
  uploadContentChunk: (id: text, index: nat, data: blob) ->
   (ContentStoreResult);
  uploadContentInit: (id: text, mimeType: text, totalSize: nat, chunkCount:
   nat) -> (ContentStoreResult);
  verifyGrant: (grant: AccessGrant) -> (AccessGrantResult) query;
}