@robertprp/intents-sdk/dist/esm/core/sdk.js

Shogun Network Intent-based cross-chain swaps SDK

import { AUCTIONEER_URL } from '../constants.js';
import { NetworkError } from '../errors/index.js';
import { Parsers } from '../utils/parsers.js';
import { CrossChainOrder } from './orders/cross-chain.js';
import { DcaSingleChainOrder } from './orders/dca-single-chain.js';
import { SingleChainOrder } from './orders/single-chain.js';
/**
 * Base SDK providing common functionality for all blockchain implementations
 */
export class BaseSDK {
    // Generic HTTP request handler
    static async makeRequest(url, body) {
        const response = await fetch(url, {
            method: 'POST',
            headers: { 'Content-Type': 'application/json' },
            body,
        });
        if (!response.ok) {
            const errorJson = await response.json();
            const mainError = errorJson.error;
            const extraErrorData = errorJson.extra_error_data;
            const errorMessage = mainError
                ? `${mainError}. Extra error data: ${extraErrorData}`
                : `Server error ${extraErrorData}`;
            throw new NetworkError(errorMessage);
        }
        return response.json();
    }
    static async validateOrder(intentRequest, endpoint) {
        const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
        const url = `${AUCTIONEER_URL}${endpoint}`;
        await BaseSDK.makeRequest(url, body);
    }
    static async sendOrder(preparedOrder, endpoint) {
        const intentRequest = preparedOrder.order.toIntentRequest(preparedOrder.preparedData);
        const body = JSON.stringify(intentRequest, Parsers.bigIntReplacer);
        const url = `${AUCTIONEER_URL}${endpoint}`;
        return BaseSDK.makeRequest(url, body);
    }
    async createCrossChainOrder(params) {
        const userAddress = await this.getUserAddress();
        const order = await CrossChainOrder.create({ ...params, user: userAddress });
        return this.prepareCrossChainOrder(order);
    }
    async createAndSendCrossChainOrder(params) {
        const preparedOrder = await this.createCrossChainOrder(params);
        return BaseSDK.sendCrossChainOrder(preparedOrder);
    }
    static async sendCrossChainOrder(preparedOrder) {
        return BaseSDK.sendOrder(preparedOrder, '/user_intent/cross_chain/limit_order');
    }
    static async validateCrossChainOrder(intentRequest) {
        return BaseSDK.validateOrder(intentRequest, '/validate_intent/cross_chain/limit_order');
    }
    async createSingleChainOrder(params) {
        const userAddress = await this.getUserAddress();
        const order = await SingleChainOrder.create({ ...params, user: userAddress });
        return this.prepareSingleChainOrder(order);
    }
    async createAndSendSingleChainOrder(params) {
        const preparedOrder = await this.createSingleChainOrder(params);
        return BaseSDK.sendSingleChainOrder(preparedOrder);
    }
    static async sendSingleChainOrder(preparedOrder) {
        return BaseSDK.sendOrder(preparedOrder, '/user_intent/single_chain/limit_order');
    }
    static async validateSingleChainOrder(intentRequest) {
        return BaseSDK.validateOrder(intentRequest, '/validate_intent/single_chain/limit_order');
    }
    async createDcaSingleChainOrder(params) {
        const userAddress = await this.getUserAddress();
        const order = await DcaSingleChainOrder.create({ ...params, user: userAddress });
        return this.prepareDcaSingleChainOrder(order);
    }
    async createAndSendDcaSingleChainOrder(params) {
        const preparedOrder = await this.createDcaSingleChainOrder(params);
        return BaseSDK.sendDcaSingleChainOrder(preparedOrder);
    }
    static async sendDcaSingleChainOrder(preparedOrder) {
        return BaseSDK.sendOrder(preparedOrder, '/user_intent/single_chain/dca_order');
    }
    static async validateDcaSingleChainOrder(intentRequest) {
        return BaseSDK.validateOrder(intentRequest, '/validate_intent/single_chain/dca_order');
    }
}
//# sourceMappingURL=sdk.js.map