mirror of
https://github.com/orionprotocol/sdk.git
synced 2026-03-14 14:12:35 +03:00
450 lines
13 KiB
TypeScript
450 lines
13 KiB
TypeScript
import { z } from 'zod';
|
|
import {
|
|
IDOSchema, atomicHistorySchema,
|
|
poolsConfigSchema, poolsInfoSchema, infoSchema, historySchema,
|
|
type addPoolSchema, adminPoolsListSchema, adminPoolSchema,
|
|
atomicSummarySchema,
|
|
poolsLpAndStakedSchema,
|
|
userVotesSchema,
|
|
userEarnedSchema,
|
|
type PairStatusEnum,
|
|
pairStatusSchema,
|
|
cfdContractsSchema,
|
|
cfdHistorySchema,
|
|
governanceContractsSchema,
|
|
governancePoolsSchema,
|
|
governancePoolSchema,
|
|
} from './schemas/index.js';
|
|
import type redeemOrderSchema from '../Aggregator/schemas/redeemOrderSchema.js';
|
|
import { sourceAtomicHistorySchema, targetAtomicHistorySchema } from './schemas/atomicHistorySchema.js';
|
|
import { makePartial } from '../../utils/index.js';
|
|
import type { networkCodes } from '../../constants/index.js';
|
|
import { fetchWithValidation } from 'simple-typed-fetch';
|
|
|
|
type IAdminAuthHeaders = {
|
|
auth: string
|
|
[key: string]: string
|
|
}
|
|
|
|
export type IEditPool = {
|
|
tokenAIcon?: string
|
|
tokenBIcon?: string
|
|
symbol?: string
|
|
status: PairStatusEnum
|
|
minQty?: number
|
|
tokenASymbol?: string
|
|
tokenBSymbol?: string
|
|
tokensReversed?: boolean
|
|
}
|
|
|
|
type AtomicSwapHistoryBaseQuery = {
|
|
limit?: number
|
|
sender?: string
|
|
receiver?: string
|
|
used?: 0 | 1
|
|
page?: number
|
|
sourceNetworkCode?: typeof networkCodes[number]
|
|
} & Partial<Record<string, string | number>>
|
|
|
|
type AtomicSwapHistorySourceQuery = AtomicSwapHistoryBaseQuery & {
|
|
type?: 'source'
|
|
expiredLock?: 0 | 1
|
|
state?: 'LOCKED' | 'CLAIMED' | 'REFUNDED'
|
|
|
|
}
|
|
type AtomicSwapHistoryTargetQuery = AtomicSwapHistoryBaseQuery & {
|
|
type?: 'target'
|
|
expiredRedeem?: 0 | 1
|
|
state?: 'REDEEMED' | 'BEFORE-REDEEM'
|
|
}
|
|
|
|
type CfdHistoryQuery = {
|
|
instrument?: string
|
|
page?: number
|
|
limit?: number
|
|
} & Partial<Record<string, string | number>>
|
|
class BlockchainService {
|
|
private readonly apiUrl: string;
|
|
|
|
get api() {
|
|
return this.apiUrl;
|
|
}
|
|
|
|
constructor(apiUrl: string) {
|
|
this.apiUrl = apiUrl;
|
|
|
|
this.getAtomicSwapAssets = this.getAtomicSwapAssets.bind(this);
|
|
this.getAtomicSwapHistory = this.getAtomicSwapHistory.bind(this);
|
|
this.getAuthToken = this.getAuthToken.bind(this);
|
|
this.getCirculatingSupply = this.getCirculatingSupply.bind(this);
|
|
this.getInfo = this.getInfo.bind(this);
|
|
this.getPoolsConfig = this.getPoolsConfig.bind(this);
|
|
this.getPoolsInfo = this.getPoolsInfo.bind(this);
|
|
this.getPoolsLpAndStaked = this.getPoolsLpAndStaked.bind(this);
|
|
this.getUserVotes = this.getUserVotes.bind(this);
|
|
this.getUserEarned = this.getUserEarned.bind(this);
|
|
this.getHistory = this.getHistory.bind(this);
|
|
this.getPrices = this.getPrices.bind(this);
|
|
this.getTokensFee = this.getTokensFee.bind(this);
|
|
this.getGasPriceWei = this.getGasPriceWei.bind(this);
|
|
this.checkFreeRedeemAvailable = this.checkFreeRedeemAvailable.bind(this);
|
|
this.redeemAtomicSwap = this.redeemAtomicSwap.bind(this);
|
|
this.redeem2AtomicSwaps = this.redeem2AtomicSwaps.bind(this);
|
|
this.checkRedeem = this.checkRedeem.bind(this);
|
|
this.checkRedeem2Atomics = this.checkRedeem2Atomics.bind(this);
|
|
this.getIDOInfo = this.getIDOInfo.bind(this);
|
|
this.checkAuth = this.checkAuth.bind(this);
|
|
this.addPool = this.addPool.bind(this);
|
|
this.editPool = this.editPool.bind(this);
|
|
this.getPool = this.getPool.bind(this);
|
|
this.getPoolsList = this.getPoolsList.bind(this);
|
|
this.getSourceAtomicSwapHistory = this.getSourceAtomicSwapHistory.bind(this);
|
|
this.getTargetAtomicSwapHistory = this.getTargetAtomicSwapHistory.bind(this);
|
|
this.checkPoolInformation = this.checkPoolInformation.bind(this);
|
|
this.checkIfHashUsed = this.checkIfHashUsed.bind(this);
|
|
this.getBlockNumber = this.getBlockNumber.bind(this);
|
|
this.getRedeemOrderBySecretHash = this.getRedeemOrderBySecretHash.bind(this);
|
|
this.claimOrder = this.claimOrder.bind(this);
|
|
this.getCFDContracts = this.getCFDContracts.bind(this);
|
|
this.getCFDHistory = this.getCFDHistory.bind(this);
|
|
this.getGovernanceContracts = this.getGovernanceContracts.bind(this);
|
|
this.getGovernancePools = this.getGovernancePools.bind(this);
|
|
this.getGovernancePool = this.getGovernancePool.bind(this);
|
|
}
|
|
|
|
get blockchainServiceWsUrl() {
|
|
return `${this.apiUrl}/`;
|
|
}
|
|
|
|
private readonly getSummaryRedeem = (brokerAddress: string, unshifted?: 1 | 0, sourceNetworkCode?: typeof networkCodes[number]) => {
|
|
const url = new URL(`${this.apiUrl}/api/atomic/summary-redeem/${brokerAddress}`);
|
|
if (unshifted !== undefined && unshifted === 1) {
|
|
url.searchParams.append('unshifted', unshifted.toString());
|
|
}
|
|
if (sourceNetworkCode !== undefined) {
|
|
url.searchParams.append('sourceNetworkCode', sourceNetworkCode);
|
|
}
|
|
return fetchWithValidation(
|
|
url.toString(),
|
|
atomicSummarySchema,
|
|
);
|
|
};
|
|
|
|
private readonly getSummaryClaim = (brokerAddress: string) => fetchWithValidation(
|
|
`${this.apiUrl}/api/atomic/summary-claim/${brokerAddress}`,
|
|
atomicSummarySchema,
|
|
);
|
|
|
|
private readonly getQueueLength = () => fetchWithValidation(
|
|
`${this.apiUrl}/api/queueLength`,
|
|
z.number().int(),
|
|
);
|
|
|
|
get internal() {
|
|
return {
|
|
getSummaryRedeem: this.getSummaryRedeem.bind(this),
|
|
getSummaryClaim: this.getSummaryClaim.bind(this),
|
|
getQueueLength: this.getQueueLength.bind(this),
|
|
};
|
|
}
|
|
|
|
getAuthToken = () => fetchWithValidation(
|
|
`${this.apiUrl}/api/auth/token`,
|
|
z.object({ token: z.string() }),
|
|
);
|
|
|
|
getCirculatingSupply = () => fetchWithValidation(
|
|
`${this.apiUrl}/api/circulating-supply`,
|
|
z.number(),
|
|
);
|
|
|
|
getInfo = () => fetchWithValidation(`${this.apiUrl}/api/info`, infoSchema);
|
|
|
|
getPoolsConfig = () => fetchWithValidation(
|
|
`${this.apiUrl}/api/pools/config`,
|
|
poolsConfigSchema,
|
|
);
|
|
|
|
getPoolsInfo = () => fetchWithValidation(
|
|
`${this.apiUrl}/api/pools/info`,
|
|
poolsInfoSchema,
|
|
);
|
|
|
|
getPoolsLpAndStaked = (address: string) => fetchWithValidation(
|
|
`${this.apiUrl}/api/pools/user-lp/${address}`,
|
|
poolsLpAndStakedSchema,
|
|
);
|
|
|
|
getUserVotes = (address: string) => fetchWithValidation(
|
|
`${this.apiUrl}/api/pools/user-votes/${address}`,
|
|
userVotesSchema,
|
|
);
|
|
|
|
getUserEarned = (address: string) => fetchWithValidation(
|
|
`${this.apiUrl}/api/pools/user-earned/${address}`,
|
|
userEarnedSchema,
|
|
);
|
|
|
|
getHistory = (address: string) => fetchWithValidation(
|
|
`${this.apiUrl}/api/history/${address}`,
|
|
historySchema,
|
|
);
|
|
|
|
getPrices = () => fetchWithValidation(
|
|
`${this.apiUrl}/api/prices`,
|
|
z.record(z.string()).transform(makePartial),
|
|
);
|
|
|
|
getCFDPrices = () => fetchWithValidation(
|
|
`${this.apiUrl}/api/cfd/prices`,
|
|
z.record(z.string()).transform(makePartial),
|
|
);
|
|
|
|
getTokensFee = () => fetchWithValidation(
|
|
`${this.apiUrl}/api/tokensFee`,
|
|
z.record(z.string()).transform(makePartial),
|
|
);
|
|
|
|
getGasPriceWei = () => fetchWithValidation(
|
|
`${this.apiUrl}/api/gasPrice`,
|
|
z.string(),
|
|
);
|
|
|
|
checkFreeRedeemAvailable = (walletAddress: string) => fetchWithValidation(
|
|
`${this.apiUrl}/api/atomic/has-free-redeem/${walletAddress}`,
|
|
z.boolean(),
|
|
);
|
|
|
|
getRedeemOrderBySecretHash = (secretHash: string) => fetchWithValidation(
|
|
`${this.apiUrl}/api/atomic/redeem-order/${secretHash}`,
|
|
z.object({
|
|
secretHash: z.string(),
|
|
secret: z.string(),
|
|
redeemTxHash: z.string(),
|
|
}),
|
|
);
|
|
|
|
claimOrder = (
|
|
secretHash: string,
|
|
targetNetwork: typeof networkCodes[number],
|
|
redeemTxHash?: string,
|
|
) => fetchWithValidation(
|
|
`${this.apiUrl}/api/atomic/claim-order`,
|
|
z.string(),
|
|
{
|
|
method: 'POST',
|
|
body: JSON.stringify({
|
|
secretHash,
|
|
targetNetwork,
|
|
redeemTxHash,
|
|
}),
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
},
|
|
},
|
|
);
|
|
|
|
redeemAtomicSwap = (
|
|
redeemOrder: z.infer<typeof redeemOrderSchema>,
|
|
secret: string,
|
|
sourceNetwork: typeof networkCodes[number],
|
|
) => fetchWithValidation(
|
|
`${this.apiUrl}/api/atomic/matcher-redeem`,
|
|
z.string(),
|
|
{
|
|
method: 'POST',
|
|
body: JSON.stringify({
|
|
order: redeemOrder,
|
|
secret,
|
|
sourceNetwork,
|
|
}),
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
},
|
|
},
|
|
);
|
|
|
|
redeem2AtomicSwaps = (
|
|
redeemOrder1: z.infer<typeof redeemOrderSchema>,
|
|
secret1: string,
|
|
redeemOrder2: z.infer<typeof redeemOrderSchema>,
|
|
secret2: string,
|
|
sourceNetwork: typeof networkCodes[number],
|
|
) => fetchWithValidation(
|
|
`${this.apiUrl}/api/atomic/matcher-redeem2atomics`,
|
|
z.string(),
|
|
{
|
|
method: 'POST',
|
|
body: JSON.stringify({
|
|
order1: redeemOrder1,
|
|
secret1,
|
|
order2: redeemOrder2,
|
|
secret2,
|
|
sourceNetwork,
|
|
}),
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
},
|
|
},
|
|
);
|
|
|
|
checkRedeem = (secretHash: string) => fetchWithValidation(
|
|
`${this.apiUrl}/api/atomic/matcher-redeem/${secretHash}`,
|
|
z.enum(['OK', 'FAIL']).nullable(),
|
|
);
|
|
|
|
checkRedeem2Atomics = (firstSecretHash: string, secondSecretHash: string) => fetchWithValidation(
|
|
`${this.apiUrl}/api/atomic/matcher-redeem/${firstSecretHash}-${secondSecretHash}`,
|
|
z.enum(['OK', 'FAIL']).nullable(),
|
|
);
|
|
|
|
getBlockNumber = () => fetchWithValidation(`${this.apiUrl}/api/blocknumber`, z.number().int());
|
|
|
|
getIDOInfo = () => fetchWithValidation(`${this.apiUrl}/api/solarflare`, IDOSchema);
|
|
|
|
checkAuth = (headers: IAdminAuthHeaders) => fetchWithValidation(`${this.apiUrl}/api/auth/check`, z.object({
|
|
auth: z.boolean(),
|
|
}), { headers });
|
|
|
|
getPool = (address: string, headers: IAdminAuthHeaders) => fetchWithValidation(
|
|
`${this.apiUrl}/api/pools/${address}`,
|
|
adminPoolSchema,
|
|
{ headers },
|
|
);
|
|
|
|
getPoolsList = (headers: IAdminAuthHeaders) => fetchWithValidation(
|
|
`${this.apiUrl}/api/pools/list`,
|
|
adminPoolsListSchema,
|
|
{ headers },
|
|
);
|
|
|
|
editPool = (address: string, data: IEditPool, headers: IAdminAuthHeaders) => fetchWithValidation(
|
|
`${this.apiUrl}/api/pools/edit/${address}`,
|
|
pairStatusSchema,
|
|
{
|
|
method: 'POST',
|
|
body: JSON.stringify(data),
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
...headers,
|
|
},
|
|
},
|
|
);
|
|
|
|
addPool = (data: z.infer<typeof addPoolSchema>) => fetchWithValidation(
|
|
`${this.apiUrl}/api/pools/add`,
|
|
z.number(),
|
|
{
|
|
method: 'POST',
|
|
body: JSON.stringify(data),
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
Accept: 'application/json',
|
|
},
|
|
},
|
|
z.string(),
|
|
);
|
|
|
|
checkPoolInformation = (poolAddress: string) => fetchWithValidation(
|
|
`${this.apiUrl}/api/pools/check/${poolAddress}`,
|
|
pairStatusSchema,
|
|
);
|
|
|
|
getAtomicSwapAssets = () => fetchWithValidation(
|
|
`${this.apiUrl}/api/atomic/swap-assets`,
|
|
z.array(z.string()),
|
|
);
|
|
|
|
/**
|
|
* Sender is user address in source BlockchainService instance \
|
|
* Receiver is user address in target BlockchainService instance
|
|
*/
|
|
getAtomicSwapHistory = (query: AtomicSwapHistorySourceQuery | AtomicSwapHistoryTargetQuery) => {
|
|
const url = new URL(`${this.apiUrl}/api/atomic/history/`);
|
|
|
|
Object.entries(query)
|
|
.forEach(([key, value]) => {
|
|
if (value === undefined) throw new Error('Value must be defined');
|
|
url.searchParams.append(key, value.toString());
|
|
});
|
|
|
|
return fetchWithValidation(url.toString(), atomicHistorySchema);
|
|
};
|
|
|
|
getSourceAtomicSwapHistory = (query: AtomicSwapHistorySourceQuery) => {
|
|
const url = new URL(`${this.apiUrl}/api/atomic/history/`);
|
|
|
|
Object.entries(query)
|
|
.forEach(([key, value]) => {
|
|
if (value === undefined) throw new Error('Value must be defined');
|
|
url.searchParams.append(key, value.toString());
|
|
});
|
|
|
|
if (query.type === undefined) url.searchParams.append('type', 'source');
|
|
|
|
return fetchWithValidation(url.toString(), sourceAtomicHistorySchema);
|
|
};
|
|
|
|
getTargetAtomicSwapHistory = (query: AtomicSwapHistoryTargetQuery) => {
|
|
const url = new URL(`${this.apiUrl}/api/atomic/history/`);
|
|
|
|
Object.entries(query)
|
|
.forEach(([key, value]) => {
|
|
if (value === undefined) throw new Error('Value must be defined');
|
|
url.searchParams.append(key, value.toString());
|
|
});
|
|
|
|
if (query.type === undefined) url.searchParams.append('type', 'target');
|
|
|
|
return fetchWithValidation(url.toString(), targetAtomicHistorySchema);
|
|
};
|
|
|
|
checkIfHashUsed = (secretHashes: string[]) => fetchWithValidation(
|
|
`${this.apiUrl}/api/atomic/is-hash-used`,
|
|
z.record(z.boolean()).transform(makePartial),
|
|
{
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
Accept: 'application/json',
|
|
},
|
|
method: 'POST',
|
|
body: JSON.stringify(secretHashes),
|
|
},
|
|
);
|
|
|
|
getCFDContracts = () => fetchWithValidation(
|
|
`${this.apiUrl}/api/cfd/contracts`,
|
|
cfdContractsSchema,
|
|
);
|
|
|
|
getCFDHistory = (address: string, query: CfdHistoryQuery = {}) => {
|
|
const url = new URL(`${this.apiUrl}/api/cfd/deposit-withdraw/${address}`);
|
|
|
|
Object.entries(query)
|
|
.forEach(([key, value]) => {
|
|
if (value === undefined) throw new Error('Value must be defined');
|
|
url.searchParams.append(key, value.toString());
|
|
});
|
|
|
|
return fetchWithValidation(url.toString(), cfdHistorySchema);
|
|
};
|
|
|
|
getGovernanceContracts = () => fetchWithValidation(
|
|
`${this.apiUrl}/api/governance/info`,
|
|
governanceContractsSchema,
|
|
);
|
|
|
|
getGovernancePools = () => fetchWithValidation(
|
|
`${this.apiUrl}/api/governance/pools`,
|
|
governancePoolsSchema,
|
|
);
|
|
|
|
getGovernancePool = (address: string) => fetchWithValidation(
|
|
`${this.apiUrl}/api/governance/pools/${address}`,
|
|
governancePoolSchema,
|
|
);
|
|
}
|
|
|
|
export * as schemas from './schemas/index.js';
|
|
export { BlockchainService };
|