@proton/wrap-constants 0.1.1 → 0.2.2

package/src/parsers/dex.ts

@@ -0,0 +1,156 @@
+import { ExtendedAsset, ExtendedSymbol } from '@bloks/numbers';
+import * as z from 'zod';
+
+const numTransform = z.string().regex(/\d+/).transform(Number)
+
+export const ohlcvParser = z.object({
+  time: z.number(),
+  open: z.number(),
+  high: z.number(),
+  low: z.number(),
+  close: z.number(),
+  volume: z.number(),
+  volume_bid: z.number(),
+  count: z.number()
+})
+export type OHLCV = z.infer<typeof ohlcvParser>
+
+export const getOhlcvParser = z.object({
+  interval: z.string(),
+  dateFrom: z.string(),
+  dateTo: z.string(),
+  marketId: z.number().or(numTransform),
+  limit: z.number().or(numTransform).default(500).refine(n => n <= 1000, 'Max limit is 1000'),
+})
+export type GetOHLCV = z.infer<typeof getOhlcvParser>
+
+export const orderHistoryParser = z.object({
+  seq: z.number(),
+  block_num: z.number(),
+  block_time: z.string(),
+  order_id: z.number(),
+  market_id: z.number(),
+  quantity_init: z.number().optional(),
+  quantity_curr: z.number(),
+  price: z.number(),
+  account_name: z.string(),
+  order_side: z.number(),
+  order_type: z.number(),
+  status: z.string(),
+  quantity_change: z.number(),
+  trx_id: z.string(),
+})
+export type OrderHistory = z.infer<typeof orderHistoryParser>
+
+export const getOrderHistoryParser = z.object({
+  account: z.string(),
+  offset: z.number().or(numTransform).default(0),
+  limit: z.number().or(numTransform).default(100).refine(n => n <= 250, 'Max limit is 250'),
+})
+export type GetOrderHistory = z.infer<typeof getOrderHistoryParser>
+
+export const depthParser = z.object({
+  level: z.number(),
+  ask: z.number(),
+  bid: z.number(),
+  count: z.number(),
+})
+export type Depth = z.infer<typeof depthParser>
+
+export const getDepthParser = z.object({
+  marketId: z.number(),
+  step: z.string(),
+  side: z.string(),
+  limit: z.number().or(numTransform).default(100).refine(n => n <= 250, 'Max limit is 250'),
+})
+export type GetDepth = z.infer<typeof getDepthParser>
+
+export const tradeParser = z.object({
+  block_num: z.number(),
+  block_time: z.string(),
+  trade_id: z.number(),
+  market_id: z.number(),
+  price: z.number(),
+  bid_user: z.string(),
+  bid_user_order_id: z.number(),
+  bid_amount: z.number(),
+  bid_fee: z.number(),
+  ask_user: z.string(),
+  ask_user_order_id: z.number(),
+  ask_amount: z.number(),
+  ask_fee: z.number(),
+  order_side: z.number(),
+  trx_id: z.string(),
+})
+export type Trade = z.infer<typeof tradeParser>
+
+export const getTradesParser = z.object({
+  marketId: z.number().or(numTransform),
+  offset: z.number().or(numTransform).default(0),
+  limit: z.number().or(numTransform).default(100).refine(n => n <= 250, 'Max limit is 250'),
+})
+export type GetTrades = z.infer<typeof getTradesParser>
+
+export const syncParser = z.object({
+  sourceid: z.number(),
+  block_num: z.string(),
+  block_time: z.string(),
+  irreversible: z.string(),
+  is_master: z.number(),
+  last_updated: z.string(),
+})
+export type Sync = z.infer<typeof syncParser>
+
+export enum orderType { INVALID = 0, MARKET = 1, LIMIT = 2, STOPLOSS = 3, TAKEPROFIT = 4 }
+
+export enum orderSide { INVALID = 0, BUY = 1, SELL = 2 }
+
+export enum logStatus {
+    CREATE = "create",
+    UPDATE = "update",
+    TRANSFER = "transfer",
+    CANCEL = "cancel",
+    DELETE = "delete",
+}
+
+export interface CurrentOrder {
+  order_id: number
+  market_id: number
+  quantity_init: number
+  quantity_curr: number
+  price: number
+  account_name: string
+  order_side: number
+  order_type: number
+  status: string
+  created_at: string
+  updated_at: string
+}
+
+export interface RawMarket {
+    market_id: number
+    order_min: number
+    status_code: number
+    maker_fee: number
+    taker_fee: number
+    bid_token: {
+        sym: string
+        contract: string
+    }
+    ask_token: {
+        quantity: string
+        contract: string
+    }
+}
+
+export interface Market {
+    market_id: number
+    order_min: number
+    status_code: number
+    maker_fee: number
+    taker_fee: number
+    bid_token: ExtendedSymbol
+    ask_token: ExtendedAsset
+    bid_multiplier: number
+    ask_multiplier: number
+}

package/src/parsers/index.ts

@@ -0,0 +1,12 @@
+export * from './actions'
+export * from './address'
+export * from './auth'
+export * from './base'
+export * from './currency'
+export * from './deposit'
+export * from './otc'
+export * from './pool'
+export * from './withdraw'
+export * from './withdrawalHistory'
+export * from './wrap'
+export * from './dex'

package/src/parsers/otc.ts

@@ -0,0 +1,23 @@
+import * as z from 'zod'
+
+export const otcOrderResponseParser = z.object({
+    success       : z.boolean(),
+    transaction_id: z.string(),
+    errormsg      : z.string().optional()
+})
+export type OtcOrderResponse = z.infer<typeof otcOrderResponseParser>
+
+export const otcQuoteBodyParser = z.object({
+    baseAmount : z.number(),
+    baseSymbol : z.string(),
+    quoteSymbol: z.string()
+})
+export type OtcQuoteBody = z.infer<typeof otcQuoteBodyParser>
+
+export const otcQuoteResponseParser = z.object({
+    success : z.boolean(),
+    token   : z.string(),
+    qty     : z.number(),
+    errormsg: z.string().optional()
+})
+export type OtcQuoteResponse = z.infer<typeof otcQuoteResponseParser>

package/src/parsers/pool.ts

@@ -0,0 +1,51 @@
+import { Coin } from "../coins"
+import { ExtendedAsset } from '@bloks/numbers'
+import { INode } from "../graph";
+
+
+export interface RawPool {
+    lt_symbol: string;
+    creator: string;
+    memo: string;
+    pool1: {
+      quantity: string;
+      contract: string;
+    };
+    pool2: {
+      quantity: string;
+      contract: string;
+    };
+    hash: string;
+    fee: {
+      exchange_fee: number;
+      add_liquidity_fee: number;
+      remove_liquidity_fee: number;
+    };
+    active: boolean;
+    amplifier: number;
+}
+export interface Pool extends Omit<RawPool, 'pool1'|'pool2'> {
+  lt_symbol: string;
+  creator: string;
+  memo: string;
+  pool1: ExtendedTokenWithRate;
+  pool2: ExtendedTokenWithRate;
+  hash: string;
+  fee: {
+    exchange_fee: number;
+    add_liquidity_fee: number;
+    remove_liquidity_fee: number;
+  };
+  liquidityUsd: number;
+  liquidityApr: number;
+}
+  
+export type ExtendedToken = Coin & ExtendedAsset & { key: string; }
+export type ExtendedTokenWithRate = ExtendedToken & { rate: number; }
+
+export type PoolTable = {
+  pool1: ExtendedTokenWithRate;
+  pool2: ExtendedTokenWithRate;
+  path: INode<Pool>[];
+  getPathString: () => string;
+} | undefined

package/src/parsers/withdraw.ts

@@ -0,0 +1,39 @@
+import * as z from 'zod'
+import { singleActionTransactionParser } from './actions'
+import { authorizationParser } from './base'
+import { WRAP_CONTRACT } from '../constants'
+import { baseActionParser } from './actions'
+
+const withdrawData = {
+    from: z.string().refine((val) => val !== WRAP_CONTRACT, {
+        message: `${WRAP_CONTRACT} must be receiver`,
+    }),
+    to: z.literal(WRAP_CONTRACT),
+    quantity: z.string(),
+    memo: z.string()
+}
+const withdrawBodyBaseAction = baseActionParser('*', 'transfer', withdrawData)
+export type WithdrawBodyBaseAction = z.infer<typeof withdrawBodyBaseAction>
+
+export const withdrawBodyParser = z.object({
+    signer     : authorizationParser,
+    signatures : z.array(z.string()).length(1),
+    transaction: singleActionTransactionParser('*', 'transfer', withdrawData),
+    quoteId: z.string(),
+    provider: z.string().optional()
+})
+export type WithdrawBody = z.infer<typeof withdrawBodyParser>
+
+export const withdrawMetalResponseParser = z.object({
+    success: z.boolean(),
+    id     : z.string(),
+})
+export type WithdrawMetalResponse = z.infer<typeof withdrawMetalResponseParser>
+
+export const withdrawalFeeQuoteParser = z.object({
+    quoteId     : z.string(),
+    estimatedFee: z.string(),
+    currency    : z.string(),
+    network     : z.string(),
+})
+export type WithdrawalFeeQuote = z.infer<typeof withdrawalFeeQuoteParser>

package/src/parsers/withdrawalHistory.ts

@@ -0,0 +1,23 @@
+import * as z from 'zod'
+
+export const withdrawHistoryMetalSwapParser = z.object({
+    id               : z.string(),
+    status           : z.string(),
+    amount           : z.string(),
+    currency         : z.string(),
+    network          : z.string(),
+    created          : z.string(),
+    withdrawalAddress: z.string(),
+    withdrawalHash   : z.string().optional()
+})
+export type WithdrawHistoryMetalSwap = z.infer<typeof withdrawHistoryMetalSwapParser>
+
+export const withdrawHistoryMetalResponseParser = z.object({
+    swaps           : z.array(withdrawHistoryMetalSwapParser),
+    page            : z.number(),
+    pageSize        : z.number(),
+    numberOfElements: z.number(),
+    totalPages      : z.number(),
+    totalElements   : z.number()
+})
+export type WithdrawHistoryMetalResponse = z.infer<typeof withdrawHistoryMetalResponseParser>

package/src/parsers/wrap.ts

@@ -0,0 +1,41 @@
+import * as z from 'zod'
+import { ExtendedAssetParser } from './base'
+
+export enum Status {
+    PENDING    = 'pending',
+    SUCCESS    = 'success',
+    FAIL       = 'fail',
+    PROCESSING = 'processing'
+}
+
+export const wrapStartParser = z.object({
+    balance        : ExtendedAssetParser,
+    id             : z.string(),
+    txid           : z.string(),
+    chain          : z.string(),
+    deposit_address: z.string(),
+    confirmations  : z.number()
+})
+
+export type WrapStart = z.infer<typeof wrapStartParser>
+
+export const wrapSetConfParser = z.object({
+    wrap_hash    : z.string(),
+    confirmations: z.number()
+})
+export type WrapSetConf = z.infer<typeof wrapSetConfParser>
+
+export const wrapParser = z.object({
+    index          : z.number(),
+    proton_account : z.string(),
+    balance        : ExtendedAssetParser,
+    id             : z.string(),
+    txid           : z.string(),
+    chain          : z.string(),
+    deposit_address: z.string(),
+    status         : z.nativeEnum(Status),
+    finish_txid    : z.string(),
+    wrap_hash      : z.string(),
+    confirmations  : z.number(),
+})
+export type Wrap = z.infer<typeof wrapParser>

package/src/utils.ts

@@ -8,4 +8,15 @@ export const isSameToken = (token1: PartialCoin, token2: PartialCoin) => {
     return token1.xtokenSymbol === token2.xtokenSymbol &&
            token1.xtokenPrecision === token2.xtokenPrecision &&
            token1.xtokenContract === token2.xtokenContract
-}
+}
+
+export const median = (numbers: number[]) => {
+    const sorted = numbers.slice().sort((a, b) => a - b);
+    const middle = Math.floor(sorted.length / 2);
+
+    if (sorted.length % 2 === 0) {
+        return (sorted[middle - 1] + sorted[middle]) / 2;
+    }
+
+    return sorted[middle];
+}