@nekoproject/swap
Version:
Cross-chain Swap Token
360 lines (303 loc) • 11.3 kB
JavaScript
'use strict';
Object.defineProperty(exports, '__esModule', { value: true });
var ethers = require('ethers');
var axios = require('axios');
var web3_js = require('@solana/web3.js');
function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
/* eslint-disable @typescript-eslint/no-unused-vars */
/* eslint-disable @typescript-eslint/no-explicit-any */
class Swap {
constructor(network, endpoint, version) {
this._network = void 0;
this._endpoint = void 0;
this._network = network;
this._endpoint = endpoint;
}
get network() {
return this._network;
}
get endpoint() {
throw new Error('Abstract Method has no implementation');
}
set endpoint(endpoint) {
throw new Error('Abstract Method has no implementation');
}
async createSwapOrder(swapRequest) {
throw new Error('Abstract Method has no implementation');
}
async swapToken(swapRequest, wallet) {
throw new Error('Abstract Method has no implementation');
}
}
/* eslint-disable @typescript-eslint/no-explicit-any */
class BSCSwap extends Swap {
constructor(network, endpoint) {
let fmt_endpoint;
if (endpoint.endsWith('/')) {
fmt_endpoint = endpoint.slice(0, endpoint.length - 1);
} else {
fmt_endpoint = endpoint;
}
super(network, fmt_endpoint);
this._createOrderApi = void 0;
this._buildTransApi = void 0;
this._createOrderApi = this._endpoint + '/v2/swaps/create-order';
this._buildTransApi = this._endpoint + '/v2/swaps/build-transaction';
}
set endpoint(endpoint) {
this._endpoint = endpoint;
}
get endpoint() {
return this._endpoint;
}
set api(params) {
this._createOrderApi = this._endpoint + params.createOrder;
this._buildTransApi = this._endpoint + params.buildTransaction;
}
/**
*
* @param swapRequest
* @returns
*/
async createSwapOrder(swapRequest) {
try {
const unitAmount = ethers.ethers.utils.parseUnits(swapRequest.srcAmount, swapRequest.srcToken.tokenInfo.decimals);
const data = {
wallet_address: swapRequest.wallet_address,
slippage: swapRequest.slippage,
network: 'BSC',
destDecimals: swapRequest.destToken.tokenInfo.decimals,
srcDecimals: swapRequest.srcToken.tokenInfo.decimals,
srcAmount: unitAmount.toString(),
destToken: swapRequest.destToken.tokenInfo.mintAddress,
srcToken: swapRequest.srcToken.tokenInfo.mintAddress
};
const orderResquest = await axios__default["default"].post(this._createOrderApi, data);
if (orderResquest.data.swap_order) {
return orderResquest.data.swap_order;
} else {
throw new Error(`Error create order: ${orderResquest.data?.error?.message}`);
}
} catch (error) {
throw new Error(`Error swap token: ${error}`);
}
}
/**
*
* @param swapRequest
* @param wallet
* @returns
*/
async swapToken(swapRequest, wallet) {
try {
const buildTransactionOrder = {
slippage: swapRequest.slippage,
wallet_address: wallet.address,
network: 'BSC',
swap_order_id: swapRequest.id.toString()
};
const buildResponse = await axios__default["default"].post(this._buildTransApi, buildTransactionOrder);
if (buildResponse.data.transaction) {
const orderRequest = {
from: buildResponse.data.transaction.from,
to: buildResponse.data.transaction.to,
value: ethers.ethers.utils.formatEther(buildResponse.data.transaction.value),
data: buildResponse.data.transaction.data,
gasPrice: buildResponse.data.transaction.gasPrice,
gasLimit: buildResponse.data.transaction.gas,
chainId: buildResponse.data.transaction.chainId
};
const transactionRequest = await this.network.createTransactionOrder(orderRequest, wallet);
const hash = await this.network.sendTransaction(transactionRequest, wallet);
return hash;
} else {
throw new Error(`Build transaction Error: ${buildResponse.data?.error?.message}`);
}
} catch (error) {
throw new Error(`Error swap token: ${error}`);
}
}
}
/* eslint-disable @typescript-eslint/no-explicit-any */
class ETHSwap extends Swap {
constructor(network, endpoint) {
let fmt_endpoint;
if (endpoint.endsWith('/')) {
fmt_endpoint = endpoint.slice(0, endpoint.length - 1);
} else {
fmt_endpoint = endpoint;
}
super(network, fmt_endpoint);
this._createOrderApi = void 0;
this._buildTransApi = void 0;
this._createOrderApi = this._endpoint + '/v2/swaps/create-order';
this._buildTransApi = this._endpoint + '/v2/swaps/build-transaction';
}
set endpoint(endpoint) {
this._endpoint = endpoint;
}
get endpoint() {
return this._endpoint;
}
set api(params) {
this._createOrderApi = this._endpoint + params.createOrder;
this._buildTransApi = this._endpoint + params.buildTransaction;
}
/**
*
* @param swapRequest
* @returns
*/
async createSwapOrder(swapRequest) {
try {
const unitAmount = ethers.ethers.utils.parseUnits(swapRequest.srcAmount, swapRequest.srcToken.tokenInfo.decimals);
const data = {
wallet_address: swapRequest.wallet_address,
slippage: swapRequest.slippage,
network: 'ETH',
destDecimals: swapRequest.destToken.tokenInfo.decimals,
srcDecimals: swapRequest.srcToken.tokenInfo.decimals,
srcAmount: unitAmount.toString(),
destToken: swapRequest.destToken.tokenInfo.mintAddress,
srcToken: swapRequest.srcToken.tokenInfo.mintAddress
};
const orderResquest = await axios__default["default"].post(this._createOrderApi, data);
if (orderResquest.data.swap_order) {
return orderResquest.data.swap_order;
} else {
throw new Error(`Error create order: ${orderResquest.data?.error?.message}`);
}
} catch (error) {
throw new Error(`Error swap token: ${error}`);
}
}
/**
*
* @param swapRequest
* @param wallet
* @returns
*/
async swapToken(swapRequest, wallet) {
try {
const buildTransactionOrder = {
slippage: swapRequest.slippage,
wallet_address: wallet.address,
network: 'ETH',
swap_order_id: swapRequest.id.toString()
};
const buildResponse = await axios__default["default"].post(this._buildTransApi, buildTransactionOrder);
if (buildResponse.data.transaction) {
const orderRequest = {
from: buildResponse.data.transaction.from,
to: buildResponse.data.transaction.to,
value: ethers.ethers.utils.formatEther(buildResponse.data.transaction.value),
data: buildResponse.data.transaction.data,
gasPrice: buildResponse.data.transaction.gasPrice,
gasLimit: buildResponse.data.transaction.gas,
chainId: buildResponse.data.transaction.chainId
};
const transactionRequest = await this.network.createTransactionOrder(orderRequest, wallet);
const hash = await this.network.sendTransaction(transactionRequest, wallet);
return hash;
} else {
throw new Error(`Build transaction Error: ${buildResponse.data?.error?.message}`);
}
} catch (error) {
throw new Error(`Error swap token: ${error}`);
}
}
}
/* eslint-disable @typescript-eslint/no-explicit-any */
class SPLSwap extends Swap {
constructor(network, endpoint) {
let fmt_endpoint;
if (endpoint.endsWith('/')) {
fmt_endpoint = endpoint.slice(0, endpoint.length - 1);
} else {
fmt_endpoint = endpoint;
}
super(network, fmt_endpoint);
this._createOrderApi = void 0;
this._buildTransApi = void 0;
this._createOrderApi = this._endpoint + '/v2/swaps/create-order';
this._buildTransApi = this._endpoint + '/v2/swaps/build-transaction';
}
set endpoint(endpoint) {
this._endpoint = endpoint;
}
get endpoint() {
return this._endpoint;
}
set api(params) {
this._createOrderApi = this._endpoint + params.createOrder;
this._buildTransApi = this._endpoint + params.buildTransaction;
}
/**
*
* @param swapRequest
* @returns
*/
async createSwapOrder(swapRequest) {
const destDecimals = swapRequest.destToken.tokenInfo.decimals ? swapRequest.destToken.tokenInfo.decimals : (await swapRequest.destToken.getInfo()).decimals;
const srcDecimals = swapRequest.srcToken.tokenInfo.decimals ? swapRequest.srcToken.tokenInfo.decimals : (await swapRequest.srcToken.getInfo()).decimals;
const unitAmount = ethers.ethers.utils.parseUnits(swapRequest.srcAmount, srcDecimals);
const data = {
wallet_address: swapRequest.wallet_address,
slippage: swapRequest.slippage,
network: 'SOL',
destDecimals: destDecimals,
srcDecimals: srcDecimals,
srcAmount: unitAmount.toString(),
destToken: swapRequest.destToken.tokenInfo.mintAddress,
srcToken: swapRequest.srcToken.tokenInfo.mintAddress
};
const orderResquest = await axios__default["default"].post(this._createOrderApi, data);
if (orderResquest.data.swap_order) {
return orderResquest.data.swap_order;
} else {
throw new Error(`Error create order: ${orderResquest.data?.error?.message}`);
}
}
/**
*
* @param swapRequest
* @param wallet
* @returns
*/
async swapToken(swapRequest, wallet) {
const buildTransactionOrder = {
slippage: swapRequest.slippage,
wallet_address: wallet.address,
network: 'SOL',
swap_order_id: swapRequest.id.toString()
};
const buildResponse = await axios__default["default"].post(this._buildTransApi, buildTransactionOrder);
const transactions = buildResponse.data.transaction; // setup transaction if must have
if (transactions.setupTransaction) {
const instructions = web3_js.Transaction.from(Buffer.from(transactions.setupTransaction, 'base64')).instructions;
const txSetUp = new web3_js.Transaction().add(...instructions);
await this.network.provider.sendTransaction(txSetUp, [wallet.signer], {
skipPreflight: false
});
} // execute swap
const swapInstructions = web3_js.Transaction.from(Buffer.from(transactions.swapTransaction, 'base64')).instructions;
const transactionSwap = new web3_js.Transaction().add(...swapInstructions);
const signature = await this.network.provider.sendTransaction(transactionSwap, [wallet.signer], {
skipPreflight: false
}); // clear cache if possible
if (transactions.cleanupTransaction) {
const cleanInstruction = web3_js.Transaction.from(Buffer.from(transactions.swapTransaction, 'base64')).instructions;
const txClean = new web3_js.Transaction().add(...cleanInstruction);
await this.network.provider.sendTransaction(txClean, [wallet.signer], {
skipPreflight: false
});
}
return signature;
}
}
exports.BSCSwap = BSCSwap;
exports.ETHSwap = ETHSwap;
exports.SPLSwap = SPLSwap;
exports.Swap = Swap;
//# sourceMappingURL=index.commonjs.js.map