@robertprp/intents-sdk/dist/esm/utils/order-validator.js

Shogun Network Intent-based cross-chain swaps SDK

import { ChainType, chainIdToChainTypeMap } from '../chains.js';
import { EvmValidator } from '../core/evm/validator.js';
import { SolanaValidator } from '../core/solana/validator.js';
import { SuiValidator } from '../core/sui/validator.js';
import { ValidationError } from '../errors/index.js';
/**
 * CommonValidator - Handles validations shared across chains
 */
export class CommonValidator {
    isValidDeadline(deadline) {
        return deadline > Math.floor(Date.now() / 1000);
    }
    validateDeadline(deadline) {
        if (!this.isValidDeadline(deadline)) {
            throw new ValidationError('Deadline must be in the future');
        }
    }
}
export class ValidatorFactory {
    static getValidator(chainType) {
        if (!this.validators.has(chainType)) {
            switch (chainType) {
                case ChainType.EVM:
                    this.validators.set(chainType, new EvmValidator());
                    break;
                case ChainType.Solana:
                    this.validators.set(chainType, new SolanaValidator());
                    break;
                case ChainType.Sui:
                    this.validators.set(chainType, new SuiValidator());
                    break;
                default:
                    throw new ValidationError(`Chain type ${chainType} validation is not implemented.`);
            }
        }
        return this.validators.get(chainType);
    }
    static getValidatorForChain(chainId) {
        const chainType = chainIdToChainTypeMap[chainId];
        return this.getValidator(chainType);
    }
}
Object.defineProperty(ValidatorFactory, "validators", {
    enumerable: true,
    configurable: true,
    writable: true,
    value: new Map()
});
export class CrossChainOrderValidator {
    constructor() {
        Object.defineProperty(this, "commonValidator", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new CommonValidator()
        });
    }
    async validateOrder(order) {
        const sourceValidator = ValidatorFactory.getValidatorForChain(order.sourceChainId);
        await sourceValidator.validateSourceChain({ ...order, user: order.user });
        const destinationValidator = ValidatorFactory.getValidatorForChain(order.destinationChainId);
        destinationValidator.validateDestinationChain(order);
        this.commonValidator.validateDeadline(order.deadline);
    }
}
export class SingleChainOrderValidator {
    constructor() {
        Object.defineProperty(this, "commonValidator", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new CommonValidator()
        });
    }
    async validateOrder(order) {
        this.commonValidator.validateDeadline(order.deadline);
        const chainValidator = ValidatorFactory.getValidatorForChain(order.chainId);
        chainValidator.validateSingleChainOrder(order);
    }
}
export class DcaSingleChainOrderValidator {
    constructor() {
        Object.defineProperty(this, "commonValidator", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new CommonValidator()
        });
    }
    async validateOrder(order) {
        this.commonValidator.validateDeadline(order.deadline);
        // Validate start time is in the future or current time
        if (order.startTime < Math.floor(Date.now() / 1000)) {
            throw new ValidationError('Start time must be in the future or current time');
        }
        // Validate intervals
        if (order.totalIntervals <= 0) {
            throw new ValidationError('Total intervals must be greater than 0');
        }
        if (order.intervalDuration <= 0) {
            throw new ValidationError('Interval duration must be greater than 0');
        }
        // Validate that the order will complete before deadline
        const estimatedCompletionTime = order.startTime + order.totalIntervals * order.intervalDuration;
        if (estimatedCompletionTime > order.deadline) {
            throw new ValidationError('Order would complete after deadline');
        }
        const chainValidator = ValidatorFactory.getValidatorForChain(order.chainId);
        await chainValidator.validateDcaSingleChainOrder(order);
    }
}
//# sourceMappingURL=order-validator.js.map