@proton/wrap-constants 0.2.193 → 0.3.0

package/package.json

@@ -2,40 +2,54 @@
   "name": "@proton/wrap-constants",
   "author": "Metallicus",
   "module": "dist/index.mjs",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.193",
+  "version": "0.3.0",
   "license": "MIT",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "dist/index.cjs",
+  "typings": "dist/index.d.cts",
   "files": [
     "dist",
     "src"
   ],
   "engines": {
-    "node": ">=10"
+    "node": ">=20"
   },
   "devDependencies": {
     "@bloks/numbers": "^27.0.0",
-    "@size-limit/preset-small-lib": "^11.2.0",
+    "@eslint/js": "^10.0.1",
+    "@size-limit/preset-small-lib": "^14.3.0",
     "@types/lodash.clonedeep": "^4.5.6",
-    "@typescript-eslint/eslint-plugin": "^8.36.0",
-    "@typescript-eslint/parser": "^8.36.0",
-    "eslint": "^9.30.1",
-    "size-limit": "^11.2.0",
-    "tsup": "^8.5.0",
-    "typescript": "^4.8.4"
+    "eslint": "^10.11.0",
+    "size-limit": "^14.3.0",
+    "tsdown": "0.22.14",
+    "typescript": "~6.0.0",
+    "typescript-eslint": "^8.70.1"
   },
   "dependencies": {
     "bignumber.js": "^9.3.1",
     "lodash.clonedeep": "^4.5.0",
-    "zod": "^3.19.1"
+    "zod": "^4.6.7"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
-    "dev": "tsup src/index.ts --watch",
+    "build": "tsdown src/index.ts --format cjs,esm --dts",
+    "dev": "tsdown src/index.ts --watch",
     "size": "size-limit",
-    "analyze": "size-limit --why"
+    "analyze": "size-limit --why",
+    "lint": "eslint ."
   }
 }

package/src/coins.ts

@@ -1,4 +1,4 @@
-import { Asset } from "@bloks/numbers";
+import type { Asset } from "@bloks/numbers";
 
 export enum Chains {
   BitcoinMainnet = "Bitcoin",

package/src/parsers/actions.ts

@@ -1,82 +1,105 @@
-import * as z from 'zod';
-import { accountParser, authorizationsParser } from './base'
+import * as z from "zod";
+import { accountParser, authorizationsParser } from "./base";
 
 const actionParser = z.object({
-    account: z.string(),
-    name: z.string(),
-    authorization: z.array(
-        z.object({
-            actor: z.string(),
-            permission: z.string(),
-        })
-    ),
-    data: z.any(),
-    hex_data: z.string().optional()
-})
+  account: z.string(),
+  name: z.string(),
+  authorization: z.array(
+    z.object({
+      actor: z.string(),
+      permission: z.string(),
+    }),
+  ),
+  data: z.any(),
+  hex_data: z.string().optional(),
+});
 
-const transactionExtensionsParser = z.array(z.number().or(z.string())).optional()
+const transactionExtensionsParser = z
+  .array(z.number().or(z.string()))
+  .optional();
 
 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(actionParser),
-    transaction_extensions: z.array(transactionExtensionsParser)
-})
+  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(actionParser),
+  transaction_extensions: z.array(transactionExtensionsParser),
+});
 
-export const baseActionParser = <T extends z.ZodRawShape>(contract: string, action: string, data: T) => z.object({
-    account: contract === '*' ? accountParser : z.literal(contract),
+export const baseActionParser = <T extends z.ZodRawShape>(
+  contract: string,
+  action: string,
+  data: T,
+) =>
+  z.object({
+    account: contract === "*" ? accountParser : z.literal(contract),
     name: z.literal(action),
     data: z.object(data),
-    authorization: authorizationsParser
-})
+    authorization: authorizationsParser,
+  });
 
-export const baseActionSerializedParser = <T extends z.ZodRawShape>(contract: string, action: string, data: T) => z.object({
-    account: contract === '*' ? accountParser : z.literal(contract),
+export const baseActionSerializedParser = <T extends z.ZodRawShape>(
+  contract: string,
+  action: string,
+  data: T,
+) =>
+  z.object({
+    account: contract === "*" ? accountParser : z.literal(contract),
     name: z.literal(action),
     data: z.string().or(z.object(data)),
-    authorization: authorizationsParser
-})
+    authorization: authorizationsParser,
+  });
 
-export const webauthActionParser = <T extends z.ZodRawShape>(contract: string, action: string, data: T) => z.object({
-    account: z.literal('webauthn'),
-    name: z.literal('exec'),
+export const webauthActionParser = <T extends z.ZodRawShape>(
+  contract: string,
+  action: string,
+  data: T,
+) =>
+  z.object({
+    account: z.literal("webauthn"),
+    name: z.literal("exec"),
     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(
+      account: accountParser,
+      key: z.object({
+        key: z.array(
+          z.string().or(
             z.object({
-                actions: z.array(
-                    baseActionSerializedParser(contract, action, data)
-                ).length(1)
-            })
-        )
+              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.extend({
+        actions: z
+          .array(baseActionSerializedParser(contract, action, data))
+          .length(1),
+      }),
     }),
-    authorization: authorizationsParser
-})
+    authorization: authorizationsParser,
+  });
 
-export const singleActionTransactionParser = <T extends z.ZodRawShape>(contract: string, action: string, data: T) => {
-    const baseAction = baseActionParser(contract, action, data)
-    const webauthAction = webauthActionParser(contract, action, data)
+export const singleActionTransactionParser = <T extends z.ZodRawShape>(
+  contract: string,
+  action: string,
+  data: T,
+) => {
+  const baseAction = baseActionParser(contract, action, data);
+  const webauthAction = webauthActionParser(contract, action, data);
 
-    return rawTransactionParser.merge(z.object({
-        actions: z.array(baseAction.or(webauthAction)).length(1)
-    }))
-}
+  return rawTransactionParser.extend({
+    actions: z.array(baseAction.or(webauthAction)).length(1),
+  });
+};

package/src/parsers/address.ts

@@ -1,27 +1,27 @@
-import * as z from 'zod';
-import { accountParser } from './base'
-import { generateAuthParser } from './auth'
+import * as z from "zod";
+import { accountParser } from "./base";
+import { generateAuthParser } from "./auth";
 
 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>
+  index: z.number(),
+  account: accountParser,
+  chain: z.string(),
+  address: z.string(),
+  address_hash: z.string(),
+});
+export type Address = z.infer<typeof addressParser>;
 
-export const generateAddressBodyParser = z.object({
-    coin: z.string(),
-    wallet: z.string(),
-}).merge(generateAuthParser)
-export type GenerateAddressBody = z.infer<typeof generateAddressBodyParser>
+export const generateAddressBodyParser = generateAuthParser.extend({
+  coin: z.string(),
+  wallet: z.string(),
+});
+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>
+  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>;

package/src/parsers/auth.ts

@@ -1,7 +1,7 @@
 import * as z from "zod";
 import { baseActionParser, singleActionTransactionParser } from "./actions";
 import { authorizationParser } from "./base";
-import { WRAP_CONTRACT, WRAP_AUTH_ACTION } from "../constants";
+import { WRAP_AUTH_ACTION, WRAP_CONTRACT } from "../constants";
 
 export const createAbstractAuthParser = (
   contract: string,
@@ -19,7 +19,7 @@ const generateAuthData = {
   time: z.string(),
   protonAccount: z.string(),
 };
-const generateAuthActionsBaseParser = baseActionParser(
+export const generateAuthActionsBaseParser = baseActionParser(
   WRAP_CONTRACT,
   WRAP_AUTH_ACTION,
   generateAuthData

package/src/parsers/deposit.ts

@@ -7,7 +7,7 @@ export enum Type {
 
 export const depositBodyParser = z.object({
   id: z.string(), // "0x000010203121388fac991"
-  type: z.nativeEnum(Type), // "receive" or "send"
+  type: z.enum(Type), // "receive" or "send"
   hash: z.string(), // "0x000010203121388fac991"
   coin: z.string(), // "ETH" or "XPR"
   wallet: z.string(), // "ETH-SEPOLIA" or "XPR-MAINNET"
@@ -21,17 +21,11 @@ export const metalTransactionParser = z.object({
   value: z.number(), // 10000000000000000
   valueString: z.string(), // "10000000000000000"
   address: z.string(), // "0x0000"
-  type: z.nativeEnum(Type), // "receive" or "send"
+  type: z.enum(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
+  blockHash: z.string().optional().nullable(), // "000000000000000000089b270eb99f75107d6a9cde37ec944cb80a2998df7b43"
+  blockHeight: z.number().optional().nullable(), // 643159
 });
 export type MetalTransaction = z.infer<typeof metalTransactionParser>;

package/src/parsers/dex.ts

@@ -1,15 +1,19 @@
 import * as z from "zod";
 import { accountRamDeltaParser, authorizationParser } from "./base";
 
-const booleanParamSchema = z.boolean().or(z.enum(["true", "false"]).transform((value) => value === "true"))
+const booleanParamSchema = z
+  .boolean()
+  .or(z.enum(["true", "false"]).transform((value) => value === "true"));
 
 const createLimit = (base: number, max: number) =>
   z.coerce
-    .number()
+    .number<number>()
     .default(base)
-    .refine((n) => +n > 0 && +n <= max, `Limit must be between 0 and ${max}`);
+    .refine((n) => +n > 0 && +n <= max, {
+      error: `Limit must be between 0 and ${max}`,
+    });
 
-const createOffset = (base: number) => z.coerce.number().default(base);
+const createOffset = (base: number) => z.coerce.number<number>().default(base);
 
 const ordinalOrderIdsParser = z
   .array(z.string())
@@ -21,10 +25,12 @@ const ordinalOrderIdsParser = z
   });
 
 const marketIdsParser = z
-  .array(z.coerce.number())
-  .or(z.coerce.number())
+  .array(z.coerce.number<number>())
+  .or(z.coerce.number<number>())
   .transform((mids) => (Array.isArray(mids) ? mids : [mids]))
-  .refine((mids) => mids.length > 0, "Must provide atleast one market ID")
+  .refine((mids) => mids.length > 0, {
+    error: "Must provide atleast one market ID",
+  });
 
 const contractFiltersParser = z
   .array(z.string())
@@ -35,7 +41,7 @@ const contractFiltersParser = z
     return Array.isArray(oids) ? oids : [oids];
   });
 
-export const sortDirectionEnum = z.enum(["asc", "desc"])
+export const sortDirectionEnum = z.enum(["asc", "desc"]);
 export type SortDirection = z.input<typeof sortDirectionEnum>;
 
 /**
@@ -110,7 +116,7 @@ export const orderLogParser = z.object({
   status: z.string(),
   quantity_change: z.string(),
   trx_id: z.string(),
-})
+});
 export type OrderLog = z.infer<typeof orderLogParser>;
 
 export const orderHistoryParser = z.object({
@@ -209,11 +215,13 @@ export const postSubmitOrderResponseParser = z.object({
         ordinal_order_id: z.string(),
         order_id: z.string(),
         status: z.string(),
-      })
+      }),
     ),
   }),
 });
-export type PostSubmitOrderResponse = z.infer<typeof postSubmitOrderResponseParser>;
+export type PostSubmitOrderResponse = z.infer<
+  typeof postSubmitOrderResponseParser
+>;
 
 /**
  * Serialize Order
@@ -225,8 +233,8 @@ export const postSerializeOrderParser = z.object({
         account: z.string(),
         name: z.string(),
         authorization: z.array(authorizationParser),
-        data: z.record(z.any()),
-      })
+        data: z.record(z.string(), z.any()),
+      }),
     ),
   }),
 });
@@ -256,7 +264,7 @@ export type Depth = z.infer<typeof depthParser>;
 
 export const getDepthParser = z.object({
   symbol: z.string(),
-  step: z.coerce.number(),
+  step: z.coerce.number<number>(),
   limit: createLimit(100, 250),
 });
 export type GetDepth = z.input<typeof getDepthParser>;
@@ -496,9 +504,7 @@ export const getReferralsResponseParser = z.object({
   sync: z.number(),
   data: z.array(refferalParser),
 });
-export type GetReferralsResponse = z.infer<
-  typeof getReferralsResponseParser
->;
+export type GetReferralsResponse = z.infer<typeof getReferralsResponseParser>;
 
 /**
  * Leaderboard
@@ -513,7 +519,7 @@ export const getLeaderboardParser = z.object({
   market_ids: marketIdsParser,
   from: z.string(),
   to: z.string(),
-  exclude_zero_fee: booleanParamSchema.default('true'),
+  exclude_zero_fee: booleanParamSchema.prefault("true"),
 });
 export type GetLeaderboard = z.input<typeof getLeaderboardParser>;
 export type GetLeaderboardParsed = z.output<typeof getLeaderboardParser>;
@@ -556,7 +562,7 @@ export const receiptParser = z.object({
   global_sequence: z.string(),
   recv_sequence: z.string(),
   auth_sequence: z.array(
-    z.object({ account: z.string(), sequence: z.string() })
+    z.object({ account: z.string(), sequence: z.string() }),
   ),
   code_sequence: z.string(),
   abi_sequence: z.string(),
@@ -606,7 +612,7 @@ export const historyTransactionParser = z.object({
     block_timestamp: z.string(),
     trace: traceParser,
   }),
-  irreversible: z.boolean()
+  irreversible: z.boolean(),
 });
 export type HistoryTransaction = z.infer<typeof historyTransactionParser>;
 
@@ -637,14 +643,14 @@ export type DbHistoryTransaction = z.infer<typeof dbHistoryTransactionParser>;
  * History Actions
  */
 export const getHistoryActionsParser = z.object({
-  account: z.string().min(1, { message: 'account is required' }),
+  account: z.string().min(1, { error: "account is required" }),
   contract_filters: contractFiltersParser,
   account_seq_from: z.string().optional(),
   account_seq_to: z.string().optional(),
   date_from: z.string().optional(),
   date_to: z.string().optional(),
   direction: sortDirectionEnum.optional(),
-  limit: createLimit(100, 250)
+  limit: createLimit(100, 250),
 });
 export type GetHistoryActions = z.input<typeof getHistoryActionsParser>;
 export type GetHistoryActionsParsed = z.output<typeof getHistoryActionsParser>;
@@ -656,16 +662,18 @@ export const historyActionParser = z.object({
   account_action_seq: z.number(),
   global_action_seq: z.number(),
   action_trace: actionTraceParser,
-  irreversible: z.boolean()
+  irreversible: z.boolean(),
 });
 export type HistoryAction = z.infer<typeof historyActionParser>;
 
 export const getHistoryActionsResponseParser = z.object({
   sync: z.number(),
   last_irreversible_block_num: z.number(),
-  data: z.array(historyActionParser)
+  data: z.array(historyActionParser),
 });
-export type GetHistoryActionsResponse = z.infer<typeof getHistoryActionsResponseParser>;
+export type GetHistoryActionsResponse = z.infer<
+  typeof getHistoryActionsResponseParser
+>;
 
 /**
  * History transfers
@@ -683,10 +691,12 @@ export const getHistoryTransfersParser = z.object({
   global_seq_from: z.string().optional(),
   global_seq_to: z.string().optional(),
   direction: sortDirectionEnum.optional(),
-  limit: createLimit(100, 250)
+  limit: createLimit(100, 250),
 });
 export type GetHistoryTransfers = z.input<typeof getHistoryTransfersParser>;
-export type GetHistoryTransfersParsed = z.output<typeof getHistoryTransfersParser>;
+export type GetHistoryTransfersParsed = z.output<
+  typeof getHistoryTransfersParser
+>;
 
 export const historyTransferParser = z.object({
   block_num: z.number(),
@@ -695,16 +705,18 @@ export const historyTransferParser = z.object({
   account_action_seq: z.number(),
   global_action_seq: z.number(),
   action_trace: actionTraceParser,
-  irreversible: z.boolean()
+  irreversible: z.boolean(),
 });
 export type HistoryTransfer = z.infer<typeof historyTransferParser>;
 
 export const getHistoryTransfersResponseParser = z.object({
   sync: z.number(),
   last_irreversible_block_num: z.number(),
-  data: z.array(historyTransferParser)
+  data: z.array(historyTransferParser),
 });
-export type GetHistoryTransfersResponse = z.infer<typeof getHistoryTransfersResponseParser>;
+export type GetHistoryTransfersResponse = z.infer<
+  typeof getHistoryTransfersResponseParser
+>;
 
 /**
  * Open orders Balances
@@ -716,13 +728,17 @@ export const marketOpenOrdersBalanceParser = z.object({
   ask_token_quantity: z.number(),
   ask_token: z.string(),
 });
-export type MarketOpenOrdersBalance = z.infer<typeof marketOpenOrdersBalanceParser>;
+export type MarketOpenOrdersBalance = z.infer<
+  typeof marketOpenOrdersBalanceParser
+>;
 export const getOpenOrdersBalancesResponseParser = z.object({
   sync: z.number(),
-  data: z.array(marketOpenOrdersBalanceParser)
+  data: z.array(marketOpenOrdersBalanceParser),
 });
 
-export type GetOpenOrdersBalancesResponse = z.infer<typeof getOpenOrdersBalancesResponseParser>;
+export type GetOpenOrdersBalancesResponse = z.infer<
+  typeof getOpenOrdersBalancesResponseParser
+>;
 
 /**
  * Basic Types

package/src/parsers/login.ts

@@ -1,9 +1,8 @@
-import * as z from 'zod';
-import { generateAuthParser } from "./auth"
+import * as z from "zod";
+import { generateAuthParser } from "./auth";
 
-export const loginAccountParamsV3Parser = z.object({
-    email: z.string().optional(),
-    verificationCode: z.string().optional(),
-}).merge(generateAuthParser)
-  
-export type LoginAccountParamsV3 = z.infer<typeof loginAccountParamsV3Parser>
+export const loginAccountParamsV3Parser = generateAuthParser.extend({
+  email: z.string().optional(),
+  verificationCode: z.string().optional(),
+});
+export type LoginAccountParamsV3 = z.infer<typeof loginAccountParamsV3Parser>;

package/src/parsers/pool.ts

@@ -1,4 +1,4 @@
-import { ExtendedAsset } from "@bloks/numbers";
+import type { ExtendedAsset } from "@bloks/numbers";
 import { Coin } from "../coins";
 import { INode } from "../graph";
 

package/src/parsers/withdraw.ts

@@ -1,39 +1,39 @@
-import * as z from 'zod'
-import { singleActionTransactionParser } from './actions'
-import { authorizationParser } from './base'
-import { WRAP_CONTRACT } from '../constants'
-import { baseActionParser } from './actions'
+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>
+  from: z.string().refine((val) => val !== WRAP_CONTRACT, {
+    error: `${WRAP_CONTRACT} must be receiver`,
+  }),
+  to: z.literal(WRAP_CONTRACT),
+  quantity: z.string(),
+  memo: z.string(),
+};
+export 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>
+  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>
+  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>
+  quoteId: z.string(),
+  estimatedFee: z.string(),
+  currency: z.string(),
+  network: z.string(),
+});
+export type WithdrawalFeeQuote = z.infer<typeof withdrawalFeeQuoteParser>;