@argent/x-shared 1.62.12 → 1.63.0

package/dist/src/features/defiDecomposition/schema.js

@@ -0,0 +1,153 @@
+import { z as t } from "zod";
+import { webBaseTokenSchema as o } from "../../tokens/service/types/webToken.model.js";
+import { productGroupsSchema as D } from "../../tokens/service/types/defiPosition.model.js";
+import { stakerInfoSchema as U } from "../../staking/schema.js";
+const i = o.extend({
+  balance: t.string()
+}), a = i.extend({
+  usdValue: t.string()
+}), n = i.extend({
+  principal: t.string(),
+  accruedFees: t.string(),
+  minPrice: t.string(),
+  maxPrice: t.string(),
+  currentPrice: t.string()
+}), u = n.extend({
+  usdValue: t.string()
+}), d = t.object({
+  id: t.string(),
+  poolFeePercentage: t.string(),
+  tickSpacingPercentage: t.string().optional(),
+  token0: n,
+  token1: n,
+  liquidityToken: o.optional()
+}), m = d.extend({
+  totalUsdValue: t.string(),
+  token0: u,
+  token1: u,
+  liquidityToken: o.optional()
+}), I = t.object({
+  totalUsdValue: t.string(),
+  positions: t.array(m)
+}), s = t.object({
+  id: t.string(),
+  collateral: t.boolean(),
+  debt: t.boolean(),
+  lending: t.boolean(),
+  apy: t.string().optional(),
+  totalApy: t.string().optional(),
+  group: t.string().optional(),
+  token: i,
+  liquidityToken: o.optional()
+}), r = s.extend({
+  token: a
+}), l = t.object({
+  id: t.string(),
+  group: t.string(),
+  healthRatio: t.string().optional(),
+  collateralizedPositions: t.array(s),
+  debtPositions: t.array(s)
+}), f = l.extend({
+  totalUsdValue: t.string(),
+  collateralizedPositions: t.array(r),
+  debtPositions: t.array(r),
+  collateralizedPositionsTotalUsdValue: t.string(),
+  debtPositionsTotalUsdValue: t.string()
+}), h = s.or(l), P = r.or(f), B = t.object({
+  totalUsdValue: t.string(),
+  positions: t.array(P)
+}), c = t.object({
+  id: t.string(),
+  investmentId: t.string().optional(),
+  apy: t.string(),
+  totalApy: t.string().optional(),
+  token: i,
+  liquidityToken: o.optional()
+}), S = c.extend({
+  token: a
+}), A = t.object({
+  totalUsdValue: t.string(),
+  positions: t.array(S)
+}), p = t.object({
+  id: t.string(),
+  investmentId: t.string().optional(),
+  stakerInfo: U,
+  pendingWithdrawal: t.object({
+    amount: t.string(),
+    withdrawableAfter: t.number()
+  }).optional(),
+  accruedRewards: t.string(),
+  stakedAmount: t.string(),
+  apy: t.string().optional(),
+  totalApy: t.string().optional(),
+  token: i
+}), k = p.extend({
+  token: a
+}), v = t.object({
+  totalUsdValue: t.string(),
+  positions: t.array(k)
+}), g = t.object({
+  id: t.string(),
+  delegatingTo: t.string(),
+  token: i,
+  liquidityToken: o.optional()
+}), b = g.extend({
+  token: a
+}), F = t.object({
+  totalUsdValue: t.string(),
+  positions: t.array(b)
+}), T = d.or(h).or(g).or(p).or(c), W = m.or(P).or(b).or(k).or(S), z = t.union([
+  t.literal("concentratedLiquidityPosition"),
+  t.literal("collateralizedDebtLendingPosition"),
+  t.literal("collateralizedDebtBorrowingPosition"),
+  t.literal("delegatedTokens"),
+  t.literal("strkDelegatedStaking"),
+  t.literal("staking")
+]), y = t.object({
+  type: z,
+  productId: t.string().optional(),
+  manageUrl: t.string().url().optional(),
+  name: t.string(),
+  positions: t.array(T),
+  groups: D.optional()
+}), C = y.extend({
+  positions: t.array(W),
+  totalUsdValue: t.string()
+}), V = t.object({
+  dappId: t.string(),
+  products: t.array(y)
+}), R = t.array(V), j = V.extend({
+  dappId: t.string(),
+  products: t.array(C),
+  totalUsdValue: t.string()
+}), G = t.array(j), E = (e) => s.safeParse(e).success, H = (e) => l.safeParse(e).success, J = (e) => h.safeParse(e).success, K = (e) => g.safeParse(e).success, M = (e) => c.safeParse(e).success, N = (e) => p.safeParse(e).success, O = (e) => d.safeParse(e).success;
+export {
+  z as argentDefiPositionTypeSchema,
+  H as isCollateralizedDebtBorrowingPosition,
+  E as isCollateralizedDebtLendingPosition,
+  J as isCollateralizedDebtPosition,
+  O as isConcentratedLiquidityPosition,
+  K as isDelegatedTokensPosition,
+  M as isStakingPosition,
+  N as isStrkDelegatedStakingPosition,
+  f as parsedCollateralizedDebtBorrowingPositionWithUsdValueSchema,
+  s as parsedCollateralizedDebtLendingPositionSchema,
+  h as parsedCollateralizedDebtPositionSchema,
+  P as parsedCollateralizedDebtPositionWithUsdValueSchema,
+  B as parsedCollateralizedDebtPositionsWithUsdValueSchema,
+  d as parsedConcentratedLiquidityPositionSchema,
+  m as parsedConcentratedLiquidityPositionWithUsdValueSchema,
+  I as parsedConcentratedLiquidityPositionsWithUsdValueSchema,
+  V as parsedDefiDecompositionItemSchema,
+  j as parsedDefiDecompositionItemWithUsdValueSchema,
+  R as parsedDefiDecompositionSchema,
+  G as parsedDefiDecompositionWithUsdValueSchema,
+  b as parsedDelegatedTokensPositionWithUsdValueSchema,
+  F as parsedDelegatedTokensPositionsWithUsdValueSchema,
+  T as parsedPositionSchema,
+  W as parsedPositionWithUsdValueSchema,
+  y as parsedProductSchema,
+  C as parsedProductWithUsdValueSchema,
+  A as parsedStakingPositionsWithUsdValueSchema,
+  v as parsedStrkDelegatedStakingPositionsWithUsdValueSchema
+};

package/dist/src/features/paymaster/types.d.ts

@@ -11,15 +11,15 @@ export declare const paymasterExecutionDataParams: z.ZodObject<{
     calls: import('starknet').Call[];
     maxFee: string | number | bigint;
     feeTokenAddress: `0x${string}`;
-    accountClassHash?: string | undefined;
     networkId?: "mainnet-alpha" | "sepolia-alpha" | "mainnet" | "sepolia" | undefined;
+    accountClassHash?: string | undefined;
 }, {
     accountAddress: string;
     calls: import('starknet').Call[];
     maxFee: string | number | bigint;
     feeTokenAddress: string;
-    accountClassHash?: string | undefined;
     networkId?: "mainnet-alpha" | "sepolia-alpha" | "mainnet" | "sepolia" | undefined;
+    accountClassHash?: string | undefined;
 }>;
 export type PaymasterExecutionDataParams = z.infer<typeof paymasterExecutionDataParams>;
 export declare const paymasterExecuteParams: z.ZodObject<{
@@ -31,34 +31,34 @@ export declare const paymasterExecuteParams: z.ZodObject<{
             type: z.ZodLiteral<"merkletree">;
             contains: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            name: string;
             type: "merkletree";
+            name: string;
             contains: string;
         }, {
-            name: string;
             type: "merkletree";
+            name: string;
             contains: string;
         }>, z.ZodObject<{
             name: z.ZodString;
             type: z.ZodLiteral<"enum">;
             contains: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            name: string;
             type: "enum";
+            name: string;
             contains: string;
         }, {
-            name: string;
             type: "enum";
+            name: string;
             contains: string;
         }>, z.ZodObject<{
             name: z.ZodString;
             type: z.ZodString;
         }, "strip", z.ZodTypeAny, {
-            name: string;
             type: string;
-        }, {
             name: string;
+        }, {
             type: string;
+            name: string;
         }>]>, "many">>;
         primaryType: z.ZodString;
         domain: z.ZodRecord<z.ZodString, z.ZodUnknown>;
@@ -66,32 +66,32 @@ export declare const paymasterExecuteParams: z.ZodObject<{
     }, "strip", z.ZodTypeAny, {
         message: Record<string, any> | z.objectOutputType<{}, z.ZodTypeAny, "passthrough">;
         types: Record<string, ({
-            name: string;
             type: "merkletree";
+            name: string;
             contains: string;
         } | {
-            name: string;
             type: "enum";
+            name: string;
             contains: string;
         } | {
-            name: string;
             type: string;
+            name: string;
         })[]>;
         primaryType: string;
         domain: Record<string, unknown>;
     }, {
         message: Record<string, any> | z.objectInputType<{}, z.ZodTypeAny, "passthrough">;
         types: Record<string, ({
-            name: string;
             type: "merkletree";
+            name: string;
             contains: string;
         } | {
-            name: string;
             type: "enum";
+            name: string;
             contains: string;
         } | {
-            name: string;
             type: string;
+            name: string;
         })[]>;
         primaryType: string;
         domain: Record<string, unknown>;
@@ -119,16 +119,16 @@ export declare const paymasterExecuteParams: z.ZodObject<{
     typedData: {
         message: Record<string, any> | z.objectOutputType<{}, z.ZodTypeAny, "passthrough">;
         types: Record<string, ({
-            name: string;
             type: "merkletree";
+            name: string;
             contains: string;
         } | {
-            name: string;
             type: "enum";
+            name: string;
             contains: string;
         } | {
-            name: string;
             type: string;
+            name: string;
         })[]>;
         primaryType: string;
         domain: Record<string, unknown>;
@@ -146,16 +146,16 @@ export declare const paymasterExecuteParams: z.ZodObject<{
     typedData: {
         message: Record<string, any> | z.objectInputType<{}, z.ZodTypeAny, "passthrough">;
         types: Record<string, ({
-            name: string;
             type: "merkletree";
+            name: string;
             contains: string;
         } | {
-            name: string;
             type: "enum";
+            name: string;
             contains: string;
         } | {
-            name: string;
             type: string;
+            name: string;
         })[]>;
         primaryType: string;
         domain: Record<string, unknown>;