viem/_cjs/tempo/actions/multisig.js

TypeScript Interface for Ethereum

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getConfig = getConfig;
exports.getConfigCommitment = getConfigCommitment;
exports.getOperation = getOperation;
exports.updateConfig = updateConfig;
exports.updateConfigSync = updateConfigSync;
const tempo_1 = require("ox/tempo");
const readContract_js_1 = require("../../actions/public/readContract.js");
const writeContract_js_1 = require("../../actions/wallet/writeContract.js");
const writeContractSync_js_1 = require("../../actions/wallet/writeContractSync.js");
const parseEventLogs_js_1 = require("../../utils/abi/parseEventLogs.js");
const Abis = require("../Abis.js");
const Account_js_1 = require("../Account.js");
const Addresses = require("../Addresses.js");
const utils_js_1 = require("../internal/utils.js");
async function getConfig(client, parameters) {
    const config = await client.request({
        method: 'multisig_getConfig',
        params: [{ address: parameters.address }],
    });
    return config ? tempo_1.MultisigConfig.fromRpc(config) : null;
}
async function getConfigCommitment(client, parameters) {
    const { account, ...rest } = parameters;
    return (0, readContract_js_1.readContract)(client, {
        ...rest,
        ...getConfigCommitment.call({ account }),
    });
}
(function (getConfigCommitment) {
    function call(args) {
        return (0, utils_js_1.defineCall)({
            address: Addresses.nativeMultisig,
            abi: Abis.nativeMultisig,
            args: [args.account],
            functionName: 'getConfigCommitment',
        });
    }
    getConfigCommitment.call = call;
})(getConfigCommitment || (exports.getConfigCommitment = getConfigCommitment = {}));
async function getOperation(client, parameters) {
    const operation = await client.request({
        method: 'multisig_getOperation',
        params: [parameters.hash],
    });
    return operation ? tempo_1.MultisigOperation.fromRpc(operation) : null;
}
async function updateConfig(client, parameters) {
    return updateConfig.inner(writeContract_js_1.writeContract, client, parameters);
}
(function (updateConfig) {
    async function inner(action, client, parameters) {
        const { account: account_, currentConfig: currentConfig_, nextConfig, ...rest } = parameters;
        const accountValue = account_ ?? client.account;
        const account = (() => {
            if (typeof accountValue === 'object' &&
                accountValue.source === 'multisig')
                return accountValue;
            return undefined;
        })();
        const config = (() => {
            if (currentConfig_)
                return currentConfig_;
            if (account?.config)
                return account.config;
            return undefined;
        })();
        const address = (() => {
            if (account)
                return account.address;
            if (typeof accountValue === 'string')
                return accountValue;
            if (accountValue)
                return accountValue.address;
            return undefined;
        })();
        const currentConfig = await (async () => {
            if (config)
                return tempo_1.MultisigConfig.from(config);
            if (!address)
                throw new Error('A multisig account address or current config is required.');
            const cachedConfig = await getConfig(client, { address });
            if (!cachedConfig)
                throw new Error(`No current multisig config is cached for account ${address}. Provide the current config.`);
            return cachedConfig;
        })();
        const resolvedAccount = (() => {
            if (account)
                return { ...account, config: currentConfig };
            if (typeof accountValue === 'object')
                return accountValue;
            if (address)
                return (0, Account_js_1.fromMultisig)({ address, ...currentConfig });
            return undefined;
        })();
        return (await action(client, {
            ...rest,
            ...(resolvedAccount ? { account: resolvedAccount } : {}),
            ...updateConfig.call({ currentConfig, nextConfig }),
        }));
    }
    updateConfig.inner = inner;
    function call(args) {
        const currentConfig = tempo_1.MultisigConfig.from(args.currentConfig);
        const nextConfig = tempo_1.MultisigConfig.from({
            owners: args.nextConfig.owners,
            salt: currentConfig.salt,
            threshold: args.nextConfig.threshold,
            version: currentConfig.version + 1n,
        });
        return (0, utils_js_1.defineCall)({
            address: Addresses.nativeMultisig,
            abi: Abis.nativeMultisig,
            args: [currentConfig, nextConfig.threshold, nextConfig.owners],
            functionName: 'updateConfig',
        });
    }
    updateConfig.call = call;
    function extractEvent(logs) {
        const [log] = (0, parseEventLogs_js_1.parseEventLogs)({
            abi: Abis.nativeMultisig,
            logs,
            eventName: 'MultisigConfigUpdated',
            strict: true,
        });
        if (!log)
            throw new Error('`MultisigConfigUpdated` event not found.');
        return log;
    }
    updateConfig.extractEvent = extractEvent;
})(updateConfig || (exports.updateConfig = updateConfig = {}));
async function updateConfigSync(client, parameters) {
    const { throwOnReceiptRevert = true, ...rest } = parameters;
    const receipt = await updateConfig.inner(writeContractSync_js_1.writeContractSync, client, {
        ...rest,
        throwOnReceiptRevert,
    });
    if (receipt.status === 'pending')
        return { receipt };
    const { args } = updateConfig.extractEvent(receipt.logs);
    return {
        account: args.account,
        config: tempo_1.MultisigConfig.from({
            owners: args.owners,
            salt: args.salt,
            threshold: args.threshold,
            version: args.version,
        }),
        receipt,
    };
}
//# sourceMappingURL=multisig.js.map