@intentlayer/sdk 0.1.0 → 0.1.2

package/dist/{agentConstraintBuilder-CK56UDUI.mjs → agentConstraintBuilder-CWXPHBNY.mjs}

@@ -1,7 +1,7 @@
 import {
   buildV2ConstraintsFromAgent,
   constraintsToV2Params
-} from "./chunk-GRBEB2EV.mjs";
+} from "./chunk-BN6IO64L.mjs";
 import "./chunk-XP4I75K7.mjs";
 export {
   buildV2ConstraintsFromAgent,

package/dist/{chunk-GRBEB2EV.mjs → chunk-BN6IO64L.mjs}

@@ -765,7 +765,7 @@ var init_constraints = __esm({
 });
 
 // src/constraints/agentConstraintBuilder.ts
-import { keccak256 as keccak2562, parseEther } from "viem";
+import { keccak256 as keccak2562, parseUnits } from "viem";
 
 // src/policy/types.ts
 var V2_FLAG_RECIPIENT = 1;
@@ -957,11 +957,13 @@ function buildV2ConstraintsFromAgent(constraints) {
   if (constraints.allowedRecipients && constraints.allowedRecipients.length === 1) {
     v2Params.allowedRecipient = constraints.allowedRecipients[0];
   }
-  if (constraints.maxDailyUsd) {
-    v2Params.cap = parseEther(String(constraints.maxDailyUsd));
-    v2Params.periodType = "daily";
-  } else if (constraints.maxPerTxUsd) {
-    v2Params.cap = parseEther(String(constraints.maxPerTxUsd));
+  const capResolution = resolveCapConfig(constraints);
+  if (capResolution.leafCap) {
+    const asset = constraints.allowedAssets?.[0];
+    v2Params.cap = capToWei(capResolution.leafCap.capValue, asset, constraints);
+    if (capResolution.leafCap.hasPeriod) {
+      v2Params.periodType = "daily";
+    }
   }
   if (constraints.deadline) {
     v2Params.deadline = constraints.deadline;
@@ -974,6 +976,11 @@ function buildV2ConstraintsFromAgent(constraints) {
   }
   const leaf = buildV2LeafFromConstraints(v2Params);
   const root = keccak2562(leaf);
+  let dailyCapWei;
+  if (capResolution.dailyCapValue !== void 0) {
+    const asset = constraints.allowedAssets?.[0];
+    dailyCapWei = capToWei(capResolution.dailyCapValue, asset, constraints);
+  }
   let recipientLeaves;
   if (constraints.allowedRecipients && constraints.allowedRecipients.length === 1) {
     const recipient = constraints.allowedRecipients[0].toLowerCase();
@@ -981,12 +988,12 @@ function buildV2ConstraintsFromAgent(constraints) {
     const key = `${recipient}-${asset}`;
     recipientLeaves = { [key]: leaf };
   }
-  return { leaf, root, recipientLeaves };
+  return { leaf, root, recipientLeaves, dailyCapWei };
 }
 function buildMultiRecipientV2Constraints(constraints) {
   const recipients = constraints.allowedRecipients;
   const builder = new CompoundLeafBuilder();
-  const cap = constraints.maxDailyUsd ? parseEther(String(constraints.maxDailyUsd)) : constraints.maxPerTxUsd ? parseEther(String(constraints.maxPerTxUsd)) : void 0;
+  const capResolution = resolveCapConfig(constraints);
   const dummyWallet = "0x0000000000000000000000000000000000000001";
   const assets = constraints.allowedAssets;
   const hasMultipleAssets = assets && assets.length > 1;
@@ -998,7 +1005,7 @@ function buildMultiRecipientV2Constraints(constraints) {
         recipientAssetCombinations.push({
           recipient,
           asset,
-          maxAmount: cap,
+          maxAmount: capResolution.leafCap ? capToWei(capResolution.leafCap.capValue, asset, constraints) : void 0,
           deadline: constraints.deadline
         });
       }
@@ -1006,14 +1013,20 @@ function buildMultiRecipientV2Constraints(constraints) {
     multiPolicy = builder.createMultiRecipientPolicy(dummyWallet, recipientAssetCombinations);
   } else {
     const asset = assets?.[0];
+    const cap = capResolution.leafCap ? capToWei(capResolution.leafCap.capValue, asset, constraints) : void 0;
     multiPolicy = builder.createMultiRecipientPolicy(dummyWallet, {
       allowedRecipients: recipients,
       allowedAsset: asset,
       maxAmount: cap,
       deadline: constraints.deadline,
-      periodCode: constraints.maxDailyUsd ? PERIOD_DAILY2 : void 0
+      periodCode: capResolution.leafCap?.hasPeriod ? PERIOD_DAILY2 : void 0
     });
   }
+  let dailyCapWei;
+  if (capResolution.dailyCapValue !== void 0) {
+    const asset = assets?.[0];
+    dailyCapWei = capToWei(capResolution.dailyCapValue, asset, constraints);
+  }
   const defaultAsset = assets?.[0] ? assets[0].toLowerCase() : "*";
   const defaultKey = `${recipients[0].toLowerCase()}-${defaultAsset}`;
   const defaultLeafAndProof = multiPolicy.leafProofs[defaultKey];
@@ -1024,8 +1037,9 @@ function buildMultiRecipientV2Constraints(constraints) {
     leaf: defaultLeafAndProof,
     // This is actually leafAndProof (leaf + merkle proof)
     root: multiPolicy.merkleRoot,
-    recipientLeaves: multiPolicy.leafProofs
+    recipientLeaves: multiPolicy.leafProofs,
     // Map of recipient-asset -> leafAndProof
+    dailyCapWei
   };
 }
 function constraintsToV2Params(constraints, recipient) {
@@ -1035,11 +1049,13 @@ function constraintsToV2Params(constraints, recipient) {
   } else if (constraints.allowedRecipients && constraints.allowedRecipients.length === 1) {
     params.allowedRecipient = constraints.allowedRecipients[0];
   }
-  if (constraints.maxDailyUsd) {
-    params.cap = parseEther(String(constraints.maxDailyUsd));
-    params.periodType = "daily";
-  } else if (constraints.maxPerTxUsd) {
-    params.cap = parseEther(String(constraints.maxPerTxUsd));
+  const capResolution = resolveCapConfig(constraints);
+  if (capResolution.leafCap) {
+    const asset = constraints.allowedAssets?.[0];
+    params.cap = capToWei(capResolution.leafCap.capValue, asset, constraints);
+    if (capResolution.leafCap.hasPeriod) {
+      params.periodType = "daily";
+    }
   }
   if (constraints.deadline) {
     params.deadline = constraints.deadline;
@@ -1052,6 +1068,31 @@ function constraintsToV2Params(constraints, recipient) {
   }
   return params;
 }
+function resolveCapConfig(constraints) {
+  const periodCap = constraints.capPerPeriod ?? constraints.maxDailyUsd;
+  const txCap = constraints.capPerTx ?? constraints.maxPerTxUsd;
+  if (txCap && periodCap) {
+    return {
+      leafCap: { capValue: txCap, hasPeriod: false },
+      dailyCapValue: periodCap
+    };
+  } else if (periodCap) {
+    return {
+      leafCap: { capValue: periodCap, hasPeriod: true },
+      dailyCapValue: void 0
+    };
+  } else if (txCap) {
+    return {
+      leafCap: { capValue: txCap, hasPeriod: false },
+      dailyCapValue: void 0
+    };
+  }
+  return { leafCap: void 0, dailyCapValue: void 0 };
+}
+function capToWei(capValue, asset, constraints) {
+  const decimals = asset && constraints.tokenDecimals ? constraints.tokenDecimals[asset.toLowerCase()] ?? 18 : 18;
+  return parseUnits(String(capValue), decimals);
+}
 function bigintToBytes32(value) {
   return `0x${value.toString(16).padStart(64, "0")}`;
 }

package/dist/index.d.mts

@@ -242,15 +242,33 @@ interface AgentConstraints {
      */
     presetType?: string;
     /**
-     * Maximum USD value per day (uses oracle for conversion).
-     * This sets FLAG_CAP | FLAG_PERIOD with PERIOD_DAILY in V2 leaf.
+     * Maximum token amount per period (human-readable, e.g. 1000 = 1000 USDC).
+     * This sets FLAG_CAP | FLAG_PERIOD in V2 leaf.
+     * The period is determined by `periodCode` (defaults to PERIOD_DAILY).
+     */
+    capPerPeriod?: number;
+    /**
+     * Maximum token amount per transaction (human-readable, e.g. 500 = 500 USDC).
+     * This sets FLAG_CAP only in V2 leaf (no period tracking).
+     */
+    capPerTx?: number;
+    /**
+     * @deprecated Use `capPerPeriod` instead. This field name is misleading —
+     * caps are token-amount-based, not USD-based.
      */
     maxDailyUsd?: number;
     /**
-     * Maximum USD value per transaction (without period).
-     * This sets FLAG_CAP only in V2 leaf.
+     * @deprecated Use `capPerTx` instead. This field name is misleading —
+     * caps are token-amount-based, not USD-based.
      */
     maxPerTxUsd?: number;
+    /**
+     * Token decimals map for cap conversion.
+     * Maps lowercase token address → decimals (e.g., USDC = 6, ETH = 18).
+     * Used by the constraint builder to convert human-readable cap values to raw wei.
+     * If not provided, defaults to 18 decimals (ETH-like).
+     */
+    tokenDecimals?: Record<string, number>;
     /**
      * Allowed recipient addresses for transfers.
      * This sets FLAG_RECIPIENT in V2 leaf.
@@ -932,8 +950,10 @@ declare const SELECTORS: {
  * Configuration for a trading agent preset.
  */
 interface TradingAgentPreset {
-    /** Maximum USD value per day */
-    maxDailyUsd: number;
+    /** Human-readable token amount cap per period */
+    capPerPeriod?: number;
+    /** @deprecated Use capPerPeriod */
+    maxDailyUsd?: number;
     /** Swap contract address (e.g., MockSwap, Uniswap Router) */
     swapContract: Hex;
     /** Swap function selectors (defaults to common swap selectors) */
@@ -980,8 +1000,10 @@ declare function tradingAgent(config: TradingAgentPreset): AgentConstraints;
 interface PaymentAgentPreset {
     /** Allowed vendor addresses */
     vendors: Hex[];
-    /** Maximum USD value per day across all vendors */
-    maxDailyUsd: number;
+    /** Human-readable token amount cap per period */
+    capPerPeriod?: number;
+    /** @deprecated Use capPerPeriod */
+    maxDailyUsd?: number;
     /** Token contract for ERC20 payments (optional, for ETH-only omit this) */
     tokenContract?: Hex;
 }
@@ -1017,8 +1039,10 @@ declare function paymentAgent(config: PaymentAgentPreset): AgentConstraints;
  * Configuration for a treasury operations preset.
  */
 interface TreasuryOpsPreset {
-    /** Maximum USD value per day */
-    maxDailyUsd: number;
+    /** Human-readable token amount cap per period */
+    capPerPeriod?: number;
+    /** @deprecated Use capPerPeriod */
+    maxDailyUsd?: number;
     /** Allowed protocol contracts for treasury operations */
     protocolContracts: Hex[];
     /** Allowed function selectors for protocols */
@@ -1058,8 +1082,10 @@ declare function treasuryOps(config: TreasuryOpsPreset): AgentConstraints;
  * Configuration for a lending operations preset (Aave, Compound, etc.).
  */
 interface LendingOpsPreset {
-    /** Maximum USD value per day */
-    maxDailyUsd: number;
+    /** Human-readable token amount cap per period */
+    capPerPeriod?: number;
+    /** @deprecated Use capPerPeriod */
+    maxDailyUsd?: number;
     /** Lending pool contract address (e.g., Aave Pool, Compound Comptroller) */
     lendingPool: Hex;
     /**
@@ -1108,8 +1134,10 @@ declare function lendingOps(config: LendingOpsPreset): AgentConstraints;
  * Configuration for a stablecoin transfer preset.
  */
 interface StablecoinTransferPreset {
-    /** Maximum USD value per day */
-    maxDailyUsd: number;
+    /** Human-readable token amount cap per period */
+    capPerPeriod?: number;
+    /** @deprecated Use capPerPeriod */
+    maxDailyUsd?: number;
     /** Allowed recipient addresses */
     recipients: Hex[];
     /** Stablecoin contract addresses (USDC, USDT, DAI, etc.) */
@@ -1145,8 +1173,10 @@ declare function stablecoinTransfer(config: StablecoinTransferPreset): AgentCons
 interface PayrollPreset {
     /** Employee wallet addresses */
     employees: Hex[];
-    /** Maximum monthly USD total budget */
-    maxMonthlyUsd: number;
+    /** Human-readable token amount cap per period (monthly) */
+    capPerPeriod?: number;
+    /** @deprecated Use capPerPeriod */
+    maxMonthlyUsd?: number;
     /** Token contract for salary payments (optional, for ETH-only omit) */
     tokenContract?: Hex;
     /**
@@ -1197,8 +1227,10 @@ declare function payroll(config: PayrollPreset): AgentConstraints;
  * Configuration for a simple transfer-only preset.
  */
 interface TransferOnlyPreset {
-    /** Maximum USD value per day */
-    maxDailyUsd: number;
+    /** Human-readable token amount cap per period */
+    capPerPeriod?: number;
+    /** @deprecated Use capPerPeriod */
+    maxDailyUsd?: number;
     /** Allowed recipient addresses */
     recipients: Hex[];
     /** Token contract for ERC20 transfers (optional, for ETH-only omit) */
@@ -1254,8 +1286,10 @@ declare function transferOnly(config: TransferOnlyPreset): AgentConstraints;
 interface MarketingBucketPreset {
     /** Marketing recipient addresses (e.g., Google Ads, Meta Ads) */
     recipients: Hex[];
-    /** Maximum monthly USD budget shared across ALL recipients */
-    maxMonthlyUsd: number;
+    /** Human-readable token amount cap per period (monthly) */
+    capPerPeriod?: number;
+    /** @deprecated Use capPerPeriod */
+    maxMonthlyUsd?: number;
     /**
      * Bucket identifier for shared cap tracking.
      * Can be a string (will be hashed) or a 32-byte hex value.
@@ -1301,8 +1335,10 @@ interface VendorCardPreset {
      * updated on-chain without modifying the policy.
      */
     vendorGroupId: bigint | Hex;
-    /** Maximum daily USD spending limit */
-    maxDailyUsd: number;
+    /** Human-readable token amount cap per period */
+    capPerPeriod?: number;
+    /** @deprecated Use capPerPeriod */
+    maxDailyUsd?: number;
     /** Token contract for payments (optional, for ETH-only omit) */
     tokenContract?: Hex;
     /**
@@ -5307,7 +5343,7 @@ declare class RelayerRuntime {
      *
      * @example
      * ```ts
-     * import { GLOBAL_FLAG_NO_BRIDGE } from '@iel/sdk';
+     * import { GLOBAL_FLAG_NO_BRIDGE } from '@intentlayer/sdk';
      *
      * // Enable bridge blocking (invalidates pending intents)
      * const { headerVersion, txHash } = await runtime.updatePolicyGlobalFlags(
@@ -5796,6 +5832,136 @@ interface ListScheduleExecutionsResponse {
     limit: number;
     offset: number;
 }
+type RequestType = "policy" | "agent_wallet" | "fund";
+type RequestStatus = "pending" | "approved" | "denied" | "executed";
+interface CreateRequestBody {
+    type: RequestType;
+    chainId: number;
+    walletId?: string;
+    params: Record<string, unknown>;
+    reason?: string;
+    expiresAt?: string;
+}
+interface RequestResponse {
+    id: string;
+    tenantId: string;
+    walletId: string | null;
+    chainId: number;
+    type: RequestType;
+    status: RequestStatus;
+    params: Record<string, unknown>;
+    reason: string | null;
+    createdByType: string;
+    createdById: string;
+    rowVersion: number;
+    expiresAt: string | null;
+    resolvedAt: string | null;
+    denyReason: string | null;
+    executionTxHash: string | null;
+    executionId: string | null;
+    executionError: string | null;
+    createdAt: string;
+}
+interface ApproveRequestResponse {
+    requestId: string;
+    status: "approved";
+    rowVersion: number;
+    action: {
+        type: string;
+        intent: Record<string, unknown>;
+        eip712TypedData: Record<string, unknown>;
+    };
+}
+interface ExecuteRequestResponse {
+    requestId: string;
+    status: "executed";
+    executionTxHash: string;
+    executionId?: string;
+    policyId?: string;
+    snapshotId?: string;
+}
+interface ListRequestsResponse {
+    requests: RequestResponse[];
+    total: number;
+}
+interface RequestSummary {
+    id: string;
+    type: RequestType;
+    status: RequestStatus;
+    title: string;
+    description: string;
+    details: Array<{
+        label: string;
+        value: string;
+    }>;
+    expiresAt: string | null;
+    createdAt: string;
+}
+/**
+ * Suggested constraints from agent (input to policy request).
+ * These are advisory - subject to preset caps enforced in compilePolicyConstraints().
+ */
+interface SuggestedConstraints {
+    /** Recipient addresses to include in policy allowlist */
+    allowedRecipients?: string[];
+    /** Asset addresses to include in policy allowlist (or "NATIVE") */
+    allowedAssets?: string[];
+    /** Maximum USD per day budget */
+    maxDailyUsd?: number;
+    /** Maximum USD per transaction */
+    maxPerTxUsd?: number;
+}
+/**
+ * Warning generated during constraint compilation.
+ * Shows what was clamped, excluded, or invalid - never silently dropped.
+ */
+interface CompileWarning {
+    type: "clamped" | "excluded" | "invalid";
+    field: string;
+    message: string;
+    original?: unknown;
+    final?: unknown;
+}
+/**
+ * Diff showing what was requested vs what was included/excluded.
+ */
+interface CompiledPolicyDiff {
+    recipients: {
+        requested: string[];
+        added: string[];
+        excluded: string[];
+        finalCount: number;
+    };
+    assets: {
+        requested: string[];
+        added: string[];
+        excluded: string[];
+        finalCount: number;
+    };
+    dailyBudget: {
+        requested: number | null;
+        final: number | null;
+        changed: boolean;
+    };
+    perTxBudget: {
+        requested: number | null;
+        final: number | null;
+        changed: boolean;
+    };
+}
+/**
+ * Response from compile-policy endpoint.
+ * Shows final constraints that will be bootstrapped after owner approval.
+ */
+interface CompiledPolicyResponse {
+    preset: string;
+    baselineConstraints: Record<string, unknown>;
+    suggestedConstraints: SuggestedConstraints | null;
+    finalConstraints: Record<string, unknown>;
+    warnings: CompileWarning[];
+    diff: CompiledPolicyDiff;
+    compilerVersion: string;
+}
 
 /**
  * Cloud API Error
@@ -5981,6 +6147,56 @@ declare class IELCloudClient {
         limit?: number;
         offset?: number;
     }): Promise<ListScheduleExecutionsResponse>;
+    /**
+     * Create a request (policy, agent_wallet, or fund).
+     * Agents use this to request new permissions from the wallet owner.
+     */
+    createRequest(body: CreateRequestBody, idempotencyKey?: string): Promise<RequestResponse>;
+    /**
+     * List requests with optional filters.
+     */
+    listRequests(options?: {
+        status?: string;
+        type?: string;
+        walletId?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<ListRequestsResponse>;
+    /**
+     * Get a request by ID.
+     */
+    getRequest(requestId: string): Promise<RequestResponse>;
+    /**
+     * Get a human-readable summary of a request.
+     */
+    getRequestSummary(requestId: string): Promise<RequestSummary>;
+    /**
+     * Approve a request. Returns the EIP-712 typed data for the owner to sign.
+     * Only callable by owner (API key holder).
+     */
+    approveRequest(requestId: string): Promise<ApproveRequestResponse>;
+    /**
+     * Deny a request with an optional reason.
+     * Only callable by owner (API key holder).
+     */
+    denyRequest(requestId: string, reason?: string): Promise<RequestResponse>;
+    /**
+     * Execute an approved request by submitting the owner's EIP-712 signature.
+     * Triggers on-chain execution via the bootstrap pipeline.
+     * Only callable by owner (API key holder).
+     */
+    executeRequest(requestId: string, signature: string, txHash?: string, policyId?: string, walletAddress?: string): Promise<ExecuteRequestResponse>;
+    /**
+     * Compile policy constraints for a policy request.
+     * Returns the final constraints that will be bootstrapped after approval,
+     * along with any warnings about clamped/excluded items.
+     *
+     * Use this to show users exactly what they're approving before signing.
+     *
+     * @param requestId - Policy request ID
+     * @returns Compiled policy with finalConstraints, warnings, and diff
+     */
+    compilePolicyRequest(requestId: string): Promise<CompiledPolicyResponse>;
     /**
      * Get wallet by name and return a CloudWallet instance
      */
@@ -7030,6 +7246,8 @@ interface V2ConstraintBuildResult {
     root: Hex;
     /** Per-recipient leaf map for multi-recipient policies */
     recipientLeaves?: Record<string, Hex>;
+    /** Policy-level daily cap in wei (set when both capPerTx and capPerPeriod are present) */
+    dailyCapWei?: bigint;
 }
 /**
  * Build V2 constraints from high-level AgentConstraints.
@@ -7916,7 +8134,7 @@ declare function createV3OnlyPolicy(params: {
  *
  * @example
  * ```ts
- * import { createMultiLeafPolicyBuilder } from '@iel/sdk/policy';
+ * import { createMultiLeafPolicyBuilder } from '@intentlayer/sdk/policy';
  *
  * const builder = createMultiLeafPolicyBuilder();
  *
@@ -8063,7 +8281,7 @@ declare function createMultiLeafPolicyBuilder(): MultiLeafPolicyBuilder;
  * ## Usage
  *
  * ```ts
- * import { policy } from '@iel/sdk';
+ * import { policy } from '@intentlayer/sdk';
  *
  * // Create hybrid policy
  * const result = await policy.createHybridPolicy({