soso-widget/dist/esm/providers/WalletProvider/getSafeMultisigConfig.js

LI.FI Widget for cross-chain bridging and swapping. It will drive your multi-chain strategy and attract new users from everywhere.

var TransactionStatus;
(function (TransactionStatus) {
    TransactionStatus["AWAITING_CONFIRMATIONS"] = "AWAITING_CONFIRMATIONS";
    TransactionStatus["AWAITING_EXECUTION"] = "AWAITING_EXECUTION";
    TransactionStatus["CANCELLED"] = "CANCELLED";
    TransactionStatus["FAILED"] = "FAILED";
    TransactionStatus["SUCCESS"] = "SUCCESS";
})(TransactionStatus || (TransactionStatus = {}));
export const getSafeMultisigConfig = (connector) => {
    const getMultisigTransactionDetails = async (txHash, chainId, updateIntermediateStatus) => {
        const safeAppProvider = (await connector.getProvider());
        const safeProviderSDK = safeAppProvider.sdk;
        const safeTransactionDetails = await safeProviderSDK.txs.getBySafeTxHash(txHash);
        const safeTxHash = safeTransactionDetails.txId;
        const safeApiTransactionResponse = await fetch(`https://safe-client.safe.global/v1/chains/${chainId}/transactions/${safeTxHash}`);
        const safeApiTransactionDetails = await safeApiTransactionResponse.json();
        const nonTerminalStatus = [
            TransactionStatus.SUCCESS,
            TransactionStatus.CANCELLED,
            TransactionStatus.FAILED,
        ];
        const isSafeStatusPending = !nonTerminalStatus.includes(safeTransactionDetails.txStatus) &&
            !nonTerminalStatus.includes(safeApiTransactionDetails.txStatus);
        const isAwaitingExecution = [
            safeTransactionDetails.txStatus,
            safeApiTransactionDetails.txStatus,
        ].includes(TransactionStatus.AWAITING_EXECUTION);
        if (isAwaitingExecution) {
            updateIntermediateStatus?.();
        }
        if (isSafeStatusPending) {
            await new Promise((resolve) => {
                setTimeout(resolve, 5000);
            });
            return await getMultisigTransactionDetails(txHash, chainId, updateIntermediateStatus);
        }
        if ([
            safeTransactionDetails.txStatus,
            safeApiTransactionDetails.txStatus,
        ].includes(TransactionStatus.SUCCESS)) {
            return {
                status: 'DONE',
                txHash: `0x${safeTransactionDetails.txHash?.slice(2)}`,
            };
        }
        if ([
            safeTransactionDetails.txStatus,
            safeApiTransactionDetails.txStatus,
        ].includes(TransactionStatus.FAILED)) {
            return {
                status: 'FAILED',
                txHash: `0x${safeTransactionDetails.txHash?.slice(2)}`,
            };
        }
        if ([
            safeTransactionDetails.txStatus,
            safeApiTransactionDetails.txStatus,
        ].includes(TransactionStatus.CANCELLED)) {
            return {
                status: 'CANCELLED',
                txHash: `0x${safeTransactionDetails.txHash?.slice(2)}`,
            };
        }
        if (isSafeStatusPending) {
            return {
                status: 'PENDING',
                txHash: `0x${safeTransactionDetails.txHash?.slice(2)}`,
            };
        }
        return {
            status: 'PENDING',
            txHash: `0x${safeTransactionDetails.txHash?.slice(2)}`,
        };
    };
    const sendBatchTransaction = async (batchTransactions) => {
        const safeAppProvider = (await connector.getProvider());
        const safeProviderSDK = safeAppProvider.sdk;
        try {
            const { safeTxHash } = await safeProviderSDK.txs.send({
                txs: batchTransactions,
            });
            return `0x${safeTxHash.slice(2)}`;
        }
        catch (error) {
            throw new Error(error);
        }
    };
    return {
        isMultisigWalletClient: connector?.id === 'safe',
        shouldBatchTransactions: connector?.id === 'safe',
        sendBatchTransaction,
        getMultisigTransactionDetails,
    };
};
//# sourceMappingURL=getSafeMultisigConfig.js.map