damm-sdk 1.4.35 → 1.4.37

package/src/integrations/lagoonV2/factory.abi.ts

@@ -0,0 +1,110 @@
+// Lagoon v0.6 factory ABI — v3 factory, bytes overload only.
+// The typed overload (0xff592eb5) embeds the v0.5.1 12-field InitStruct and reverts on the
+// 19-field v0.6 struct decode. Always use the bytes overload (0x9dfe49f2) for v0.6 deployments.
+export default [
+    {
+        inputs: [{ internalType: "bool", name: "disable", type: "bool" }],
+        stateMutability: "nonpayable",
+        type: "constructor",
+    },
+    { inputs: [], name: "InvalidInitialization", type: "error" },
+    { inputs: [], name: "NotInitializing", type: "error" },
+    {
+        inputs: [{ internalType: "address", name: "owner", type: "address" }],
+        name: "OwnableInvalidOwner",
+        type: "error",
+    },
+    {
+        inputs: [{ internalType: "address", name: "account", type: "address" }],
+        name: "OwnableUnauthorizedAccount",
+        type: "error",
+    },
+    {
+        anonymous: false,
+        inputs: [{ indexed: false, internalType: "uint64", name: "version", type: "uint64" }],
+        name: "Initialized",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: "address", name: "previousOwner", type: "address" },
+            { indexed: true, internalType: "address", name: "newOwner", type: "address" },
+        ],
+        name: "OwnershipTransferred",
+        type: "event",
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: false, internalType: "address", name: "proxy", type: "address" },
+            { indexed: false, internalType: "address", name: "deployer", type: "address" },
+        ],
+        name: "ProxyDeployed",
+        type: "event",
+    },
+    // Bytes overload: selector 0x9dfe49f2
+    // call_data must be pre-encoded as: initialize(bytes,address,address) with abi.encode(<19-field InitStruct tuple>)
+    // Use this overload exclusively for v0.6 — the typed overload (0xff592eb5) contains the
+    // v0.5.1 12-field struct and reverts on any v0.6 decode attempt.
+    {
+        inputs: [
+            { internalType: "address", name: "_logic", type: "address" },
+            { internalType: "address", name: "_initialOwner", type: "address" },
+            { internalType: "uint256", name: "_initialDelay", type: "uint256" },
+            { internalType: "bytes", name: "call_data", type: "bytes" },
+            { internalType: "bytes32", name: "salt", type: "bytes32" },
+        ],
+        name: "createVaultProxy",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [
+            { internalType: "address", name: "_registry", type: "address" },
+            { internalType: "address", name: "_wrappedNativeToken", type: "address" },
+            { internalType: "address", name: "owner", type: "address" },
+        ],
+        name: "initialize",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [{ internalType: "address", name: "vault", type: "address" }],
+        name: "isInstance",
+        outputs: [{ internalType: "bool", name: "", type: "bool" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "owner",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "registry",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+    { inputs: [], name: "renounceOwnership", outputs: [], stateMutability: "nonpayable", type: "function" },
+    {
+        inputs: [{ internalType: "address", name: "newOwner", type: "address" }],
+        name: "transferOwnership",
+        outputs: [],
+        stateMutability: "nonpayable",
+        type: "function",
+    },
+    {
+        inputs: [],
+        name: "wrappedNativeToken",
+        outputs: [{ internalType: "address", name: "", type: "address" }],
+        stateMutability: "view",
+        type: "function",
+    },
+] as const;

package/src/integrations/lagoonV2/index.ts

@@ -0,0 +1,6 @@
+export { default as lagoonV2FactoryAbi } from "./factory.abi";
+export { default as lagoonV2VaultAbi } from "./vault.abi";
+export * from "./addresses";
+export * from "./lagoon.v2";
+export * from "./lagoon.v2.permissions";
+export * from "./lagoon.v2.setters";

package/src/integrations/lagoonV2/lagoon.v2.permissions.ts

@@ -0,0 +1,578 @@
+/**
+ * Lagoon v0.6 vault permission builders.
+ *
+ * These functions encode calldata for the role-gated functions on a deployed v0.6
+ * LagoonVault proxy. They are the v0.6 counterparts of the v0.5 helpers in
+ * `src/integrations/lagoonV1/lagoon.v1.ts` and mirror that module's shape exactly.
+ *
+ * Naming: all exports are prefixed `LagoonV2` / `lagoonV2` to avoid name conflicts
+ * with the v0.5 lagoonV1 exports (e.g. PauseVaultCalldata, pauseVaultTrx) that are
+ * already on the top-level SDK namespace.
+ *
+ * All function signatures have been verified against the deployed v0.6 implementations:
+ *   Arbitrum: 0x3f5A9e1D82c595d14bA93c97eB8a77928cFdee70
+ *   Ethereum: 0x6C77c47FB8168E22976C3B0338CB1769c952249f
+ *
+ * v0.6 differences from v0.5 that affect this module:
+ *   - updateRates takes a 5-field Rates struct (managementRate, performanceRate,
+ *     entryRate, exitRate, haircutRate) — selector 0x0190b902. v0.5 had 2 fields.
+ *   - addToBlacklist / revokeFromBlacklist are NEW (Accessable / Blacklist mode).
+ *   - updateSecurityCouncil and updateSuperOperator are NEW role setters.
+ *   - addToWhitelist / revokeFromWhitelist remain for Whitelist mode.
+ */
+
+import { encodeFunctionData } from "viem";
+import type { Address } from "viem";
+import { createCall, type Call, type HexString, type Unwrapable } from "../..";
+import lagoonV2VaultAbi from "./vault.abi.ts";
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/**
+ * 5-field fee rates struct for Lagoon v0.6.
+ *
+ * Caps (from FeeLib.sol):
+ *   managementRate  max 1000 bps (10%)
+ *   performanceRate max 5000 bps (50%)
+ *   entryRate       max  200 bps (2%)
+ *   exitRate        max  200 bps (2%)
+ *   haircutRate     max 2000 bps (20%)
+ *
+ * Entry and exit rates can only DECREASE after first initialization
+ * (RateCanOnlyDecrease). Management, performance, and haircut have no
+ * monotonic rule — they can be raised up to their caps at any time.
+ */
+export type LagoonV2Rates = Readonly<{
+    managementRate: number; // uint16, max 1000
+    performanceRate: number; // uint16, max 5000
+    entryRate: number; // uint16, max 200
+    exitRate: number; // uint16, max 200
+    haircutRate: number; // uint16, max 2000
+}>;
+
+// ---------------------------------------------------------------------------
+// Validation
+// ---------------------------------------------------------------------------
+
+function validateLagoonV2Rates(rates: LagoonV2Rates): void {
+    if (rates.managementRate > 1_000) {
+        throw new Error(`managementRate ${rates.managementRate} exceeds max 1000 bps (10%)`);
+    }
+    if (rates.performanceRate > 5_000) {
+        throw new Error(`performanceRate ${rates.performanceRate} exceeds max 5000 bps (50%)`);
+    }
+    if (rates.entryRate > 200) {
+        throw new Error(`entryRate ${rates.entryRate} exceeds max 200 bps (2%)`);
+    }
+    if (rates.exitRate > 200) {
+        throw new Error(`exitRate ${rates.exitRate} exceeds max 200 bps (2%)`);
+    }
+    if (rates.haircutRate > 2_000) {
+        throw new Error(`haircutRate ${rates.haircutRate} exceeds max 2000 bps (20%)`);
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Settler (Safe) — settleDeposit, settleRedeem, updateNewTotalAssets, expireTotalAssets
+// ---------------------------------------------------------------------------
+
+/**
+ * Encodes a `settleDeposit(uint256 epoch)` call.
+ * Selector: 0xd24ca58a
+ * Role: Safe (Settler)
+ */
+export const LagoonV2SettleDepositCalldata = ({ epoch }: { epoch: bigint }): HexString => {
+    return encodeFunctionData({
+        abi: lagoonV2VaultAbi,
+        functionName: "settleDeposit",
+        args: [epoch],
+    }) as HexString;
+};
+
+export const lagoonV2SettleDepositTrx = ({ vault, epoch }: { vault: Address; epoch: bigint }): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: vault,
+        value: 0n,
+        data: LagoonV2SettleDepositCalldata({ epoch }),
+    });
+};
+
+/**
+ * Encodes a `settleRedeem(uint256 epoch)` call.
+ * Selector: 0xa627df66
+ * Role: Safe (Settler)
+ */
+export const LagoonV2SettleRedeemCalldata = ({ epoch }: { epoch: bigint }): HexString => {
+    return encodeFunctionData({
+        abi: lagoonV2VaultAbi,
+        functionName: "settleRedeem",
+        args: [epoch],
+    }) as HexString;
+};
+
+export const lagoonV2SettleRedeemTrx = ({ vault, epoch }: { vault: Address; epoch: bigint }): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: vault,
+        value: 0n,
+        data: LagoonV2SettleRedeemCalldata({ epoch }),
+    });
+};
+
+/**
+ * Encodes an `updateNewTotalAssets(uint256 newTotalAssets)` call.
+ * Selector: 0xbcd1bf34
+ * Role: Valuation Manager
+ *
+ * Subject to guardrails when activated. Reverts ValuationUpdateNotAllowed()
+ * if a NAV is currently valid (isTotalAssetsValid()). The Safe must call
+ * lagoonV2ExpireTotalAssetsTrx first in that case.
+ */
+export const LagoonV2UpdateNewTotalAssetsCalldata = ({ newTotalAssets }: { newTotalAssets: bigint }): HexString => {
+    return encodeFunctionData({
+        abi: lagoonV2VaultAbi,
+        functionName: "updateNewTotalAssets",
+        args: [newTotalAssets],
+    }) as HexString;
+};
+
+export const lagoonV2UpdateNewTotalAssetsTrx = ({
+    vault,
+    newTotalAssets,
+}: {
+    vault: Address;
+    newTotalAssets: bigint;
+}): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: vault,
+        value: 0n,
+        data: LagoonV2UpdateNewTotalAssetsCalldata({ newTotalAssets }),
+    });
+};
+
+/**
+ * Encodes an `expireTotalAssets()` call.
+ * Selector: 0x927b15df
+ * Role: Safe
+ *
+ * Immediately invalidates the current NAV. Required before pushing a new NAV
+ * when isTotalAssetsValid() is true.
+ */
+export const LagoonV2ExpireTotalAssetsCalldata = (): HexString => {
+    return encodeFunctionData({
+        abi: lagoonV2VaultAbi,
+        functionName: "expireTotalAssets",
+        args: [],
+    }) as HexString;
+};
+
+export const lagoonV2ExpireTotalAssetsTrx = ({ vault }: { vault: Address }): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: vault,
+        value: 0n,
+        data: LagoonV2ExpireTotalAssetsCalldata(),
+    });
+};
+
+// ---------------------------------------------------------------------------
+// Guardian — pause / unpause
+// ---------------------------------------------------------------------------
+
+/**
+ * Encodes a `pause()` call.
+ * Selector: 0x8456cb59
+ * Role: Owner (Guardian in practice — Owner delegates pause authority)
+ *
+ * Halts all deposit and redeem operations. Emergency use only.
+ */
+export const LagoonV2PauseVaultCalldata = (): HexString => {
+    return encodeFunctionData({
+        abi: lagoonV2VaultAbi,
+        functionName: "pause",
+        args: [],
+    }) as HexString;
+};
+
+export const lagoonV2PauseVaultTrx = ({ vault }: { vault: Address }): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: vault,
+        value: 0n,
+        data: LagoonV2PauseVaultCalldata(),
+    });
+};
+
+/**
+ * Encodes an `unpause()` call.
+ * Selector: 0x3f4ba83a
+ * Role: Owner (Admin)
+ *
+ * Resumes normal vault operations after a pause.
+ */
+export const LagoonV2UnpauseVaultCalldata = (): HexString => {
+    return encodeFunctionData({
+        abi: lagoonV2VaultAbi,
+        functionName: "unpause",
+        args: [],
+    }) as HexString;
+};
+
+export const lagoonV2UnpauseVaultTrx = ({ vault }: { vault: Address }): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: vault,
+        value: 0n,
+        data: LagoonV2UnpauseVaultCalldata(),
+    });
+};
+
+// ---------------------------------------------------------------------------
+// Whitelist Manager — whitelist operations (Whitelist access mode)
+// ---------------------------------------------------------------------------
+
+/**
+ * Encodes an `addToWhitelist(address[] accounts)` call.
+ * Selector: 0x7f649783
+ * Role: Whitelist (Access) Manager
+ *
+ * Grants vault access when the vault is in Whitelist mode (AccessMode.Whitelist).
+ * In Blacklist mode this is still callable but has no gate effect.
+ */
+export const LagoonV2AddToWhitelistCalldata = ({ accounts }: { accounts: Address[] }): HexString => {
+    return encodeFunctionData({
+        abi: lagoonV2VaultAbi,
+        functionName: "addToWhitelist",
+        args: [accounts],
+    }) as HexString;
+};
+
+export const lagoonV2AddToWhitelistTrx = ({
+    vault,
+    accounts,
+}: {
+    vault: Address;
+    accounts: Address[];
+}): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: vault,
+        value: 0n,
+        data: LagoonV2AddToWhitelistCalldata({ accounts }),
+    });
+};
+
+/**
+ * Encodes a `revokeFromWhitelist(address[] accounts)` call.
+ * Selector: 0x86af6e68
+ * Role: Whitelist (Access) Manager
+ *
+ * Revokes vault access for addresses in Whitelist mode.
+ */
+export const LagoonV2RevokeFromWhitelistCalldata = ({ accounts }: { accounts: Address[] }): HexString => {
+    return encodeFunctionData({
+        abi: lagoonV2VaultAbi,
+        functionName: "revokeFromWhitelist",
+        args: [accounts],
+    }) as HexString;
+};
+
+export const lagoonV2RevokeFromWhitelistTrx = ({
+    vault,
+    accounts,
+}: {
+    vault: Address;
+    accounts: Address[];
+}): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: vault,
+        value: 0n,
+        data: LagoonV2RevokeFromWhitelistCalldata({ accounts }),
+    });
+};
+
+// ---------------------------------------------------------------------------
+// Whitelist Manager — blacklist operations (Blacklist access mode — NEW in v0.6)
+// ---------------------------------------------------------------------------
+
+/**
+ * Encodes an `addToBlacklist(address[] accounts)` call.
+ * Selector: 0x935eb35f
+ * Role: Whitelist (Access) Manager
+ *
+ * Blocks vault access and transfers for addresses in Blacklist mode.
+ * NEW in v0.6 — does not exist in v0.5.
+ */
+export const LagoonV2AddToBlacklistCalldata = ({ accounts }: { accounts: Address[] }): HexString => {
+    return encodeFunctionData({
+        abi: lagoonV2VaultAbi,
+        functionName: "addToBlacklist",
+        args: [accounts],
+    }) as HexString;
+};
+
+export const lagoonV2AddToBlacklistTrx = ({
+    vault,
+    accounts,
+}: {
+    vault: Address;
+    accounts: Address[];
+}): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: vault,
+        value: 0n,
+        data: LagoonV2AddToBlacklistCalldata({ accounts }),
+    });
+};
+
+/**
+ * Encodes a `revokeFromBlacklist(address[] accounts)` call.
+ * Selector: 0x4cc724c2
+ * Role: Whitelist (Access) Manager
+ *
+ * Removes addresses from the blacklist.
+ * NEW in v0.6 — does not exist in v0.5.
+ */
+export const LagoonV2RevokeFromBlacklistCalldata = ({ accounts }: { accounts: Address[] }): HexString => {
+    return encodeFunctionData({
+        abi: lagoonV2VaultAbi,
+        functionName: "revokeFromBlacklist",
+        args: [accounts],
+    }) as HexString;
+};
+
+export const lagoonV2RevokeFromBlacklistTrx = ({
+    vault,
+    accounts,
+}: {
+    vault: Address;
+    accounts: Address[];
+}): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: vault,
+        value: 0n,
+        data: LagoonV2RevokeFromBlacklistCalldata({ accounts }),
+    });
+};
+
+// ---------------------------------------------------------------------------
+// Admin — updateRates (5-field Rates struct — NEW ABI in v0.6)
+// ---------------------------------------------------------------------------
+
+/**
+ * Encodes an `updateRates((uint16,uint16,uint16,uint16,uint16) rates)` call.
+ * Selector: 0x0190b902
+ * Role: Owner (Admin)
+ *
+ * v0.6 CHANGE: v0.5 had `updateRates(uint16 managementRate, uint16 performanceRate)`
+ * (2 positional args). v0.6 uses a single Rates struct with 5 fields. The selector
+ * is therefore different and not backward-compatible with v0.5 callers.
+ *
+ * Rate-change rules:
+ *   - entryRate and exitRate can only DECREASE after first initialization.
+ *   - managementRate, performanceRate, and haircutRate can be raised or lowered
+ *     freely up to their respective caps.
+ *   - No cooldown mechanism (removed in v0.6).
+ */
+export const LagoonV2UpdateRatesCalldata = ({ rates }: { rates: LagoonV2Rates }): HexString => {
+    validateLagoonV2Rates(rates);
+
+    return encodeFunctionData({
+        abi: lagoonV2VaultAbi,
+        functionName: "updateRates",
+        args: [
+            {
+                managementRate: rates.managementRate,
+                performanceRate: rates.performanceRate,
+                entryRate: rates.entryRate,
+                exitRate: rates.exitRate,
+                haircutRate: rates.haircutRate,
+            },
+        ],
+    }) as HexString;
+};
+
+export const lagoonV2UpdateRatesTrx = ({
+    vault,
+    rates,
+}: {
+    vault: Address;
+    rates: LagoonV2Rates;
+}): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: vault,
+        value: 0n,
+        data: LagoonV2UpdateRatesCalldata({ rates }),
+    });
+};
+
+// ---------------------------------------------------------------------------
+// Admin — role setters
+// ---------------------------------------------------------------------------
+
+/**
+ * Encodes an `updateWhitelistManager(address)` call.
+ * Selector: 0xf1a76fcc
+ * Role: Owner (Admin)
+ */
+export const LagoonV2UpdateWhitelistManagerCalldata = ({
+    newWhitelistManager,
+}: {
+    newWhitelistManager: Address;
+}): HexString => {
+    return encodeFunctionData({
+        abi: lagoonV2VaultAbi,
+        functionName: "updateWhitelistManager",
+        args: [newWhitelistManager],
+    }) as HexString;
+};
+
+export const lagoonV2UpdateWhitelistManagerTrx = ({
+    vault,
+    newWhitelistManager,
+}: {
+    vault: Address;
+    newWhitelistManager: Address;
+}): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: vault,
+        value: 0n,
+        data: LagoonV2UpdateWhitelistManagerCalldata({ newWhitelistManager }),
+    });
+};
+
+/**
+ * Encodes an `updateValuationManager(address)` call.
+ * Selector: 0x65ccfcef
+ * Role: Owner (Admin)
+ */
+export const LagoonV2UpdateValuationManagerCalldata = ({
+    newValuationManager,
+}: {
+    newValuationManager: Address;
+}): HexString => {
+    return encodeFunctionData({
+        abi: lagoonV2VaultAbi,
+        functionName: "updateValuationManager",
+        args: [newValuationManager],
+    }) as HexString;
+};
+
+export const lagoonV2UpdateValuationManagerTrx = ({
+    vault,
+    newValuationManager,
+}: {
+    vault: Address;
+    newValuationManager: Address;
+}): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: vault,
+        value: 0n,
+        data: LagoonV2UpdateValuationManagerCalldata({ newValuationManager }),
+    });
+};
+
+/**
+ * Encodes an `updateFeeReceiver(address)` call.
+ * Selector: 0xc69bebe4
+ * Role: Owner (Admin)
+ */
+export const LagoonV2UpdateFeeReceiverCalldata = ({ newFeeReceiver }: { newFeeReceiver: Address }): HexString => {
+    return encodeFunctionData({
+        abi: lagoonV2VaultAbi,
+        functionName: "updateFeeReceiver",
+        args: [newFeeReceiver],
+    }) as HexString;
+};
+
+export const lagoonV2UpdateFeeReceiverTrx = ({
+    vault,
+    newFeeReceiver,
+}: {
+    vault: Address;
+    newFeeReceiver: Address;
+}): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: vault,
+        value: 0n,
+        data: LagoonV2UpdateFeeReceiverCalldata({ newFeeReceiver }),
+    });
+};
+
+/**
+ * Encodes an `updateSecurityCouncil(address)` call.
+ * Selector: 0xdbfe3e96
+ * Role: Owner (Admin)
+ *
+ * NEW in v0.6. The Security Council can bypass guardrails via
+ * securityCouncilUpdateTotalAssets() — treat this address as high-trust.
+ */
+export const LagoonV2UpdateSecurityCouncilCalldata = ({
+    newSecurityCouncil,
+}: {
+    newSecurityCouncil: Address;
+}): HexString => {
+    return encodeFunctionData({
+        abi: lagoonV2VaultAbi,
+        functionName: "updateSecurityCouncil",
+        args: [newSecurityCouncil],
+    }) as HexString;
+};
+
+export const lagoonV2UpdateSecurityCouncilTrx = ({
+    vault,
+    newSecurityCouncil,
+}: {
+    vault: Address;
+    newSecurityCouncil: Address;
+}): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: vault,
+        value: 0n,
+        data: LagoonV2UpdateSecurityCouncilCalldata({ newSecurityCouncil }),
+    });
+};
+
+/**
+ * Encodes an `updateSuperOperator(address)` call.
+ * Selector: 0x3a891d3b
+ * Role: Owner (Admin)
+ *
+ * NEW in v0.6. The Super Operator can act on behalf of any user without
+ * per-user approval (except for protocolFeeReceiver). Can be locked
+ * permanently via lockSuperOperator().
+ */
+export const LagoonV2UpdateSuperOperatorCalldata = ({ newSuperOperator }: { newSuperOperator: Address }): HexString => {
+    return encodeFunctionData({
+        abi: lagoonV2VaultAbi,
+        functionName: "updateSuperOperator",
+        args: [newSuperOperator],
+    }) as HexString;
+};
+
+export const lagoonV2UpdateSuperOperatorTrx = ({
+    vault,
+    newSuperOperator,
+}: {
+    vault: Address;
+    newSuperOperator: Address;
+}): Unwrapable<Call> => {
+    return createCall({
+        operation: 0,
+        to: vault,
+        value: 0n,
+        data: LagoonV2UpdateSuperOperatorCalldata({ newSuperOperator }),
+    });
+};