@ember-finance/sdk 1.0.28 → 1.1.0

package/dist/src/evm-vaults/on-chain-calls/onchain-calls.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMOnChainCalls = void 0;
+const ethers_1 = require("ethers");
+const deployment_parser_1 = require("../utils/deployment-parser");
+const tx_builder_1 = require("./tx-builder");
+/**
+ * EVM On-Chain Calls for Ember Protocol
+ *
+ * This class provides a higher-level interface for executing Ember Protocol
+ * transactions on EVM-compatible chains. It wraps the EVMTxBuilder and handles
+ * transaction encoding, signing, and execution using ethers.js.
+ *
+ * @example
+ * ```typescript
+ * import { EVMOnChainCalls } from "@ember-finance/sdk";
+ * import { ethers } from "ethers";
+ *
+ * const provider = new ethers.JsonRpcProvider("https://...");
+ * const signer = new ethers.Wallet(privateKey, provider);
+ *
+ * const onChainCalls = new EVMOnChainCalls(deployment, signer, provider);
+ *
+ * // Execute a transaction and wait for receipt with events
+ * const result = await onChainCalls.execCall(
+ *   onChainCalls.txBuilder.pauseDeposits(vaultAddress, true),
+ *   { waitForReceipt: true }
+ * );
+ * console.log("Events:", result.events);
+ * ```
+ */
+class EVMOnChainCalls {
+    constructor(_deployment, _signer, _provider, _walletAddress) {
+        this.parser = new deployment_parser_1.EVMDeploymentParser(_deployment);
+        this.txBuilder = new tx_builder_1.EVMTxBuilder(_deployment);
+        this.signer = _signer;
+        this.provider = _provider;
+        this.walletAddress = _walletAddress;
+    }
+    /**
+     * Updates the deployment configuration
+     * @param newDeployment The new deployment configuration
+     */
+    updateDeployment(newDeployment) {
+        this.parser.updateDeployment(newDeployment);
+        this.txBuilder.updateDeployment(newDeployment);
+    }
+    /**
+     * Gets the wallet address
+     * @returns The wallet address
+     */
+    async getWalletAddress() {
+        if (this.walletAddress) {
+            return this.walletAddress;
+        }
+        if (this.signer) {
+            return this.signer.getAddress();
+        }
+        throw new Error("No wallet address or signer available");
+    }
+    /**
+     * Encodes a transaction call into sendable transaction data using ethers.js
+     * @param txCall The transaction call object from TxBuilder
+     * @returns Encoded transaction ready to send
+     */
+    encodeTransaction(txCall) {
+        const iface = new ethers_1.Interface(txCall.abi);
+        const data = iface.encodeFunctionData(txCall.functionName, txCall.args);
+        return {
+            to: txCall.to,
+            data,
+            value: txCall.value
+        };
+    }
+    /**
+     * Decodes function result data using ethers.js
+     * @param abi The contract ABI
+     * @param functionName The function name
+     * @param data The encoded result data
+     * @returns Decoded result
+     */
+    decodeResult(abi, functionName, data) {
+        const iface = new ethers_1.Interface(abi);
+        return iface.decodeFunctionResult(functionName, data);
+    }
+    /**
+     * Parses logs from a transaction receipt into structured events
+     * @param logs The logs from the transaction receipt
+     * @param abi The ABI to use for parsing
+     * @returns Array of parsed events
+     */
+    parseEvents(logs, abi) {
+        const iface = new ethers_1.Interface(abi);
+        const events = [];
+        for (const log of logs) {
+            try {
+                const parsed = iface.parseLog({
+                    topics: log.topics,
+                    data: log.data
+                });
+                if (parsed) {
+                    // Convert Result to plain object
+                    const args = {};
+                    for (const key of Object.keys(parsed.args)) {
+                        // Skip numeric indices, keep named args
+                        if (isNaN(Number(key))) {
+                            args[key] = parsed.args[key];
+                        }
+                    }
+                    events.push({
+                        name: parsed.name,
+                        signature: parsed.signature,
+                        args,
+                        log
+                    });
+                }
+            }
+            catch {
+                // Log doesn't match this ABI, skip it
+            }
+        }
+        return events;
+    }
+    /**
+     * Executes a transaction call
+     * @param txCall The transaction call object
+     * @param options Optional execution parameters
+     * @returns Transaction response based on options
+     */
+    async execCall(txCall, options) {
+        if (options?.returnTxCall) {
+            return txCall;
+        }
+        const encodedTx = this.encodeTransaction(txCall);
+        if (options?.dryRun) {
+            if (!this.provider) {
+                throw new Error("Provider required for dry run");
+            }
+            try {
+                const resultData = await this.provider.call({
+                    to: encodedTx.to,
+                    data: encodedTx.data
+                });
+                // Decode the result if possible
+                let result;
+                try {
+                    result = this.decodeResult(txCall.abi, txCall.functionName, resultData);
+                }
+                catch {
+                    // Function might return void or decoding failed
+                    result = resultData;
+                }
+                return { success: true, result };
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                return { success: false, error: errorMessage };
+            }
+        }
+        if (!this.signer) {
+            throw new Error("Signer required to send transactions");
+        }
+        const txRequest = {
+            to: encodedTx.to,
+            data: encodedTx.data,
+            value: encodedTx.value
+        };
+        if (options?.gasLimit) {
+            txRequest.gasLimit = options.gasLimit;
+        }
+        const response = await this.signer.sendTransaction(txRequest);
+        // If waitForReceipt is true, wait for the transaction to be mined and parse events
+        if (options?.waitForReceipt) {
+            const confirmations = options.confirmations ?? 1;
+            const receipt = await response.wait(confirmations);
+            if (!receipt) {
+                throw new Error("Transaction receipt not available");
+            }
+            // Parse events from the receipt using the transaction's ABI
+            const events = this.parseEvents(receipt.logs, txCall.abi);
+            return {
+                response,
+                receipt,
+                events
+            };
+        }
+        return response;
+    }
+}
+exports.EVMOnChainCalls = EVMOnChainCalls;

package/dist/src/evm-vaults/on-chain-calls/operator.d.ts

@@ -0,0 +1,72 @@
+import { Signer, Provider } from "ethers";
+import { EVMOnChainCalls } from "./onchain-calls";
+import { IEvmDeployment, IEvmCallOptions, EvmOnChainCallResponse } from "../interfaces";
+import { NumStr } from "../../common/types";
+/**
+ * Operator Calls for Ember Protocol on EVM
+ *
+ * This class extends EVMOnChainCalls and provides operator-specific methods
+ * for managing vaults. Operators can process withdrawals, collect fees,
+ * and manage vault funds.
+ *
+ * Note: Rate updates are performed by the rate manager role, which may be
+ * the same as or different from the operator.
+ *
+ *
+ * @example
+ * ```typescript
+ * import { EVMOperatorCalls } from "@ember-finance/sdk";
+ * import { ethers } from "ethers";
+ *
+ * const provider = new ethers.JsonRpcProvider("https://...");
+ * const signer = new ethers.Wallet(privateKey, provider);
+ *
+ * const operatorCalls = new EVMOperatorCalls(deployment, signer, provider);
+ *
+ * // Process withdrawal requests
+ * await operatorCalls.processWithdrawalRequests(vaultAddress, 10);
+ *
+ * // Collect platform fees
+ * await operatorCalls.collectPlatformFee(vaultAddress);
+ *
+ * // Withdraw funds to sub-account for strategy
+ * await operatorCalls.withdrawFromVaultWithoutRedeemingShares(vaultAddress, subAccount, amount);
+ * ```
+ */
+export declare class EVMOperatorCalls extends EVMOnChainCalls {
+    constructor(_deployment: IEvmDeployment, _signer?: Signer, _provider?: Provider, _walletAddress?: string);
+    /**
+     * Update the rate of a vault
+     * Note: This requires the rate manager role, which may or may not be the operator
+     * @param vaultAddress The address of the vault
+     * @param rate The new rate to set for the vault
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    updateVaultRate(vaultAddress: string, rate: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Process withdrawal requests up to a maximum count
+     * @param vaultAddress The address of the vault
+     * @param maxRequestCount The maximum number of withdrawal requests to process
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    processWithdrawalRequests(vaultAddress: string, maxRequestCount: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Collect accrued platform fees from a vault
+     * @param vaultAddress The address of the vault
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    collectPlatformFee(vaultAddress: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Withdraw assets from the vault without redeeming shares
+     * Used by operators to move funds to sub-accounts for strategy execution
+     * @param vaultAddress The address of the vault
+     * @param subAccount The sub-account address to withdraw to
+     * @param amount The amount to withdraw
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    withdrawFromVaultWithoutRedeemingShares(vaultAddress: string, subAccount: string, amount: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+}

package/dist/src/evm-vaults/on-chain-calls/operator.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMOperatorCalls = void 0;
+const onchain_calls_1 = require("./onchain-calls");
+/**
+ * Operator Calls for Ember Protocol on EVM
+ *
+ * This class extends EVMOnChainCalls and provides operator-specific methods
+ * for managing vaults. Operators can process withdrawals, collect fees,
+ * and manage vault funds.
+ *
+ * Note: Rate updates are performed by the rate manager role, which may be
+ * the same as or different from the operator.
+ *
+ *
+ * @example
+ * ```typescript
+ * import { EVMOperatorCalls } from "@ember-finance/sdk";
+ * import { ethers } from "ethers";
+ *
+ * const provider = new ethers.JsonRpcProvider("https://...");
+ * const signer = new ethers.Wallet(privateKey, provider);
+ *
+ * const operatorCalls = new EVMOperatorCalls(deployment, signer, provider);
+ *
+ * // Process withdrawal requests
+ * await operatorCalls.processWithdrawalRequests(vaultAddress, 10);
+ *
+ * // Collect platform fees
+ * await operatorCalls.collectPlatformFee(vaultAddress);
+ *
+ * // Withdraw funds to sub-account for strategy
+ * await operatorCalls.withdrawFromVaultWithoutRedeemingShares(vaultAddress, subAccount, amount);
+ * ```
+ */
+class EVMOperatorCalls extends onchain_calls_1.EVMOnChainCalls {
+    constructor(_deployment, _signer, _provider, _walletAddress) {
+        super(_deployment, _signer, _provider, _walletAddress);
+    }
+    // ============================================
+    // Rate Management (Rate Manager Role)
+    // ============================================
+    /**
+     * Update the rate of a vault
+     * Note: This requires the rate manager role, which may or may not be the operator
+     * @param vaultAddress The address of the vault
+     * @param rate The new rate to set for the vault
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    async updateVaultRate(vaultAddress, rate, options) {
+        const txCall = this.txBuilder.updateVaultRate(vaultAddress, rate);
+        return this.execCall(txCall, options);
+    }
+    // ============================================
+    // Withdrawal Request Processing
+    // ============================================
+    /**
+     * Process withdrawal requests up to a maximum count
+     * @param vaultAddress The address of the vault
+     * @param maxRequestCount The maximum number of withdrawal requests to process
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    async processWithdrawalRequests(vaultAddress, maxRequestCount, options) {
+        const txCall = this.txBuilder.processWithdrawalRequests(vaultAddress, maxRequestCount);
+        return this.execCall(txCall, options);
+    }
+    // ============================================
+    // Fee Collection
+    // ============================================
+    /**
+     * Collect accrued platform fees from a vault
+     * @param vaultAddress The address of the vault
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    async collectPlatformFee(vaultAddress, options) {
+        const txCall = this.txBuilder.collectPlatformFee(vaultAddress);
+        return this.execCall(txCall, options);
+    }
+    // ============================================
+    // Fund Management
+    // ============================================
+    /**
+     * Withdraw assets from the vault without redeeming shares
+     * Used by operators to move funds to sub-accounts for strategy execution
+     * @param vaultAddress The address of the vault
+     * @param subAccount The sub-account address to withdraw to
+     * @param amount The amount to withdraw
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    async withdrawFromVaultWithoutRedeemingShares(vaultAddress, subAccount, amount, options) {
+        const txCall = this.txBuilder.withdrawFromVaultWithoutRedeemingShares(vaultAddress, subAccount, amount);
+        return this.execCall(txCall, options);
+    }
+}
+exports.EVMOperatorCalls = EVMOperatorCalls;

package/dist/src/evm-vaults/on-chain-calls/tx-builder.d.ts

@@ -0,0 +1,250 @@
+import { EVMDeploymentParser } from "../utils";
+import { IEvmDeployment, VaultPauseOperation, ITransactionCall } from "../interfaces";
+import { NumStr } from "../../common/types";
+/**
+ * EVM Transaction Builder for Ember Protocol (ERC-4626 Compatible)
+ *
+ * This class provides methods to build transaction calls for the Ember Protocol
+ * on EVM-compatible chains. The vault contracts now implement ERC-4626 standard
+ * and are themselves ERC20 tokens representing shares.
+ *
+ * @example
+ * ```typescript
+ * import { EVMTxBuilder } from "@ember-finance/sdk";
+ * import { encodeFunctionData } from "viem";
+ *
+ * const txBuilder = new EVMTxBuilder(deployment);
+ * const txCall = txBuilder.deposit(vaultAddress, amount, receiver);
+ *
+ * // Encode with viem
+ * const data = encodeFunctionData({
+ *   abi: txCall.abi,
+ *   functionName: txCall.functionName,
+ *   args: txCall.args
+ * });
+ *
+ * // Or with ethers.js
+ * const contract = new ethers.Contract(txCall.to, txCall.abi, signer);
+ * await contract[txCall.functionName](...txCall.args);
+ * ```
+ */
+export declare class EVMTxBuilder {
+    parser: EVMDeploymentParser;
+    constructor(_deployment: IEvmDeployment);
+    /**
+     * Updates the deployment configuration
+     * @param newDeployment The new deployment configuration
+     */
+    updateDeployment(newDeployment: IEvmDeployment): void;
+    /**
+     * Gets the chain ID from the deployment
+     */
+    getChainId(): string;
+    /**
+     * Pauses or unpauses non-admin operations at the protocol level
+     * @param pause True to pause, false to unpause
+     * @returns Transaction call object
+     */
+    pauseNonAdminOperations(pause: boolean): ITransactionCall;
+    /**
+     * Updates the platform fee recipient address
+     * @param recipient New recipient address
+     * @returns Transaction call object
+     */
+    updatePlatformFeeRecipient(recipient: string): ITransactionCall;
+    /**
+     * Updates the minimum rate for the protocol
+     * @param minRate New minimum rate
+     * @returns Transaction call object
+     */
+    updateMinRate(minRate: NumStr): ITransactionCall;
+    /**
+     * Updates the maximum rate for the protocol
+     * @param maxRate New maximum rate
+     * @returns Transaction call object
+     */
+    updateMaxRate(maxRate: NumStr): ITransactionCall;
+    /**
+     * Updates the maximum rate interval for the protocol
+     * @param maxRateInterval New maximum rate interval
+     * @returns Transaction call object
+     */
+    updateMaxRateInterval(maxRateInterval: NumStr): ITransactionCall;
+    /**
+     * Updates the minimum rate interval for the protocol
+     * @param minRateInterval New minimum rate interval
+     * @returns Transaction call object
+     */
+    updateMinRateInterval(minRateInterval: NumStr): ITransactionCall;
+    /**
+     * Updates the default rate for the protocol
+     * @param defaultRate New default rate
+     * @returns Transaction call object
+     */
+    updateDefaultRate(defaultRate: NumStr): ITransactionCall;
+    /**
+     * Updates the maximum fee percentage for the protocol
+     * @param maxFeePercentage New maximum fee percentage
+     * @returns Transaction call object
+     */
+    updateMaxFeePercentage(maxFeePercentage: NumStr): ITransactionCall;
+    /**
+     * Sets whether an account is blacklisted at the protocol level
+     * @param account Address of the account
+     * @param isBlacklisted Whether the account should be blacklisted
+     * @returns Transaction call object
+     */
+    setBlacklistedAccount(account: string, isBlacklisted: boolean): ITransactionCall;
+    /**
+     * Updates the admin of a vault (called via ProtocolConfig)
+     * @param vaultAddress Address of the vault
+     * @param newAdmin New admin address
+     * @returns Transaction call object
+     */
+    updateVaultAdmin(vaultAddress: string, newAdmin: string): ITransactionCall;
+    /**
+     * Updates the paused status of a vault operation (called via ProtocolConfig)
+     * @param vaultAddress Address of the vault
+     * @param operation The operation to pause/unpause ("deposits", "withdrawals", or "privilegedOperations")
+     * @param paused Whether to pause or unpause
+     * @returns Transaction call object
+     */
+    setVaultPausedStatus(vaultAddress: string, operation: VaultPauseOperation, paused: boolean): ITransactionCall;
+    /**
+     * Updates the operator of a vault (called via ProtocolConfig)
+     * @param vaultAddress Address of the vault
+     * @param newOperator New operator address
+     * @returns Transaction call object
+     */
+    updateVaultOperator(vaultAddress: string, newOperator: string): ITransactionCall;
+    /**
+     * Updates the rate manager of a vault (called via ProtocolConfig)
+     * @param vaultAddress Address of the vault
+     * @param newRateManager New rate manager address
+     * @returns Transaction call object
+     */
+    updateVaultRateManager(vaultAddress: string, newRateManager: string): ITransactionCall;
+    /**
+     * Updates the minimum withdrawable shares of a vault (called via ProtocolConfig)
+     * @param vaultAddress Address of the vault
+     * @param minWithdrawableShares New minimum withdrawable shares
+     * @returns Transaction call object
+     */
+    updateVaultMinWithdrawableShares(vaultAddress: string, minWithdrawableShares: NumStr): ITransactionCall;
+    /**
+     * Sets a sub-account for the vault (called via ProtocolConfig)
+     * @param vaultAddress Address of the vault
+     * @param account Address of the account
+     * @param isSubAccount Whether the account should be a sub-account
+     * @returns Transaction call object
+     */
+    setVaultSubAccount(vaultAddress: string, account: string, isSubAccount: boolean): ITransactionCall;
+    /**
+     * Updates the maximum TVL of a vault (called via ProtocolConfig)
+     * @param vaultAddress Address of the vault
+     * @param maxTVL New maximum TVL
+     * @returns Transaction call object
+     */
+    updateVaultMaxTVL(vaultAddress: string, maxTVL: NumStr): ITransactionCall;
+    /**
+     * Updates the rate update interval of a vault (called via ProtocolConfig)
+     * @param vaultAddress Address of the vault
+     * @param newInterval New rate update interval
+     * @returns Transaction call object
+     */
+    updateVaultRateUpdateInterval(vaultAddress: string, newInterval: NumStr): ITransactionCall;
+    /**
+     * Updates the fee percentage of a vault (called via ProtocolConfig)
+     * @param vaultAddress Address of the vault
+     * @param newFeePercentage New fee percentage
+     * @returns Transaction call object
+     */
+    updateVaultFeePercentage(vaultAddress: string, newFeePercentage: NumStr): ITransactionCall;
+    /**
+     * Updates the name of a vault (called via ProtocolConfig)
+     * @param vaultAddress Address of the vault
+     * @param newName New vault name
+     * @returns Transaction call object
+     */
+    updateVaultName(vaultAddress: string, newName: string): ITransactionCall;
+    /**
+     * Updates the rate of a vault (rate manager only)
+     * @param vaultAddress Address of the vault
+     * @param newRate New rate value
+     * @returns Transaction call object
+     */
+    updateVaultRate(vaultAddress: string, newRate: NumStr): ITransactionCall;
+    /**
+     * Processes a specified number of withdrawal requests (operator only)
+     * @param vaultAddress Address of the vault
+     * @param numRequests Maximum number of requests to process
+     * @returns Transaction call object
+     */
+    processWithdrawalRequests(vaultAddress: string, numRequests: NumStr): ITransactionCall;
+    /**
+     * Collects accrued platform fees (operator only)
+     * @param vaultAddress Address of the vault
+     * @returns Transaction call object
+     */
+    collectPlatformFee(vaultAddress: string): ITransactionCall;
+    /**
+     * Withdraws assets from the vault without redeeming shares (operator only)
+     * Used by operators to move funds to sub-accounts for strategy execution
+     * @param vaultAddress Address of the vault
+     * @param subAccount The sub-account address to withdraw to
+     * @param amount Amount to withdraw
+     * @returns Transaction call object
+     */
+    withdrawFromVaultWithoutRedeemingShares(vaultAddress: string, subAccount: string, amount: NumStr): ITransactionCall;
+    /**
+     * Deposits assets to a vault and mints shares (ERC-4626 standard)
+     * @param vaultAddress Address of the vault
+     * @param assets Amount of assets to deposit
+     * @param receiver Address to receive the shares
+     * @returns Transaction call object
+     */
+    deposit(vaultAddress: string, assets: NumStr, receiver: string): ITransactionCall;
+    /**
+     * Mints a specific number of shares by depositing assets (ERC-4626 standard)
+     * @param vaultAddress Address of the vault
+     * @param shares Amount of shares to mint
+     * @param receiver Address to receive the shares
+     * @returns Transaction call object
+     */
+    mint(vaultAddress: string, shares: NumStr, receiver: string): ITransactionCall;
+    /**
+     * Redeems shares to initiate a withdrawal request
+     * @param vaultAddress Address of the vault
+     * @param shares Amount of shares to redeem
+     * @param receiver Address to receive the withdrawn funds
+     * @returns Transaction call object
+     */
+    redeemShares(vaultAddress: string, shares: NumStr, receiver: string): ITransactionCall;
+    /**
+     * Cancels a pending withdrawal request
+     * @param vaultAddress Address of the vault
+     * @param requestSequenceNumber Sequence number of the withdrawal request to cancel
+     * @returns Transaction call object
+     */
+    cancelPendingWithdrawalRequest(vaultAddress: string, requestSequenceNumber: NumStr): ITransactionCall;
+    /**
+     * Approves a token for spending by the vault
+     * @param tokenAddress Address of the token
+     * @param spender Address of the spender (usually the vault)
+     * @param amount Amount to approve
+     * @returns Transaction call object
+     */
+    approveToken(tokenAddress: string, spender: string, amount: NumStr): ITransactionCall;
+    /**
+     * Gets the EmberVault ABI
+     */
+    static getVaultABI(): unknown[];
+    /**
+     * Gets the EmberProtocolConfig ABI
+     */
+    static getProtocolConfigABI(): unknown[];
+    /**
+     * Gets the ERC20Token ABI
+     */
+    static getERC20ABI(): unknown[];
+}