viem 2.55.11 → 2.55.13

package/_cjs/tempo/actions/earn/deployment.js

@@ -0,0 +1,654 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeployErc4626StackError = void 0;
+exports.createErc4626Engine = createErc4626Engine;
+exports.createErc4626EngineSync = createErc4626EngineSync;
+exports.createStack = createStack;
+exports.createStackSync = createStackSync;
+exports.bindErc4626Engine = bindErc4626Engine;
+exports.bindErc4626EngineSync = bindErc4626EngineSync;
+exports.deployErc4626StackSync = deployErc4626StackSync;
+const ox_1 = require("ox");
+const parseAccount_js_1 = require("../../../accounts/utils/parseAccount.js");
+const getCode_js_1 = require("../../../actions/public/getCode.js");
+const getLogs_js_1 = require("../../../actions/public/getLogs.js");
+const readContract_js_1 = require("../../../actions/public/readContract.js");
+const simulateContract_js_1 = require("../../../actions/public/simulateContract.js");
+const writeContract_js_1 = require("../../../actions/wallet/writeContract.js");
+const writeContractSync_js_1 = require("../../../actions/wallet/writeContractSync.js");
+const address_js_1 = require("../../../constants/address.js");
+const number_js_1 = require("../../../constants/number.js");
+const account_js_1 = require("../../../errors/account.js");
+const base_js_1 = require("../../../errors/base.js");
+const transaction_js_1 = require("../../../errors/transaction.js");
+const getAbiItem_js_1 = require("../../../utils/abi/getAbiItem.js");
+const parseEventLogs_js_1 = require("../../../utils/abi/parseEventLogs.js");
+const isAddressEqual_js_1 = require("../../../utils/address/isAddressEqual.js");
+const Abis = require("../../Abis.js");
+const Addresses = require("../../Addresses.js");
+const utils_js_1 = require("../../internal/utils.js");
+async function createErc4626Engine(client, parameters) {
+    return createErc4626Engine.inner(writeContract_js_1.writeContract, client, parameters);
+}
+(function (createErc4626Engine) {
+    async function inner(action, client, parameters) {
+        const { account = client.account, chain = client.chain, deploymentId, factory, name, owner: owner_ = account, symbol, venue, ...rest } = parameters;
+        if (!account)
+            throw new account_js_1.AccountNotFoundError();
+        if (!owner_)
+            throw new Error('`owner` is required.');
+        const owner = (0, parseAccount_js_1.parseAccount)(owner_).address;
+        return (await action(client, {
+            ...rest,
+            account,
+            chain,
+            ...createErc4626Engine.call({
+                deploymentId,
+                factory,
+                name,
+                owner,
+                symbol,
+                venue,
+            }),
+        }));
+    }
+    createErc4626Engine.inner = inner;
+    function call(args) {
+        validateDeploymentId(args.deploymentId);
+        return (0, utils_js_1.defineCall)({
+            address: args.factory,
+            abi: Abis.erc4626EngineFactory,
+            functionName: 'deploy',
+            args: [
+                args.deploymentId,
+                args.venue,
+                args.owner,
+                args.name ?? '',
+                args.symbol ?? '',
+            ],
+        });
+    }
+    createErc4626Engine.call = call;
+    async function predict(client, args) {
+        validateDeploymentId(args.deploymentId);
+        return (0, readContract_js_1.readContract)(client, {
+            address: args.factory,
+            abi: Abis.erc4626EngineFactory,
+            functionName: 'predictEngine',
+            args: [
+                args.deploymentId,
+                args.venue,
+                args.owner,
+                args.name ?? '',
+                args.symbol ?? '',
+            ],
+        });
+    }
+    createErc4626Engine.predict = predict;
+    function extractEvent(logs, parameters) {
+        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
+            abi: Abis.erc4626EngineFactory,
+            eventName: 'ERC4626EngineDeployed',
+            logs: logs.filter((log) => (0, isAddressEqual_js_1.isAddressEqual)(log.address, parameters.factory)),
+            strict: true,
+        });
+        if (!log)
+            throw new Error('`ERC4626EngineDeployed` event not found.');
+        return log;
+    }
+    createErc4626Engine.extractEvent = extractEvent;
+})(createErc4626Engine || (exports.createErc4626Engine = createErc4626Engine = {}));
+async function createErc4626EngineSync(client, parameters) {
+    const { factory, throwOnReceiptRevert = true } = parameters;
+    const receipt = await createErc4626Engine.inner(writeContractSync_js_1.writeContractSync, client, {
+        ...parameters,
+        throwOnReceiptRevert,
+    });
+    const { args } = createErc4626Engine.extractEvent(receipt.logs, { factory });
+    return { ...args, receipt };
+}
+async function createStack(client, parameters) {
+    return createStack.inner(writeContract_js_1.writeContract, client, parameters);
+}
+(function (createStack) {
+    async function inner(action, client, parameters) {
+        const { account = client.account, chain = client.chain, controls, deploymentId, distributor, engine, factory, fees, owner: owner_ = account, transferPolicyId, ...rest } = parameters;
+        if (!account)
+            throw new account_js_1.AccountNotFoundError();
+        if (!owner_)
+            throw new Error('`owner` is required.');
+        return (await action(client, {
+            ...rest,
+            account,
+            chain,
+            ...createStack.call({
+                controls,
+                deploymentId,
+                distributor,
+                engine,
+                factory,
+                fees,
+                owner: (0, parseAccount_js_1.parseAccount)(owner_).address,
+                transferPolicyId,
+            }),
+        }));
+    }
+    createStack.inner = inner;
+    function call(args) {
+        validateDeploymentId(args.deploymentId);
+        return (0, utils_js_1.defineCall)({
+            address: args.factory,
+            abi: Abis.earnFactory,
+            functionName: 'deploy',
+            args: [toDeployParameters(args)],
+        });
+    }
+    createStack.call = call;
+    async function predict(client, args) {
+        validateDeploymentId(args.deploymentId);
+        const parameters = toDeployParameters(args);
+        const [earnShare, earnFees] = await Promise.all([
+            (0, readContract_js_1.readContract)(client, {
+                address: args.factory,
+                abi: Abis.earnFactory,
+                functionName: 'predictEarnShare',
+                args: [parameters],
+            }),
+            (0, readContract_js_1.readContract)(client, {
+                address: args.factory,
+                abi: Abis.earnFactory,
+                functionName: 'predictEarnFees',
+                args: [parameters],
+            }),
+        ]);
+        return { earnFees, earnShare };
+    }
+    createStack.predict = predict;
+    function extractEvent(logs, parameters) {
+        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
+            abi: Abis.earnFactory,
+            eventName: 'EarnStackDeployed',
+            logs: logs.filter((log) => (0, isAddressEqual_js_1.isAddressEqual)(log.address, parameters.factory)),
+            strict: true,
+        });
+        if (!log)
+            throw new Error('`EarnStackDeployed` event not found.');
+        return log;
+    }
+    createStack.extractEvent = extractEvent;
+})(createStack || (exports.createStack = createStack = {}));
+async function createStackSync(client, parameters) {
+    const { factory, throwOnReceiptRevert = true } = parameters;
+    const receipt = await createStack.inner(writeContractSync_js_1.writeContractSync, client, {
+        ...parameters,
+        throwOnReceiptRevert,
+    });
+    const { args } = createStack.extractEvent(receipt.logs, { factory });
+    return { ...args, receipt };
+}
+async function bindErc4626Engine(client, parameters) {
+    return bindErc4626Engine.inner(writeContract_js_1.writeContract, client, parameters);
+}
+(function (bindErc4626Engine) {
+    async function inner(action, client, parameters) {
+        const { engine, vault, ...rest } = parameters;
+        return (await action(client, {
+            ...rest,
+            ...bindErc4626Engine.call({ engine, vault }),
+        }));
+    }
+    bindErc4626Engine.inner = inner;
+    function call(args) {
+        return (0, utils_js_1.defineCall)({
+            address: args.engine,
+            abi: Abis.erc4626Engine,
+            functionName: 'initializeEarnVault',
+            args: [args.vault],
+        });
+    }
+    bindErc4626Engine.call = call;
+    function extractEvent(logs, parameters) {
+        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
+            abi: Abis.erc4626Engine,
+            eventName: 'EarnVaultInitialized',
+            logs: logs.filter((log) => (0, isAddressEqual_js_1.isAddressEqual)(log.address, parameters.engine)),
+            strict: true,
+        });
+        if (!log)
+            throw new Error('`EarnVaultInitialized` event not found.');
+        return log;
+    }
+    bindErc4626Engine.extractEvent = extractEvent;
+})(bindErc4626Engine || (exports.bindErc4626Engine = bindErc4626Engine = {}));
+async function bindErc4626EngineSync(client, parameters) {
+    const { engine, throwOnReceiptRevert = true } = parameters;
+    const receipt = await bindErc4626Engine.inner(writeContractSync_js_1.writeContractSync, client, {
+        ...parameters,
+        throwOnReceiptRevert,
+    });
+    const { args } = bindErc4626Engine.extractEvent(receipt.logs, { engine });
+    return { engine, vault: args.earnVault, receipt };
+}
+class DeployErc4626StackError extends base_js_1.BaseError {
+    constructor(cause, parameters) {
+        super(`ERC-4626 Earn deployment failed during ${parameters.stage}.`, {
+            cause,
+            name: 'DeployErc4626StackError',
+        });
+        Object.defineProperty(this, "receipts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "state", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.receipts = parameters.receipts;
+        this.stage = parameters.stage;
+        this.state = parameters.state;
+    }
+}
+exports.DeployErc4626StackError = DeployErc4626StackError;
+async function deployErc4626StackSync(client, parameters) {
+    const deployer = parameters.account ?? client.account;
+    if (!deployer)
+        throw new account_js_1.AccountNotFoundError();
+    const owner_ = parameters.owner ?? deployer;
+    const owner = (0, parseAccount_js_1.parseAccount)(owner_).address;
+    const deployerAddress = (0, parseAccount_js_1.parseAccount)(deployer).address;
+    const bindingAccount = (() => {
+        if (parameters.bindingAccount)
+            return parameters.bindingAccount;
+        if (typeof owner_ !== 'string')
+            return owner_;
+        if ((0, isAddressEqual_js_1.isAddressEqual)(owner, deployerAddress))
+            return deployer;
+        return undefined;
+    })();
+    if (bindingAccount &&
+        !(0, isAddressEqual_js_1.isAddressEqual)((0, parseAccount_js_1.parseAccount)(bindingAccount).address, owner))
+        throw new Error('`bindingAccount` must match `owner`.');
+    validateDeploymentId(parameters.deploymentId);
+    if (parameters.resume &&
+        parameters.resume.deploymentId.toLowerCase() !==
+            parameters.deploymentId.toLowerCase())
+        throw new Error('The resumed deployment ID does not match `deploymentId`.');
+    await validateContracts(client, {
+        factories: parameters.factories,
+        venue: parameters.venue,
+    });
+    const { gas: _, keyAuthorization: __, nonce: ___, ...sharedWriteParameters } = (0, utils_js_1.pickWriteParameters)(parameters);
+    const writeParameters = {
+        ...sharedWriteParameters,
+        ...(0, utils_js_1.pickWriteSyncParameters)(parameters),
+        account: deployer,
+        throwOnReceiptRevert: true,
+    };
+    const engineArgs = {
+        deploymentId: parameters.deploymentId,
+        factory: parameters.factories.erc4626Engine,
+        name: parameters.name,
+        owner,
+        symbol: parameters.symbol,
+        venue: parameters.venue,
+    };
+    const predictedEngine = await createErc4626Engine.predict(client, engineArgs);
+    const state = {
+        deploymentId: parameters.deploymentId,
+        earnShare: parameters.resume?.earnShare,
+        engine: predictedEngine,
+        fees: parameters.resume?.fees,
+        vault: parameters.resume?.vault,
+    };
+    if (parameters.resume?.engine &&
+        !(0, isAddressEqual_js_1.isAddressEqual)(parameters.resume.engine, predictedEngine))
+        throw new Error('The resumed engine does not match the factory prediction.');
+    const engineExists = await hasCode(client, predictedEngine);
+    if (!bindingAccount) {
+        const boundVault = engineExists
+            ? await (0, readContract_js_1.readContract)(client, {
+                address: predictedEngine,
+                abi: Abis.erc4626Engine,
+                functionName: 'earnVault',
+            })
+            : address_js_1.zeroAddress;
+        if ((0, isAddressEqual_js_1.isAddressEqual)(boundVault, address_js_1.zeroAddress))
+            throw new Error('`bindingAccount` is required when the final owner differs from the deployment account.');
+    }
+    const receipts = {};
+    try {
+        if (!engineExists) {
+            await (0, simulateContract_js_1.simulateContract)(client, {
+                ...sharedWriteParameters,
+                account: deployer,
+                ...createErc4626Engine.call(engineArgs),
+            });
+            const receipt = await createErc4626Engine.inner(writeContractSync_js_1.writeContractSync, client, {
+                ...writeParameters,
+                ...engineArgs,
+            });
+            receipts.engine = receipt;
+            createErc4626Engine.extractEvent(receipt.logs, {
+                factory: parameters.factories.erc4626Engine,
+            });
+        }
+        await verifyEngine(client, engineArgs, predictedEngine);
+    }
+    catch (error) {
+        throw deploymentError(error, 'engine', state, receipts);
+    }
+    const stackArgs = {
+        controls: parameters.controls,
+        deploymentId: parameters.deploymentId,
+        distributor: parameters.distributor,
+        engine: predictedEngine,
+        factory: parameters.factories.earn,
+        fees: parameters.fees,
+        owner,
+        transferPolicyId: parameters.transferPolicyId,
+    };
+    try {
+        const predicted = await createStack.predict(client, stackArgs);
+        if (parameters.resume?.earnShare &&
+            !(0, isAddressEqual_js_1.isAddressEqual)(parameters.resume.earnShare, predicted.earnShare))
+            throw new Error('The resumed EarnShare does not match the factory prediction.');
+        if (parameters.resume?.fees &&
+            !(0, isAddressEqual_js_1.isAddressEqual)(parameters.resume.fees, predicted.earnFees))
+            throw new Error('The resumed EarnFees does not match the factory prediction.');
+        state.earnShare = predicted.earnShare;
+        state.fees = predicted.earnFees;
+        if (!(await hasCode(client, predicted.earnShare))) {
+            if (await hasCode(client, predicted.earnFees))
+                throw new Error('Predicted EarnFees exists without the predicted EarnShare.');
+            await (0, simulateContract_js_1.simulateContract)(client, {
+                ...sharedWriteParameters,
+                account: deployer,
+                ...createStack.call(stackArgs),
+            });
+            const receipt = await createStack.inner(writeContractSync_js_1.writeContractSync, client, {
+                ...writeParameters,
+                ...stackArgs,
+            });
+            receipts.stack = receipt;
+            const { args } = createStack.extractEvent(receipt.logs, {
+                factory: parameters.factories.earn,
+            });
+            state.vault = args.earnVault;
+            if (parameters.resume?.vault &&
+                !(0, isAddressEqual_js_1.isAddressEqual)(parameters.resume.vault, args.earnVault))
+                throw new Error('The resumed EarnVault does not match the factory deployment.');
+        }
+        else {
+            if (!(await hasCode(client, predicted.earnFees)))
+                throw new Error('Predicted EarnShare exists without the predicted EarnFees.');
+            state.vault = parameters.resume?.vault;
+            if (!state.vault) {
+                const event = await findStackDeployment(client, {
+                    earnShare: predicted.earnShare,
+                    factory: parameters.factories.earn,
+                    fromBlock: parameters.fromBlock,
+                });
+                state.vault = event.args.earnVault;
+                if (!(0, isAddressEqual_js_1.isAddressEqual)(event.args.earnFees, predicted.earnFees))
+                    throw new Error('Recovered EarnFees does not match the factory prediction.');
+            }
+        }
+        if (!state.vault)
+            throw new Error('EarnVault address was not recovered.');
+        await verifyStack(client, {
+            engine: predictedEngine,
+            fees: predicted.earnFees,
+            owner,
+            share: predicted.earnShare,
+            vault: state.vault,
+        });
+    }
+    catch (error) {
+        throw deploymentError(error, 'stack', state, receipts);
+    }
+    try {
+        const vault = state.vault;
+        const boundVault = await (0, readContract_js_1.readContract)(client, {
+            address: predictedEngine,
+            abi: Abis.erc4626Engine,
+            functionName: 'earnVault',
+        });
+        if ((0, isAddressEqual_js_1.isAddressEqual)(boundVault, address_js_1.zeroAddress)) {
+            if (!bindingAccount)
+                throw new Error('`bindingAccount` is required when the final owner differs from the deployment account.');
+            const bindingParameters = {
+                ...writeParameters,
+                account: bindingAccount,
+                engine: predictedEngine,
+                vault,
+            };
+            await (0, simulateContract_js_1.simulateContract)(client, {
+                ...sharedWriteParameters,
+                account: bindingAccount,
+                ...bindErc4626Engine.call({ engine: predictedEngine, vault }),
+            });
+            const receipt = await bindErc4626Engine.inner(writeContractSync_js_1.writeContractSync, client, bindingParameters);
+            receipts.binding = receipt;
+            bindErc4626Engine.extractEvent(receipt.logs, { engine: predictedEngine });
+        }
+        else if (!(0, isAddressEqual_js_1.isAddressEqual)(boundVault, vault)) {
+            throw new Error(`Engine is already bound to ${boundVault}.`);
+        }
+        const verified = await (0, readContract_js_1.readContract)(client, {
+            address: predictedEngine,
+            abi: Abis.erc4626Engine,
+            functionName: 'earnVault',
+        });
+        if (!(0, isAddressEqual_js_1.isAddressEqual)(verified, vault))
+            throw new Error('Engine binding verification failed.');
+    }
+    catch (error) {
+        throw deploymentError(error, 'binding', state, receipts);
+    }
+    return {
+        deploymentId: parameters.deploymentId,
+        earnShare: state.earnShare,
+        engine: predictedEngine,
+        fees: state.fees,
+        receipts,
+        vault: state.vault,
+    };
+}
+function validateDeploymentId(deploymentId) {
+    if (ox_1.Hex.size(deploymentId) !== 32 || BigInt(deploymentId) === 0n)
+        throw new Error('`deploymentId` must be a nonzero 32-byte hex value.');
+}
+function toDeployParameters(args) {
+    const fixedFees = args.fees?.fixedFees ?? [];
+    if (fixedFees.length > 4)
+        throw new Error('Earn supports at most four fixed fee recipients.');
+    const seen = new Set();
+    let totalRateBps = 0;
+    for (const fee of fixedFees) {
+        validateFeeRate(fee.rateBps, '`fixedFees[].rateBps`', false);
+        if ((0, isAddressEqual_js_1.isAddressEqual)(fee.account, address_js_1.zeroAddress))
+            throw new Error('Fixed fee recipients cannot be the zero address.');
+        const account = fee.account.toLowerCase();
+        if (seen.has(account))
+            throw new Error('Fixed fee recipients must be unique.');
+        seen.add(account);
+        totalRateBps += fee.rateBps;
+    }
+    if (totalRateBps > 10_000)
+        throw new Error('The total fixed fee rate cannot exceed 10,000 bps.');
+    const excess = args.fees?.excess;
+    if (excess) {
+        validateFeeRate(excess.annualTargetRateBps, '`annualTargetRateBps`', true);
+        validateFeeRate(excess.rateBps, '`excess.rateBps`', false);
+        if ((0, isAddressEqual_js_1.isAddressEqual)(excess.account, address_js_1.zeroAddress))
+            throw new Error('The excess fee recipient cannot be the zero address.');
+    }
+    const zeroFee = { account: address_js_1.zeroAddress, rateBps: 0 };
+    const distributor = args.distributor?.distributor ?? address_js_1.zeroAddress;
+    const updateDelay = args.distributor?.updateDelay ?? 0;
+    if (args.distributor) {
+        if ((0, isAddressEqual_js_1.isAddressEqual)(distributor, address_js_1.zeroAddress))
+            throw new Error('An enabled distributor cannot be the zero address.');
+        if (updateDelay <= 0)
+            throw new Error('An enabled distributor requires a positive update delay.');
+        if (fixedFees.length === 0)
+            throw new Error('An enabled distributor requires at least one fixed fee.');
+    }
+    if (!Number.isSafeInteger(updateDelay) || updateDelay > 0xffffffffff)
+        throw new Error('`updateDelay` must fit into uint40 seconds.');
+    const transferPolicyId = args.transferPolicyId ?? 0n;
+    if (transferPolicyId < 0n || transferPolicyId > number_js_1.maxUint64)
+        throw new Error('`transferPolicyId` must fit into uint64.');
+    const maxManagedAssets = args.controls?.maxManagedAssets ?? 0n;
+    if (maxManagedAssets < 0n || maxManagedAssets > number_js_1.maxUint256)
+        throw new Error('`maxManagedAssets` must fit into uint256.');
+    return {
+        controls: {
+            asyncJanitor: args.controls?.asyncJanitor ?? address_js_1.zeroAddress,
+            emergencyGuardian: args.controls?.emergencyGuardian ?? address_js_1.zeroAddress,
+            maxManagedAssets,
+            migrationMode: (args.controls?.migrationMode ?? 'userOnly') === 'userOnly' ? 0 : 1,
+        },
+        deploymentId: args.deploymentId,
+        distributorConfig: { distributor, updateDelay },
+        engine: args.engine,
+        fees: {
+            excess: excess
+                ? {
+                    account: excess.account,
+                    annualTargetRateBps: excess.annualTargetRateBps,
+                    enabled: true,
+                    excessFeeRateBps: excess.rateBps,
+                }
+                : {
+                    account: address_js_1.zeroAddress,
+                    annualTargetRateBps: 0,
+                    enabled: false,
+                    excessFeeRateBps: 0,
+                },
+            fixedFeeCount: fixedFees.length,
+            fixedFees: [
+                fixedFees[0] ?? zeroFee,
+                fixedFees[1] ?? zeroFee,
+                fixedFees[2] ?? zeroFee,
+                fixedFees[3] ?? zeroFee,
+            ],
+        },
+        owner: args.owner,
+        transferPolicyId,
+    };
+}
+function validateFeeRate(rate, name, allowZero) {
+    if (!Number.isInteger(rate) || rate < (allowZero ? 0 : 1) || rate > 10_000)
+        throw new Error(`${name} must be an integer between ${allowZero ? 0 : 1} and 10,000.`);
+}
+async function hasCode(client, address) {
+    const code = await (0, getCode_js_1.getCode)(client, { address });
+    return code !== undefined && code !== '0x';
+}
+async function validateContracts(client, parameters) {
+    const [engineFactory, earnFactory, venue] = await Promise.all([
+        hasCode(client, parameters.factories.erc4626Engine),
+        hasCode(client, parameters.factories.earn),
+        hasCode(client, parameters.venue),
+    ]);
+    if (!engineFactory)
+        throw new Error('ERC4626EngineFactory has no code.');
+    if (!earnFactory)
+        throw new Error('EarnFactory has no code.');
+    if (!venue)
+        throw new Error('ERC-4626 venue has no code.');
+    const tip20Factory = await (0, readContract_js_1.readContract)(client, {
+        address: parameters.factories.earn,
+        abi: Abis.earnFactory,
+        functionName: 'tip20Factory',
+    });
+    if (!(0, isAddressEqual_js_1.isAddressEqual)(tip20Factory, Addresses.tip20Factory))
+        throw new Error('EarnFactory uses an unexpected TIP-20 factory.');
+}
+async function verifyEngine(client, args, engine) {
+    const [venue, owner] = await Promise.all([
+        (0, readContract_js_1.readContract)(client, {
+            address: engine,
+            abi: Abis.erc4626Engine,
+            functionName: 'vault',
+        }),
+        (0, readContract_js_1.readContract)(client, {
+            address: engine,
+            abi: Abis.erc4626Engine,
+            functionName: 'owner',
+        }),
+    ]);
+    if (!(0, isAddressEqual_js_1.isAddressEqual)(venue, args.venue))
+        throw new Error('Engine venue verification failed.');
+    if (!(0, isAddressEqual_js_1.isAddressEqual)(owner, args.owner))
+        throw new Error('Engine owner verification failed.');
+}
+async function verifyStack(client, parameters) {
+    const [engine, fees, operator, share] = await Promise.all([
+        (0, readContract_js_1.readContract)(client, {
+            address: parameters.vault,
+            abi: Abis.earnVault,
+            functionName: 'engine',
+        }),
+        (0, readContract_js_1.readContract)(client, {
+            address: parameters.vault,
+            abi: Abis.earnVault,
+            functionName: 'earnFees',
+        }),
+        (0, readContract_js_1.readContract)(client, {
+            address: parameters.vault,
+            abi: Abis.earnVault,
+            functionName: 'operator',
+        }),
+        (0, readContract_js_1.readContract)(client, {
+            address: parameters.vault,
+            abi: Abis.earnVault,
+            functionName: 'earnShare',
+        }),
+    ]);
+    if (!(0, isAddressEqual_js_1.isAddressEqual)(engine, parameters.engine))
+        throw new Error('EarnVault engine verification failed.');
+    if (!(0, isAddressEqual_js_1.isAddressEqual)(fees, parameters.fees))
+        throw new Error('EarnVault fees verification failed.');
+    if (!(0, isAddressEqual_js_1.isAddressEqual)(operator, parameters.owner))
+        throw new Error('EarnVault operator verification failed.');
+    if (!(0, isAddressEqual_js_1.isAddressEqual)(share, parameters.share))
+        throw new Error('EarnVault share verification failed.');
+}
+async function findStackDeployment(client, parameters) {
+    const event = (0, getAbiItem_js_1.getAbiItem)({
+        abi: Abis.earnFactory,
+        name: 'EarnStackDeployed',
+    });
+    const logs = await (0, getLogs_js_1.getLogs)(client, {
+        address: parameters.factory,
+        args: { earnShare: parameters.earnShare },
+        event,
+        fromBlock: parameters.fromBlock ?? 0n,
+        strict: true,
+        toBlock: 'latest',
+    });
+    const log = logs.at(-1);
+    if (!log)
+        throw new Error('Prior `EarnStackDeployed` event not found.');
+    return log;
+}
+function deploymentError(error, stage, state, receipts) {
+    if (error instanceof DeployErc4626StackError)
+        return error;
+    if (error instanceof transaction_js_1.TransactionReceiptRevertedError)
+        receipts[stage] = error.receipt;
+    return new DeployErc4626StackError(error instanceof Error ? error : new Error(String(error)), { receipts: { ...receipts }, stage, state: { ...state } });
+}
+//# sourceMappingURL=deployment.js.map