@ember-finance/sdk 1.0.29 → 1.1.0

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

@@ -0,0 +1,108 @@
+import { Signer, Provider } from "ethers";
+import { EVMOnChainCalls } from "./onchain-calls";
+import { IEvmDeployment, IEvmCallOptions, EvmOnChainCallResponse } from "../interfaces";
+import { NumStr } from "../../common/types";
+/**
+ * Admin Calls for Ember Protocol on EVM
+ *
+ * This class extends EVMOnChainCalls and provides admin-specific methods
+ * for managing the Ember Protocol configuration and vault administration.
+ *
+ * The protocol admin can:
+ * - Update vault admins
+ * - Configure protocol-level parameters (fees, rates, intervals)
+ * - Manage blacklisted accounts
+ * - Pause/unpause non-admin operations
+ *
+ * @example
+ * ```typescript
+ * import { EVMAdminCalls } from "@ember-finance/sdk";
+ * import { ethers } from "ethers";
+ *
+ * const provider = new ethers.JsonRpcProvider("https://...");
+ * const signer = new ethers.Wallet(privateKey, provider);
+ *
+ * const adminCalls = new EVMAdminCalls(deployment, signer, provider);
+ *
+ * // Update protocol configuration
+ * await adminCalls.updateMaxFeePercentage(newFeePercentage);
+ *
+ * // Update vault admin
+ * await adminCalls.updateVaultAdmin(vaultAddress, newAdminAddress);
+ * ```
+ */
+export declare class EVMAdminCalls extends EVMOnChainCalls {
+    constructor(_deployment: IEvmDeployment, _signer?: Signer, _provider?: Provider, _walletAddress?: string);
+    /**
+     * Update the admin address of a vault
+     * @param vaultAddress The address of the vault
+     * @param adminAddress The new admin address
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    updateVaultAdmin(vaultAddress: string, adminAddress: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Update the max fee percentage of the protocol
+     * @param maxFeePercentage The new max fee percentage
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    updateMaxFeePercentage(maxFeePercentage: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Update the default rate of the protocol
+     * @param defaultRate The new default rate
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    updateDefaultRate(defaultRate: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Update the max rate of the protocol
+     * @param maxRate The new max rate
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    updateMaxRate(maxRate: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Update the min rate of the protocol
+     * @param minRate The new min rate
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    updateMinRate(minRate: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Update the platform fee recipient of the protocol
+     * @param platformFeeRecipient The new platform fee recipient address
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    updatePlatformFeeRecipient(platformFeeRecipient: string, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Pause or unpause non-admin operations at the protocol level
+     * @param pause Whether to pause non-admin operations
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    pauseNonAdminOperations(pause: boolean, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Update the max rate interval of the protocol
+     * @param maxRateInterval The new max rate interval
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    updateMaxRateInterval(maxRateInterval: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Update the min rate interval of the protocol
+     * @param minRateInterval The new min rate interval
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    updateMinRateInterval(minRateInterval: NumStr, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+    /**
+     * Set whether an account is blacklisted at the protocol level
+     * @param account The address of the account
+     * @param isBlacklisted Whether the account should be blacklisted
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    setBlacklistedAccount(account: string, isBlacklisted: boolean, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+}

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

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVMAdminCalls = void 0;
+const onchain_calls_1 = require("./onchain-calls");
+/**
+ * Admin Calls for Ember Protocol on EVM
+ *
+ * This class extends EVMOnChainCalls and provides admin-specific methods
+ * for managing the Ember Protocol configuration and vault administration.
+ *
+ * The protocol admin can:
+ * - Update vault admins
+ * - Configure protocol-level parameters (fees, rates, intervals)
+ * - Manage blacklisted accounts
+ * - Pause/unpause non-admin operations
+ *
+ * @example
+ * ```typescript
+ * import { EVMAdminCalls } from "@ember-finance/sdk";
+ * import { ethers } from "ethers";
+ *
+ * const provider = new ethers.JsonRpcProvider("https://...");
+ * const signer = new ethers.Wallet(privateKey, provider);
+ *
+ * const adminCalls = new EVMAdminCalls(deployment, signer, provider);
+ *
+ * // Update protocol configuration
+ * await adminCalls.updateMaxFeePercentage(newFeePercentage);
+ *
+ * // Update vault admin
+ * await adminCalls.updateVaultAdmin(vaultAddress, newAdminAddress);
+ * ```
+ */
+class EVMAdminCalls extends onchain_calls_1.EVMOnChainCalls {
+    constructor(_deployment, _signer, _provider, _walletAddress) {
+        super(_deployment, _signer, _provider, _walletAddress);
+    }
+    // ============================================
+    // Vault Admin Management
+    // ============================================
+    /**
+     * Update the admin address of a vault
+     * @param vaultAddress The address of the vault
+     * @param adminAddress The new admin address
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    async updateVaultAdmin(vaultAddress, adminAddress, options) {
+        const txCall = this.txBuilder.updateVaultAdmin(vaultAddress, adminAddress);
+        return this.execCall(txCall, options);
+    }
+    // ============================================
+    // Protocol Config Admin Methods
+    // ============================================
+    /**
+     * Update the max fee percentage of the protocol
+     * @param maxFeePercentage The new max fee percentage
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    async updateMaxFeePercentage(maxFeePercentage, options) {
+        const txCall = this.txBuilder.updateMaxFeePercentage(maxFeePercentage);
+        return this.execCall(txCall, options);
+    }
+    /**
+     * Update the default rate of the protocol
+     * @param defaultRate The new default rate
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    async updateDefaultRate(defaultRate, options) {
+        const txCall = this.txBuilder.updateDefaultRate(defaultRate);
+        return this.execCall(txCall, options);
+    }
+    /**
+     * Update the max rate of the protocol
+     * @param maxRate The new max rate
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    async updateMaxRate(maxRate, options) {
+        const txCall = this.txBuilder.updateMaxRate(maxRate);
+        return this.execCall(txCall, options);
+    }
+    /**
+     * Update the min rate of the protocol
+     * @param minRate The new min rate
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    async updateMinRate(minRate, options) {
+        const txCall = this.txBuilder.updateMinRate(minRate);
+        return this.execCall(txCall, options);
+    }
+    /**
+     * Update the platform fee recipient of the protocol
+     * @param platformFeeRecipient The new platform fee recipient address
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    async updatePlatformFeeRecipient(platformFeeRecipient, options) {
+        const txCall = this.txBuilder.updatePlatformFeeRecipient(platformFeeRecipient);
+        return this.execCall(txCall, options);
+    }
+    /**
+     * Pause or unpause non-admin operations at the protocol level
+     * @param pause Whether to pause non-admin operations
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    async pauseNonAdminOperations(pause, options) {
+        const txCall = this.txBuilder.pauseNonAdminOperations(pause);
+        return this.execCall(txCall, options);
+    }
+    /**
+     * Update the max rate interval of the protocol
+     * @param maxRateInterval The new max rate interval
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    async updateMaxRateInterval(maxRateInterval, options) {
+        const txCall = this.txBuilder.updateMaxRateInterval(maxRateInterval);
+        return this.execCall(txCall, options);
+    }
+    /**
+     * Update the min rate interval of the protocol
+     * @param minRateInterval The new min rate interval
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    async updateMinRateInterval(minRateInterval, options) {
+        const txCall = this.txBuilder.updateMinRateInterval(minRateInterval);
+        return this.execCall(txCall, options);
+    }
+    /**
+     * Set whether an account is blacklisted at the protocol level
+     * @param account The address of the account
+     * @param isBlacklisted Whether the account should be blacklisted
+     * @param options Optional tx execution params
+     * @returns EvmOnChainCallResponse
+     */
+    async setBlacklistedAccount(account, isBlacklisted, options) {
+        const txCall = this.txBuilder.setBlacklistedAccount(account, isBlacklisted);
+        return this.execCall(txCall, options);
+    }
+}
+exports.EVMAdminCalls = EVMAdminCalls;

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

@@ -0,0 +1,7 @@
+export * from "./tx-builder";
+export * from "./onchain-calls";
+export * from "./admin";
+export * from "./operator";
+export * from "./vault-admin";
+export * from "./user";
+export * from "./vault-reader";

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

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./tx-builder"), exports);
+__exportStar(require("./onchain-calls"), exports);
+__exportStar(require("./admin"), exports);
+__exportStar(require("./operator"), exports);
+__exportStar(require("./vault-admin"), exports);
+__exportStar(require("./user"), exports);
+__exportStar(require("./vault-reader"), exports);

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

@@ -0,0 +1,79 @@
+import { Signer, Provider, Log } from "ethers";
+import { EVMDeploymentParser } from "../utils/deployment-parser";
+import { EvmOnChainCallResponse, IEvmCallOptions, IEvmDeployment, ITransactionCall, IParsedEvent } from "../interfaces";
+import { EVMTxBuilder } from "./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);
+ * ```
+ */
+export declare class EVMOnChainCalls {
+    parser: EVMDeploymentParser;
+    txBuilder: EVMTxBuilder;
+    signer?: Signer;
+    provider?: Provider;
+    walletAddress?: string;
+    constructor(_deployment: IEvmDeployment, _signer?: Signer, _provider?: Provider, _walletAddress?: string);
+    /**
+     * Updates the deployment configuration
+     * @param newDeployment The new deployment configuration
+     */
+    updateDeployment(newDeployment: IEvmDeployment): void;
+    /**
+     * Gets the wallet address
+     * @returns The wallet address
+     */
+    getWalletAddress(): Promise<string>;
+    /**
+     * 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: ITransactionCall): {
+        to: string;
+        data: string;
+        value: bigint;
+    };
+    /**
+     * 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: unknown[], functionName: string, data: string): unknown;
+    /**
+     * 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: readonly Log[], abi: unknown[]): IParsedEvent[];
+    /**
+     * Executes a transaction call
+     * @param txCall The transaction call object
+     * @param options Optional execution parameters
+     * @returns Transaction response based on options
+     */
+    execCall(txCall: ITransactionCall, options?: IEvmCallOptions): Promise<EvmOnChainCallResponse>;
+}

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>;
+}