@robertprp/intents-sdk/dist/esm/core/evm/intent-provider.js

Shogun Network Intent-based cross-chain swaps SDK

import {} from 'viem';
import {} from '../../chains.js';
import { SINGLE_CHAIN_GUARD_ADDRESSES, CROSS_CHAIN_GUARD_ADDRESSES, MAX_UINT_32, DCA_SINGLE_CHAIN_GUARD_ADDRESSES, } from '../../constants.js';
import { getEVMCrossChainOrderTypedData, getEVMDcaSingleChainOrderTypedData, getEVMSingleChainOrderTypedData, } from './order-signature.js';
import {} from './permit2.js';
import { ChainProvider } from './chain-provider.js';
export class EVMIntentProvider {
    constructor(config) {
        Object.defineProperty(this, "provider", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: void 0
        });
        this.provider = new ChainProvider(config);
    }
    async prepareSingleChainOrder(order) {
        const { orderTypedData: dataToSign, nonce } = await getEVMSingleChainOrderTypedData(order);
        const signature = await this.provider.walletClient.signTypedData({
            message: dataToSign.message,
            primaryType: dataToSign.primaryType,
            types: dataToSign.types,
            domain: dataToSign.domain,
            account: this.provider.getAccount(),
        });
        return {
            order,
            preparedData: {
                nonce: nonce.toString(),
                signature: signature.slice(2),
            },
        };
    }
    async prepareCrossChainOrder(order) {
        const { orderTypedData: dataToSign, nonce } = await getEVMCrossChainOrderTypedData(order);
        const signature = await this.provider.walletClient.signTypedData({
            message: dataToSign.message,
            primaryType: dataToSign.primaryType,
            types: dataToSign.types,
            domain: dataToSign.domain,
            account: this.provider.getAccount(),
        });
        return {
            order,
            preparedData: {
                nonce: nonce.toString(),
                signature: signature.slice(2),
            },
        };
    }
    static getCrossChainPermissionMessage(order, nonce) {
        const spender = CROSS_CHAIN_GUARD_ADDRESSES[order.sourceChainId];
        return {
            permitted: {
                token: order.sourceTokenAddress,
                amount: order.sourceTokenAmount,
            },
            spender,
            nonce,
            deadline: BigInt(order.deadline),
            witness: {
                user: order.user,
                tokenIn: order.sourceTokenAddress,
                srcChainId: order.sourceChainId,
                deadline: order.deadline,
                amountIn: order.sourceTokenAmount,
                minStablecoinsAmount: order.minStablecoinAmount,
                nonce,
                executionDetailsHash: order.getExecutionDetailsHash(),
            },
        };
    }
    static getSingleChainLimitPermissionMessage(order, nonce) {
        const spender = SINGLE_CHAIN_GUARD_ADDRESSES[order.chainId];
        const requestedOutput = {
            token: order.tokenOut,
            receiver: order.destinationAddress,
            amount: order.amountOutMin,
        };
        const extraTransfers = order.extraTransfers?.map((transfer) => ({
            token: transfer.token,
            receiver: transfer.receiver,
            amount: transfer.amount,
        })) || [];
        return {
            permitted: {
                token: order.tokenIn,
                amount: order.amountIn,
            },
            spender,
            nonce,
            deadline: BigInt(order.deadline),
            witness: {
                user: order.user,
                tokenIn: order.tokenIn,
                amountIn: order.amountIn,
                requestedOutput,
                encodedExternalCallData: '0x', // TODO: Update when external call data is supported
                extraTransfers,
                deadline: order.deadline,
                nonce,
            },
        };
    }
    static getRandomNonce() {
        return BigInt(Math.floor(Math.random() * Number(MAX_UINT_32)));
    }
    async prepareDcaSingleChainOrder(order) {
        const { orderTypedData: dataToSign, nonce } = await getEVMDcaSingleChainOrderTypedData(order);
        const signature = await this.provider.walletClient.signTypedData({
            message: dataToSign.message,
            primaryType: dataToSign.primaryType,
            types: dataToSign.types,
            domain: dataToSign.domain,
            account: this.provider.getAccount(),
        });
        return {
            order,
            preparedData: {
                nonce: nonce.toString(),
                signature: signature.slice(2),
            },
        };
    }
    static getDcaSingleChainPermissionMessage(order, nonce) {
        const spender = DCA_SINGLE_CHAIN_GUARD_ADDRESSES[order.chainId];
        const requestedOutput = {
            token: order.tokenOut,
            receiver: order.destinationAddress,
            amount: BigInt(order.amountOutMin),
        };
        const extraTransfers = order.extraTransfers?.map((transfer) => ({
            token: transfer.token,
            receiver: transfer.receiver,
            amount: transfer.amount,
        })) || [];
        const totalAmountIn = BigInt(order.amountInPerInterval) * BigInt(order.totalIntervals);
        return {
            permitted: {
                token: order.tokenIn,
                amount: totalAmountIn,
            },
            spender,
            nonce,
            deadline: BigInt(order.deadline),
            witness: {
                user: order.user,
                tokenIn: order.tokenIn,
                startTime: order.startTime,
                amountInPerInterval: BigInt(order.amountInPerInterval),
                totalIntervals: order.totalIntervals,
                intervalDuration: order.intervalDuration,
                requestedOutput,
                encodedExternalCallData: '0x', // TODO: Update when external call data is supported
                extraTransfers,
                deadline: order.deadline,
                nonce,
            },
        };
    }
}
//# sourceMappingURL=intent-provider.js.map