@dev.sail.money/sailor 0.0.2-12

package/templates/dca-rebalancer/src/agent.ts

@@ -0,0 +1,253 @@
+/**
+ * DCA-rebalancer agent — Base mainnet, selective SailKernel.
+ *
+ * Strategy: on each tick, if the SMA holds enough USDC, swap a fixed amount
+ * into WETH via Uniswap V3 SwapRouter02.
+ *
+ * Slippage protection: QuoterV2 is called off-chain before each swap.
+ *   amountOutMinimum = expectedOut × (1 − SLIPPAGE_BPS / 10 000)
+ * If QuoterV2 is unavailable or returns 0, the agent skips the tick entirely
+ * (fail closed — never submits with amountOutMinimum = 0).
+ *
+ * Selective kernel: the runner supports dispatchBatch, but this agent returns at
+ * most ONE dispatch per tick for simplicity:
+ *   - An approve, if the router allowance is insufficient.
+ *   - A swap, if allowance is sufficient and a valid quote is available.
+ * Next tick handles the other step.
+ *
+ * The agent does NOT call dispatch.single() itself — it returns intent objects
+ * ({calls, txHash:'0x', ...}) and the runner submits them.
+ *
+ * PERMISSION ROUTING (default — probe path):
+ * This template returns plain Dispatch objects with no `permission` field. The
+ * runner automatically probes each registered permission via off-chain evaluate()
+ * and routes each call to the first permission that accepts it. This is the
+ * recommended default: zero agent-side knowledge of permission addresses required.
+ *
+ * OPTIONAL OVERRIDE (skip probe for a known permission):
+ * If the agent knows exactly which permission governs a call, it can set the
+ * optional `permission` field on the returned Dispatch to skip the probe:
+ *
+ *   import type { Address } from "viem";
+ *   const MY_SWAP_PERMISSION = "0x..." as Address;
+ *   return [{ ...dispatch, permission: MY_SWAP_PERMISSION }];
+ *
+ * This is an optimisation only — the probe path is equally correct.
+ */
+
+import type { Agent, AgentContext, Call, Dispatch } from "@sail/sdk";
+import { encodeFunctionData, type PublicClient } from "viem";
+import {
+  ALLOWED_TOKENS,
+  MIN_USDC_TO_SWAP,
+  QUOTER_V2,
+  REBALANCE_THRESHOLD,
+  SLIPPAGE_BPS,
+  SWAP_AMOUNT_USDC,
+  SWAP_FEE_TIER,
+  SWAP_ROUTER,
+} from "./mandate.js";
+
+// ── ABI fragments ─────────────────────────────────────────────────────────────
+
+const ERC20_ABI = [
+  {
+    name: "allowance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" },
+    ],
+    outputs: [{ type: "uint256" }],
+  },
+  {
+    name: "approve",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" },
+    ],
+    outputs: [{ type: "bool" }],
+  },
+] as const;
+
+// Uniswap V3 QuoterV2 — quoteExactInputSingle (struct-params variant).
+// Called via eth_call (publicClient.simulateContract) since the function
+// is marked nonpayable but is safe to simulate as a read.
+const QUOTER_V2_ABI = [
+  {
+    name: "quoteExactInputSingle",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenIn", type: "address" },
+          { name: "tokenOut", type: "address" },
+          { name: "amountIn", type: "uint256" },
+          { name: "fee", type: "uint24" },
+          { name: "sqrtPriceLimitX96", type: "uint160" },
+        ],
+      },
+    ],
+    outputs: [
+      { name: "amountOut", type: "uint256" },
+      { name: "sqrtPriceX96After", type: "uint160" },
+      { name: "initializedTicksCrossed", type: "uint32" },
+      { name: "gasEstimate", type: "uint256" },
+    ],
+  },
+] as const;
+
+const SWAP_ROUTER_ABI = [
+  {
+    name: "exactInputSingle",
+    type: "function",
+    stateMutability: "payable",
+    inputs: [
+      {
+        name: "params",
+        type: "tuple",
+        components: [
+          { name: "tokenIn", type: "address" },
+          { name: "tokenOut", type: "address" },
+          { name: "fee", type: "uint24" },
+          { name: "recipient", type: "address" },
+          { name: "amountIn", type: "uint256" },
+          { name: "amountOutMinimum", type: "uint256" },
+          { name: "sqrtPriceLimitX96", type: "uint160" },
+        ],
+      },
+    ],
+    outputs: [{ name: "amountOut", type: "uint256" }],
+  },
+] as const;
+
+// ── Intent builder ────────────────────────────────────────────────────────────
+
+/** Wrap a single EVM call as a Dispatch intent (no txHash yet — runner submits). */
+function intent(call: Call): Dispatch {
+  return { txHash: "0x", calls: [call], success: false, gasUsed: 0n };
+}
+
+// ── Agent ─────────────────────────────────────────────────────────────────────
+
+export const agent: Agent = {
+  name: "dca-rebalancer",
+  description:
+    `DCA into WETH with USDC on Base via Uniswap V3. ` +
+    `Rebalances when allocation drift exceeds ${REBALANCE_THRESHOLD * 100}%. ` +
+    `Slippage tolerance: ${SLIPPAGE_BPS / 100}%.`,
+
+  async tick(ctx: AgentContext): Promise<Dispatch[]> {
+    const { safe } = ctx;
+
+    ctx.log(`tick — block ${ctx.blockNumber}, sma ${safe}`);
+
+    // publicClient is injected by the runner via ctx.data._publicClient
+    // so the agent can make arbitrary on-chain reads (allowance, QuoterV2).
+    const pc = ctx.data._publicClient as PublicClient | undefined;
+    if (!pc) {
+      ctx.log("no publicClient in ctx.data — skipping tick");
+      return [];
+    }
+
+    const usdc = ALLOWED_TOKENS[0]!;
+    const weth = ALLOWED_TOKENS[1]!;
+
+    // ── Step 1: Check USDC balance ────────────────────────────────────────────
+    const usdcBalance = await ctx.read.balance(usdc);
+    ctx.log(`USDC balance: ${usdcBalance} (min to swap: ${MIN_USDC_TO_SWAP})`);
+
+    if (usdcBalance < MIN_USDC_TO_SWAP) {
+      ctx.log("USDC balance below minimum — skipping tick");
+      return [];
+    }
+
+    // ── Step 2: Check allowance — approve first if needed ─────────────────────
+    const allowance = await pc.readContract({
+      address: usdc,
+      abi: ERC20_ABI,
+      functionName: "allowance",
+      args: [safe, SWAP_ROUTER],
+    });
+
+    if (allowance < SWAP_AMOUNT_USDC) {
+      ctx.log(`allowance (${allowance}) < swap amount (${SWAP_AMOUNT_USDC}) — submitting approve`);
+      // Approve max uint256 once so subsequent ticks skip this step.
+      const approveCall: Call = {
+        target: usdc,
+        value: 0n,
+        data: encodeFunctionData({
+          abi: ERC20_ABI,
+          functionName: "approve",
+          args: [SWAP_ROUTER, 2n ** 256n - 1n],
+        }),
+      };
+      return [intent(approveCall)];
+    }
+
+    // ── Step 3: Quote via QuoterV2 — fail closed ──────────────────────────────
+    let expectedOut: bigint;
+    try {
+      const result = await pc.simulateContract({
+        address: QUOTER_V2,
+        abi: QUOTER_V2_ABI,
+        functionName: "quoteExactInputSingle",
+        args: [
+          {
+            tokenIn: usdc,
+            tokenOut: weth,
+            amountIn: SWAP_AMOUNT_USDC,
+            fee: SWAP_FEE_TIER,
+            sqrtPriceLimitX96: 0n,
+          },
+        ],
+      });
+      expectedOut = (result.result as [bigint, bigint, number, bigint])[0];
+    } catch (e) {
+      ctx.log(`QuoterV2 unavailable: ${(e as Error).message.slice(0, 100)} — skipping tick (fail closed)`);
+      return [];
+    }
+
+    if (expectedOut === 0n) {
+      ctx.log("QuoterV2 returned 0 expected output — skipping tick (fail closed)");
+      return [];
+    }
+
+    // ── Step 4: Compute amountOutMinimum with slippage ────────────────────────
+    const minOut = (expectedOut * BigInt(10_000 - SLIPPAGE_BPS)) / 10_000n;
+    ctx.log(
+      `quote: ${expectedOut} wei WETH, minOut (${SLIPPAGE_BPS / 100}% slippage): ${minOut}`,
+    );
+
+    // ── Step 5: Encode swap call ──────────────────────────────────────────────
+    const swapCall: Call = {
+      // Uniswap V3 SwapRouter02 on Base
+      target: SWAP_ROUTER,
+      value: 0n,
+      data: encodeFunctionData({
+        abi: SWAP_ROUTER_ABI,
+        functionName: "exactInputSingle",
+        args: [
+          {
+            tokenIn: usdc,
+            tokenOut: weth,
+            fee: SWAP_FEE_TIER,
+            recipient: safe,      // output stays in the SMA
+            amountIn: SWAP_AMOUNT_USDC,
+            amountOutMinimum: minOut, // slippage-protected — never 0
+            sqrtPriceLimitX96: 0n,
+          },
+        ],
+      }),
+    };
+
+    ctx.log(`submitting swap: ${SWAP_AMOUNT_USDC} USDC → WETH, minOut=${minOut}`);
+    return [intent(swapCall)];
+  },
+};

package/templates/dca-rebalancer/src/config.ts

@@ -0,0 +1,27 @@
+import { SailorClient } from "@sail/sdk";
+
+/** Reads RPC_URL and CHAIN_ID from environment (set via .sail/.env.local or GitHub Secrets). */
+export function getEnvConfig(): { rpcUrl: string; chainId: number } {
+  const rpcUrl = process.env["RPC_URL"];
+  if (!rpcUrl) {
+    throw new Error(
+      "RPC_URL is not set.\n" +
+        "Run the Sailor setup guide (open this folder in your LLM tool and say 'start') or\n" +
+        "add RPC_URL to .sail/.env.local manually.",
+    );
+  }
+
+  const chainId = Number(process.env["CHAIN_ID"] ?? "8453"); // Default: Base mainnet
+  if (Number.isNaN(chainId)) {
+    throw new Error(`Invalid CHAIN_ID: ${process.env["CHAIN_ID"]}`);
+  }
+
+  return { rpcUrl, chainId };
+}
+
+/** Builds a SailorClient from environment config. */
+export function createClient(): SailorClient {
+  const { rpcUrl, chainId } = getEnvConfig();
+  // SailorClient constructor is not implemented yet — this is illustrative.
+  return new SailorClient({ rpcUrl, chainId });
+}

package/templates/dca-rebalancer/src/mandate.ts

@@ -0,0 +1,67 @@
+import type { Address } from "@sail/sdk";
+
+// ── Token addresses (Base mainnet) ────────────────────────────────────────────
+
+/**
+ * Tokens in the DCA basket.
+ * ALLOWED_TOKENS[0] = USDC (input — what the agent spends)
+ * ALLOWED_TOKENS[1] = WETH (output — what the agent accumulates)
+ */
+export const ALLOWED_TOKENS: Address[] = [
+  "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", // USDC on Base  (6 decimals)
+  "0x4200000000000000000000000000000000000006", // WETH on Base  (18 decimals)
+];
+
+// ── Swap parameters ───────────────────────────────────────────────────────────
+
+/**
+ * Amount of USDC to spend per swap (in USDC base units, 6 decimals).
+ * Default: 5 USDC. Adjust before deploying to production.
+ */
+export const SWAP_AMOUNT_USDC = 5_000_000n; // 5 USDC
+
+/**
+ * Minimum USDC balance the SMA must hold before a swap is attempted.
+ * Must be ≥ SWAP_AMOUNT_USDC. Adds a safety margin so a single swap
+ * doesn't drain the account to zero.
+ */
+export const MIN_USDC_TO_SWAP = 6_000_000n; // 6 USDC
+
+/**
+ * Slippage tolerance in basis points (100 = 1%).
+ * amountOutMinimum = quote × (1 − SLIPPAGE_BPS / 10 000).
+ * If no quote is available, the agent skips the swap entirely (fail closed).
+ *
+ * Tighten for large trades or illiquid pairs; loosen if valid swaps are
+ * frequently denied by price impact. Default 1% is conservative for
+ * USDC/WETH on Base.
+ */
+export const SLIPPAGE_BPS = 100; // 1%
+
+/**
+ * Uniswap V3 pool fee tier for the USDC/WETH pool on Base.
+ * 500 = 0.05% — the most liquid USDC/WETH pool on Base mainnet.
+ */
+export const SWAP_FEE_TIER = 500;
+
+// ── Rebalancing ───────────────────────────────────────────────────────────────
+
+/** Rebalance when allocation drift exceeds this fraction (0.05 = 5%). */
+export const REBALANCE_THRESHOLD = 0.05;
+
+// ── Contract addresses (Base mainnet) ─────────────────────────────────────────
+
+/** Uniswap SwapRouter02 on Base. Target for exactInputSingle swaps. */
+export const SWAP_ROUTER: Address = "0x2626664c2603336E57B271c5C0b26F421741e481";
+
+/**
+ * Uniswap V3 QuoterV2 on Base.
+ * Called off-chain (via eth_call) to obtain the expected output amount
+ * before computing amountOutMinimum. If this call fails, the agent skips
+ * the swap — it never submits with amountOutMinimum = 0.
+ *
+ * Note: amountOutMinimum is set by the agent from the QuoterV2 result.
+ * For defense-in-depth, add an on-chain minimum check in your permission
+ * contract so the kernel also validates the minimum out requirement.
+ */
+export const QUOTER_V2: Address = "0x3d4e44Eb1374240CE5F1B871ab261CD16335B76a";

package/templates/dca-rebalancer/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "noEmit": true
+  },
+  "include": ["src"]
+}

package/templates/dca-rebalancer/ui/README.md

@@ -0,0 +1,3 @@
+# UI
+
+Vite + React UI lands in the next prompt.

package/templates/lifi-permissions/LifiBoundedApprovePermissionCloneable.sol

@@ -0,0 +1,84 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import {IPermission, Context} from "../../.sail/contracts/interfaces/IPermission.sol";
+import {CloneInitializable} from "../../.sail/contracts/templates/base/CloneInitializable.sol";
+
+/// @title  LifiBoundedApprovePermissionCloneable
+/// @notice EIP-1167 clone-template approval permission with PER-TOKEN caps. The
+///         logic contract is deployed once and registered in the SDK's
+///         standaloneTemplates; each account clones it via
+///         PermissionFactory.deployAndAttach and configures via initialize().
+///
+///         The manager may ONLY approve the LiFi Diamond, and only on tokens that
+///         have a configured cap, up to that token's cap. Passes through any
+///         non-approve call (conjunctive model).
+///
+///         Caps are PER TOKEN (not one global cap) because token value and decimals
+///         differ — e.g. 1 DAI = 1e18 base units vs 1 USDC = 1e6. A single cap can't
+///         bound both sensibly.
+contract LifiBoundedApprovePermissionCloneable is IPermission, CloneInitializable {
+    bytes4 private constant APPROVE = 0x095ea7b3;
+    address public constant LIFI_DIAMOND = 0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE;
+
+    // Per-token approve cap, in the token's base units. 0 = token not allowed.
+    // A mapping occupies its own slot pointer and does not pack with the
+    // CloneInitializable `_initialized` bool at slot 0.
+    mapping(address token => uint256 cap) public maxApprovePerToken;
+    address public permissionSigner;
+
+    error NotPermissionSigner();
+    error ZeroAddress();
+    error LengthMismatch();
+
+    modifier onlyPermissionSigner() {
+        if (msg.sender != permissionSigner) revert NotPermissionSigner();
+        _;
+    }
+
+    /// @dev Lock the logic contract; only clones (fresh storage) can be initialized.
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @notice One-time per-clone configuration.
+    /// @param tokens            Tokens the manager may approve to the LiFi Diamond.
+    /// @param caps              Per-token cap (token base units); index-aligned with `tokens`.
+    /// @param _permissionSigner Owner wallet; sole authority for post-init updates.
+    function initialize(
+        address[] memory tokens,
+        uint256[] memory caps,
+        address _permissionSigner
+    ) external initializer {
+        if (_permissionSigner == address(0)) revert ZeroAddress();
+        if (tokens.length != caps.length) revert LengthMismatch();
+        permissionSigner = _permissionSigner;
+        for (uint256 i; i < tokens.length; i++) {
+            maxApprovePerToken[tokens[i]] = caps[i];
+        }
+    }
+
+    /// @notice Set (cap > 0) or clear (cap == 0) a token's per-tx approve cap.
+    function setTokenCap(address token, uint256 cap) external onlyPermissionSigner {
+        maxApprovePerToken[token] = cap;
+    }
+
+    function evaluate(bytes calldata txData, Context calldata ctx) external view returns (bool) {
+        // Pass through calls outside this permission's domain (conjunctive model).
+        if (ctx.selector != APPROVE) return true;
+        if (ctx.target == address(0)) return false; // token is ctx.target
+        if (txData.length < 68) return false;
+
+        (address spender, uint256 amount) = abi.decode(txData[4:], (address, uint256));
+        if (spender != LIFI_DIAMOND) return false;
+
+        uint256 cap = maxApprovePerToken[ctx.target];
+        if (cap == 0) return false; // token not allowed
+        if (amount > cap) return false; // over the per-token cap
+        return true;
+    }
+
+    function discriminator() external pure returns (bytes32) {
+        return keccak256("LifiBoundedApprovePermissionCloneable.v1");
+    }
+}

package/templates/lifi-permissions/LifiDiamondSwapPermissionCloneable.sol

@@ -0,0 +1,97 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.26;
+
+import {IPermission, Context} from "../../.sail/contracts/interfaces/IPermission.sol";
+import {CloneInitializable} from "../../.sail/contracts/templates/base/CloneInitializable.sol";
+
+/// @title  LifiDiamondSwapPermissionCloneable
+/// @notice EIP-1167 clone-template version of LifiDiamondSwapPermission. The logic
+///         contract is deployed once and registered in the SDK's standaloneTemplates;
+///         each account gets its own clone via PermissionFactory.deployAndAttach,
+///         configured through initialize() (NOT the constructor).
+///
+///         Restricts manager-initiated swaps to the official LiFi Diamond on Base:
+///          - target must be the LiFi Diamond,
+///          - selector must be allowlisted,
+///          - receiver embedded in the calldata must equal ctx.account (the SMA),
+///          - the minAmount field must not exceed the configured cap.
+///         Passes through any call whose target is not the diamond (conjunctive model).
+///
+///         Calldata layout (validated against live Base quotes):
+///          selector(4) + word0(32) + word1(32) + word2(32) + receiver(32) + minAmount(32)
+///          → receiver at offset 100, minAmount at offset 132.
+contract LifiDiamondSwapPermissionCloneable is IPermission, CloneInitializable {
+    // Official LiFi Diamond on Base Mainnet.
+    address public constant LIFI_DIAMOND = 0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE;
+
+    // Storage starts after CloneInitializable's `_initialized` bool (slot 0). A
+    // mapping occupies its own slot pointer and does not pack with the bool.
+    mapping(bytes4 selector => bool) public isAllowedSelector;
+    uint256 public maxMinAmountPerTx;
+    address public permissionSigner;
+
+    error NotPermissionSigner();
+    error ZeroAddress();
+
+    modifier onlyPermissionSigner() {
+        if (msg.sender != permissionSigner) revert NotPermissionSigner();
+        _;
+    }
+
+    /// @dev Lock the logic contract; only clones (fresh storage) can be initialized.
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @notice One-time per-clone configuration.
+    /// @param allowedSelectors   LiFi Diamond selectors to allowlist on init.
+    /// @param _maxMinAmountPerTx Cap on the minAmount field (type(uint256).max = uncapped).
+    /// @param _permissionSigner  Owner wallet; sole authority for post-init updates.
+    function initialize(
+        bytes4[] memory allowedSelectors,
+        uint256 _maxMinAmountPerTx,
+        address _permissionSigner
+    ) external initializer {
+        if (_permissionSigner == address(0)) revert ZeroAddress();
+        maxMinAmountPerTx = _maxMinAmountPerTx;
+        permissionSigner = _permissionSigner;
+        for (uint256 i; i < allowedSelectors.length; i++) {
+            isAllowedSelector[allowedSelectors[i]] = true;
+        }
+    }
+
+    function setMaxMinAmountPerTx(uint256 newMax) external onlyPermissionSigner {
+        maxMinAmountPerTx = newMax;
+    }
+
+    /// @notice Add a LiFi selector. Only after verifying its calldata places
+    ///         `receiver` at offset 100 and `minAmount` at offset 132.
+    function addSelector(bytes4 selector) external onlyPermissionSigner {
+        isAllowedSelector[selector] = true;
+    }
+
+    function removeSelector(bytes4 selector) external onlyPermissionSigner {
+        isAllowedSelector[selector] = false;
+    }
+
+    uint256 private constant RECEIVER_OFFSET = 100;
+    uint256 private constant MIN_DATA_LEN = 164;
+
+    function evaluate(bytes calldata txData, Context calldata ctx) external view returns (bool) {
+        // Pass through calls outside this permission's domain (conjunctive model).
+        if (ctx.target != LIFI_DIAMOND) return true;
+        if (!isAllowedSelector[ctx.selector]) return false;
+        if (txData.length < MIN_DATA_LEN) return false;
+
+        address receiver = abi.decode(txData[RECEIVER_OFFSET:RECEIVER_OFFSET + 32], (address));
+        uint256 minAmount = abi.decode(txData[RECEIVER_OFFSET + 32:RECEIVER_OFFSET + 64], (uint256));
+
+        if (receiver != ctx.account) return false;
+        if (minAmount > maxMinAmountPerTx) return false;
+        return true;
+    }
+
+    function discriminator() external pure returns (bytes32) {
+        return keccak256("LifiDiamondSwapPermissionCloneable.v1");
+    }
+}

package/templates/lifi-permissions/README.md

@@ -0,0 +1,53 @@
+# LiFi clone-permission templates
+
+Canonical source (for reference) of the EIP-1167 **clone** permission templates
+used for LiFi-based swaps/DCA. The logic contracts are deployed once per chain and
+registered in the SDK deployment registry
+(`packages/sdk/src/deployments.ts` → `standaloneTemplates` / `cloneTemplates`).
+Each account gets its own clone via `PermissionFactory.deployAndAttach`, configured
+through `initialize()` (never the constructor).
+
+These follow the `CloneInitializable` pattern: the constructor calls
+`_disableInitializers()` to permanently lock the logic contract, and a one-time
+`initialize()` (guarded by the `initializer` modifier) configures each clone.
+
+> The `import` paths reference `../../.sail/contracts/{interfaces,templates/base}`
+> from the Foundry project they were built in
+> (`tests/base-mainnet-agent-01/`). This folder is **reference source** — sailor has
+> no Foundry build. Build/deploy happens in that project via
+> `scripts/deploy-clone-templates.ts`.
+
+> **Note:** The kernels bundled in `@sail/sdk` (Base, Base Sepolia, Arbitrum, Unichain) now all run the **selective** dispatch model — verified on-chain against each kernel's `DISPATCH_TYPEHASH`. These templates were written for the older conjunctive model and include pass-through logic (`return true` for calls outside their domain) that is not required on selective kernels. Review before deploying against a selective kernel; the pass-through logic is harmless but unnecessary.
+
+## Contracts
+
+### LifiDiamondSwapPermissionCloneable → `boundedLiFi`
+Restricts manager swaps to the official LiFi Diamond:
+target == diamond, selector allowlisted, embedded receiver == `ctx.account`,
+`minAmount <= maxMinAmountPerTx`. Passes through any call whose target is not the
+diamond (conjunctive-kernel rule).
+
+`initialize(bytes4[] allowedSelectors, uint256 maxMinAmountPerTx, address permissionSigner)`
+
+### LifiBoundedApprovePermissionCloneable → `boundedApprove`
+Approve only the LiFi Diamond, only on tokens with a configured cap, up to that
+cap. **Per-token caps** (`mapping(token => cap)`) because token value/decimals
+differ (1 DAI = 1e18 vs 1 USDC = 1e6). Passes through non-approve calls.
+
+`initialize(address[] tokens, uint256[] caps, address permissionSigner)`
+
+## Deployed logic addresses
+
+| Template | Chain | Address |
+|---|---|---|
+| boundedLiFi | Base mainnet (8453) | `0xF1abcF774250fD1A8147B56DA07Bf9021064650A` |
+| boundedApprove | Base mainnet (8453) | `0x9c0b86daf9e75d759a5D165aD7366e52b3353fD8` |
+
+Both verified `initialized() == true` (logic locked) post-deploy.
+
+## Conjunctive-kernel note
+
+Both Base kernels use the **conjunctive** dispatch model: every registered
+permission is evaluated and ALL must return true. So a permission MUST pass through
+calls outside its own domain (return `true`), or it bricks unrelated dispatches.
+Both templates above do this.