dop-stick/dist/utils/constructorManager.js

Source control tooling for versionable-upgradeable smart contracts

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ConstructorManager = void 0;
const logger_1 = require("./logsAndMetrics/core/logger");
const terminal_1 = require("./logsAndMetrics/core/terminal");
const ethers_1 = require("ethers");
class ConstructorManager {
    constructor(standardType, cache) {
        this.standardType = standardType;
        this.cache = cache;
    }
    async prepareConstructorArgs() {
        if (this.standardType === 'custom') {
            return this.handleCustomConstructor();
        }
        return this.handleStandardConstructor();
    }
    async handleStandardConstructor() {
        var _a, _b;
        try {
            // Get basic parameters that might be needed across different standards
            const owner = process.env.DIAMOND_OWNER || process.env.DEPLOYER_ADDRESS;
            if (!owner) {
                throw new Error('DIAMOND_OWNER or DEPLOYER_ADDRESS must be set in environment');
            }
            // Get diamond cuts from cache
            const diamondCut = this.cache.cuts || [];
            switch (this.standardType) {
                case 'standard-type-1':
                    // Constructor(FacetCut[] memory _diamondCut, DiamondArgs memory _args)
                    // where DiamondArgs = { address owner; address init; bytes initCalldata; }
                    const init = process.env.INIT_ADDRESS || ((_a = this.cache.coreFacets['core/init']) === null || _a === void 0 ? void 0 : _a.address);
                    const initCalldata = process.env.INIT_CALLDATA || '0x';
                    return {
                        _diamondCut: diamondCut,
                        diamondArgs: {
                            owner: owner,
                            init: init || ethers_1.ethers.constants.AddressZero,
                            initCalldata: initCalldata
                        }
                    };
                case 'standard-type-2':
                    // Constructor(FacetCut[] memory _diamondCut, DiamondArgs memory _args)
                    // where DiamondArgs = { address owner; }
                    return {
                        _diamondCut: diamondCut,
                        diamondArgs: {
                            owner: owner
                        }
                    };
                case 'standard-type-3':
                    // Constructor(address _contractOwner, address _diamondCutFacet)
                    const diamondCutFacet = (_b = this.cache.coreFacets['core/cut']) === null || _b === void 0 ? void 0 : _b.address;
                    if (!diamondCutFacet) {
                        throw new Error('Diamond Cut facet address not found in cache');
                    }
                    return {
                        _contractOwner: owner,
                        _diamondCutFacet: diamondCutFacet
                    };
                default:
                    throw new Error(`Unsupported diamond standard type: ${this.standardType}`);
            }
        }
        catch (error) {
            logger_1.Logger.error('Failed to prepare standard constructor arguments:', error);
            throw error;
        }
    }
    async handleCustomConstructor() {
        terminal_1.Terminal.writeLine('\nCustom diamond constructor detected.');
        terminal_1.Terminal.writeLine('Please provide all constructor arguments.');
        terminal_1.Terminal.writeLine('Available deployed addresses:');
        terminal_1.Terminal.writeLine(JSON.stringify({
            coreFacets: this.cache.coreFacets,
            modules: this.cache.modules
        }, null, 2));
        terminal_1.Terminal.writeLine('\nProvide arguments in format: key=value');
        return this.handleUserModifications({});
    }
    async handleUserModifications(currentArgs) {
        const input = await terminal_1.Terminal.prompt('Enter arguments (or "done" to finish): ');
        if (input.toLowerCase() === 'done') {
            return currentArgs;
        }
        const modifications = this.parseUserInput(input);
        return {
            ...currentArgs,
            ...modifications
        };
    }
    parseUserInput(input) {
        const result = {};
        const pairs = input.split(' ');
        for (const pair of pairs) {
            const [key, value] = pair.split('=');
            if (key && value) {
                result[key.trim()] = value.trim();
            }
        }
        return result;
    }
    populateStructFields(fields) {
        var _a;
        const result = {};
        for (const [field, type] of Object.entries(fields)) {
            if (field === 'owner') {
                result[field] = process.env.DIAMOND_OWNER;
            }
            else if (field === 'init') {
                result[field] = (_a = this.cache.coreFacets['DiamondInit']) === null || _a === void 0 ? void 0 : _a.address;
            }
            // Add more field population logic as needed
        }
        return result;
    }
}
exports.ConstructorManager = ConstructorManager;
//# sourceMappingURL=constructorManager.js.map