@proton/wrap-constants 0.0.29 → 0.0.33

package/src/parsers.ts

@@ -1,334 +0,0 @@
-import * as z from 'zod'
-import { WRAP_CONTRACT, WRAP_AUTH_ACTION } from './constants'
-
-export enum Status {
-    PENDING    = 'pending',
-    SUCCESS    = 'success',
-    FAIL       = 'fail',
-    PROCESSING = 'processing'
-}
-
-export enum Type {
-    RECEIVE = 'receive',
-    SEND    = 'send'
-}
-
-export const accountParser = z.string().regex(/^[.1-5a-z]{0,12}[.1-5a-j]?$/)
-
-export const authorizationParser = z.object({
-    actor     : accountParser,
-    permission: z.string()
-})
-export type Authorization = z.infer<typeof authorizationParser>
-
-export const authorizationsParser = z.array(authorizationParser).min(1)
-export type Authorizations = z.infer<typeof authorizationsParser>
-
-export const rawTransactionParser = z.object({
-    expiration            : z.string(),
-    ref_block_num         : z.number(),
-    ref_block_prefix      : z.number(),
-    max_net_usage_words   : z.number(),
-    max_cpu_usage_ms      : z.number(),
-    delay_sec             : z.number(),
-    context_free_actions  : z.array(z.any()),
-    transaction_extensions: z.array(z.any())
-})
-
-const generateAuthActionsBaseParser = z.object({
-    account: z.literal(WRAP_CONTRACT),
-    name: z.literal(WRAP_AUTH_ACTION),
-    data: z.object({
-      time: z.string(),
-      protonAccount: z.string()
-    }),
-    authorization: authorizationsParser
-})
-export type GenerateAuthBaseAction = z.infer<typeof generateAuthActionsBaseParser>
-
-const generateAuthActionsWebAuthParser = z.object({
-    account: z.literal('webauthn'),
-    name: z.literal('exec'),
-    authorization: authorizationsParser,
-    data: z.object({
-        account: accountParser,
-        key: z.object({
-            key: z.array(z.string().or(z.object({
-                modulus: z.string(),
-                exponent: z.string()
-            }))),
-            user_presence: z.number(),
-            rpid: z.string()
-        }),
-        nonce: z.number(),
-        permissions: authorizationsParser,
-        signature: z.object({
-            auth_data: z.string(),
-            client_json: z.string(),
-            signature: z.string()
-        }),
-        trx: rawTransactionParser.merge(z.object({
-            actions: z.array(
-                z.object({
-                    account: z.literal(WRAP_CONTRACT),
-                    name: z.literal(WRAP_AUTH_ACTION),
-                    data: z.string().or(z.object({
-                        time: z.string(),
-                        protonAccount: z.string()
-                    })),
-                    authorization: authorizationsParser
-                })
-            ).length(1)
-        }))
-    })
-})
-
-export const generateAuthParser = z.object({
-    signer     : authorizationParser,
-    signatures : z.array(z.string()).length(1),
-    transaction: rawTransactionParser.merge(z.object({
-        actions: z.array(generateAuthActionsBaseParser.or(generateAuthActionsWebAuthParser)).length(1)
-    }))
-})
-export type GenerateAuth = z.infer<typeof generateAuthParser>
-
-export const generateAddressBodyParser = z.object({
-    coin: z.string(),
-    wallet: z.string(),
-}).merge(generateAuthParser)
-export type GenerateAddressBody = z.infer<typeof generateAddressBodyParser>
-
-export const generateAddressResponse = z.object({
-    id     : z.string(),            // "2448834505708930950",
-    address: z.string(),            // "0x617C03C1E2Bf81C062A4CEfbE312c070E1d86d18",
-    coin   : z.string(),            // "ETH",
-    wallet : z.string(),            // "ETH",
-    memo   : z.string().optional()
-})
-export type GenerateAddressResponse = z.infer<typeof generateAddressResponse>
-
-export const depositBodyParser = z.object({
-    id        : z.string(), // "0x000010203121388fac991"
-    type      : z.nativeEnum(Type), // "receive" or "send"
-    hash      : z.string(), // "0x000010203121388fac991"
-    coin      : z.string(), // "ETH" or "XPR"
-    wallet    : z.string(), // "ETH-ROPSTEN" or "XPR-MAINNET"
-})
-export type DepositBody = z.infer<typeof depositBodyParser>
-
-const withdrawBodyBaseAction = z.object({
-    account: accountParser,
-    name: z.literal('transfer'),
-    data: z.object({
-        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()
-    }),
-    authorization: authorizationsParser
-})
-export type WithdrawBodyBaseAction = z.infer<typeof withdrawBodyBaseAction>
-
-const withdrawBodyWebAuthAction = z.object({
-    account: z.literal('webauthn'),
-    name: z.literal('exec'),
-    authorization: authorizationsParser,
-    data: z.object({
-        account: accountParser,
-        key: z.object({
-            key: z.array(z.string().or(z.object({
-                modulus: z.string(),
-                exponent: z.string()
-            }))),
-            user_presence: z.number(),
-            rpid: z.string()
-        }),
-        nonce: z.number(),
-        permissions: authorizationsParser,
-        signature: z.object({
-            auth_data: z.string(),
-            client_json: z.string(),
-            signature: z.string()
-        }),
-        trx: rawTransactionParser.merge(z.object({
-            actions: z.array(
-                z.object({
-                    account: accountParser,
-                    name: z.literal('transfer'),
-                    data: z.string().or(z.object({
-                        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()
-                    })),
-                    authorization: authorizationsParser
-                })
-            ).length(1)
-        }))
-    })
-})
-
-export const withdrawBodyParser = z.object({
-    signer     : authorizationParser,
-    signatures : z.array(z.string()).length(1),
-    transaction: rawTransactionParser.merge(z.object({
-        actions: z.array(withdrawBodyBaseAction.or(withdrawBodyWebAuthAction)).length(1)
-    })),
-    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 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>
-
-const ExtendedAssetParser = z.object({
-    quantity: z.string(),
-    contract: accountParser
-})
-export type ExtendedAsset = z.infer<typeof ExtendedAssetParser>
-
-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>
-
-export const transactionParser = z.object({
-    id            : z.string(), // "2629304740076324677"
-    wallet        : z.string(), // "ETH"
-    value         : z.number(), // 10000000000000000
-    valueString   : z.string(), // "10000000000000000"
-    address       : z.string(), // "0x0000"
-    type          : z.nativeEnum(Type), // "receive" or "send"
-    state         : z.string(), // "confirmed"
-    confirmations : z.number(), // 1
-    hash          : z.string(), // "b4781422be95fee8fbbf720e3e0fa9705ae834474ef25f5724cdd0f5d23211ed"
-    blockHash     : z.string().optional().nullable(), // "000000000000000000089b270eb99f75107d6a9cde37ec944cb80a2998df7b43"
-    blockHeight   : z.number().optional().nullable(), // 643159
-})
-export type Transaction = z.infer<typeof transactionParser>
-
-export const addressParser = z.object({
-    index       : z.number(),
-    account     : accountParser,
-    chain       : z.string(),
-    address     : z.string(),
-    address_hash: z.string(),
-})
-export type Address = z.infer<typeof addressParser>
-
-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>
-
-export const rateParser = z.object({
-    counterCurrency   : z.string(),
-    price             : z.number(),
-    priceChangePercent: z.number(),
-    marketCap         : z.number(),
-    volume            : z.number(),
-    timestamp         : z.number()
-})
-export type Rate = z.infer<typeof rateParser>
-
-export const exchangeRateParser = z.object({
-    contract: z.string(),
-    symbol  : z.string(),
-    rank    : z.number(),
-    rates   : z.array(rateParser)
-})
-export type ExchangeRate = z.infer<typeof exchangeRateParser>
-
-export const exchangeRatesParser = z.array(exchangeRateParser)
-export type ExchangeRates = z.infer<typeof exchangeRatesParser>
-
-export const withdrawalFeeQuoteParser = z.object({
-    quoteId     : z.string(),
-    estimatedFee: z.string(),
-    currency    : z.string(),
-    network     : z.string(),
-})
-export type WithdrawalFeeQuote = z.infer<typeof withdrawalFeeQuoteParser>
-
-export interface CurrencyStat {
-    supply    : string;
-    max_supply: string;
-    issuer    : string;
-}
-export interface CurrencyStats {
-   [key: string]: CurrencyStat;
-}