@argent/x-shared 1.42.1 → 1.43.0

package/dist/src/tokens/service/types/backend.model.js

@@ -1,132 +1,134 @@
-import { z as a } from "zod";
-import { addressSchemaArgentBackend as n, addressSchema as t } from "../../../chains/starknet/address.js";
+import { z as t } from "zod";
+import { addressSchemaArgentBackend as o, addressSchema as a } from "../../../chains/starknet/address.js";
 import { defiPositionTypeSchema as d } from "./defiPositionType.model.js";
 import { createSchemaWithWarnings as g } from "../../../utils/schemas.js";
-const f = a.object({
-  status: a.literal("initialising")
-}).or(a.object({
-  status: a.literal("initialised"),
-  balances: a.array(a.object({
-    tokenAddress: n,
-    tokenBalance: a.string()
+const f = t.object({
+  status: t.literal("initialising")
+}).or(t.object({
+  status: t.literal("initialised"),
+  balances: t.array(t.object({
+    tokenAddress: o,
+    tokenBalance: t.string()
   }))
-})), i = a.object({
-  id: a.number(),
-  address: t,
-  brandColor: a.string().optional(),
-  name: a.string(),
-  symbol: a.string(),
-  decimals: a.number(),
-  iconUrl: a.string().optional(),
-  sendable: a.boolean(),
-  popular: a.boolean(),
-  refundable: a.boolean(),
-  listed: a.boolean(),
-  tradable: a.boolean(),
-  category: a.union([
-    a.literal("tokens"),
-    a.literal("currencies"),
-    a.literal("savings")
+})), i = t.object({
+  id: t.number(),
+  address: a,
+  brandColor: t.string().optional(),
+  name: t.string(),
+  symbol: t.string(),
+  decimals: t.number(),
+  iconUrl: t.string().optional(),
+  sendable: t.boolean(),
+  popular: t.boolean(),
+  refundable: t.boolean(),
+  listed: t.boolean(),
+  tradable: t.boolean(),
+  category: t.union([
+    t.literal("tokens"),
+    t.literal("currencies"),
+    t.literal("savings")
   ]),
-  pricingId: a.number().optional(),
-  dappId: a.string().optional(),
-  marketData: a.object({
-    marketCap: a.number(),
-    marketCap24hChange: a.number(),
-    dailyVolume: a.number(),
-    rank: a.number()
+  pricingId: t.number().optional(),
+  dappId: t.string().optional(),
+  marketData: t.object({
+    marketCap: t.number(),
+    marketCap24hChange: t.number(),
+    dailyVolume: t.number(),
+    rank: t.number()
   }).optional(),
-  tags: a.array(a.string()).optional()
-}), I = a.object({
-  tokens: a.array(i)
-}), A = i, m = a.object({
-  pricingId: a.number(),
-  ethValue: a.string(),
-  ccyValue: a.string(),
-  ethDayChange: a.string(),
-  ccyDayChange: a.string()
-}), C = a.object({
-  prices: a.array(m)
-}), o = a.object({
-  tokenAddress: n,
-  principal: a.string(),
-  accruedFees: a.string(),
-  minPrice: a.string(),
-  maxPrice: a.string(),
-  currentPrice: a.string()
-}), e = a.object({
-  id: a.string(),
-  investmentId: a.string().optional(),
-  tokenAddress: t.optional(),
-  totalBalances: a.record(a.string())
+  tags: t.array(t.string()).optional()
+}), I = t.object({
+  tokens: t.array(i)
+}), A = i, m = t.object({
+  pricingId: t.number(),
+  ethValue: t.string(),
+  ccyValue: t.string(),
+  ethDayChange: t.string(),
+  ccyDayChange: t.string()
+}), C = t.object({
+  prices: t.array(m)
+}), n = t.object({
+  tokenAddress: o,
+  principal: t.string(),
+  accruedFees: t.string(),
+  minPrice: t.string(),
+  maxPrice: t.string(),
+  currentPrice: t.string()
+}), e = t.object({
+  id: t.string(),
+  investmentId: t.string().optional(),
+  tokenAddress: a.optional(),
+  totalBalances: t.record(t.string())
 }), r = e.extend({
-  tokenId: a.string(),
-  data: a.object({
-    poolFeePercentage: a.string(),
-    tickSpacingPercentage: a.string().optional(),
-    token0: o,
-    token1: o
+  tokenId: t.string(),
+  data: t.object({
+    poolFeePercentage: t.string(),
+    tickSpacingPercentage: t.string().optional(),
+    token0: n,
+    token1: n
   })
-}), T = a.array(r), s = e.extend({
-  data: a.object({
-    apy: a.string()
+}), T = t.array(r), s = e.extend({
+  data: t.object({
+    apy: t.string()
   }),
-  investmentId: a.string().optional(),
-  totalBalances: a.record(a.string())
-}), x = a.array(s), c = e.extend({
-  data: a.object({
-    apy: a.string().optional(),
-    group: a.number().optional(),
-    collateral: a.boolean(),
-    debt: a.boolean(),
-    lending: a.boolean()
+  investmentId: t.string().optional(),
+  totalBalances: t.record(t.string())
+}), x = t.array(s), c = e.extend({
+  data: t.object({
+    apy: t.string().optional(),
+    group: t.number().optional(),
+    collateral: t.boolean(),
+    debt: t.boolean(),
+    lending: t.boolean()
   })
-}), B = a.array(c), l = e.extend({
-  id: a.string(),
-  data: a.object({
-    delegatingTo: t
+}), B = t.array(c), l = e.extend({
+  id: t.string(),
+  data: t.object({
+    delegatingTo: a
   }),
-  totalBalances: a.record(a.string())
-}), R = a.array(l), p = e.extend({
-  data: a.object({
-    stakerInfo: a.object({
-      name: a.string().optional(),
-      iconUrl: a.string().optional(),
-      address: t
+  totalBalances: t.record(t.string())
+}), R = t.array(l), p = e.extend({
+  investmentId: t.string(),
+  data: t.object({
+    stakerInfo: t.object({
+      name: t.string().optional(),
+      iconUrl: t.string().optional(),
+      address: a
     }),
-    accruedRewards: a.string(),
-    pendingWithdrawal: a.object({
-      amount: a.string(),
-      withdrawableAfter: a.number()
+    accruedRewards: t.string(),
+    stakedAmount: t.string(),
+    pendingWithdrawal: t.object({
+      amount: t.string(),
+      withdrawableAfter: t.number()
     }).optional(),
-    apy: a.string().optional()
+    apy: t.string().optional()
   })
-}), w = a.array(p), b = r.or(c).or(l).or(s).or(p), h = a.array(b), u = g({
-  productId: a.string().optional(),
-  name: a.string(),
-  manageUrl: a.string(),
+}), w = t.array(p), b = r.or(c).or(l).or(s).or(p), h = t.array(b), u = g({
+  productId: t.string().optional(),
+  name: t.string(),
+  manageUrl: t.string(),
   type: d,
-  groups: a.record(a.object({
-    name: a.string().optional(),
-    healthRatio: a.string().optional()
+  groups: t.record(t.object({
+    name: t.string().optional(),
+    healthRatio: t.string().optional()
   })).optional(),
   positions: h
-}), S = a.object({
-  dappId: a.string(),
-  products: a.array(u)
-}), U = a.object({
-  dapps: a.array(S)
-}), k = a.object({
-  name: a.string().optional(),
-  tokenAddress: t,
-  amount: a.string().optional(),
-  claimUrl: a.string().optional(),
-  claimStart: a.number(),
-  claimEnd: a.number().optional()
-}), v = a.object({
-  accountAddress: t,
-  chain: a.string(),
-  airdrops: a.array(k)
+}), S = t.object({
+  dappId: t.string(),
+  products: t.array(u)
+}), U = t.object({
+  dapps: t.array(S)
+}), k = t.object({
+  name: t.string().optional(),
+  tokenAddress: a,
+  amount: t.string().optional(),
+  claimUrl: t.string().optional(),
+  claimStart: t.number(),
+  claimEnd: t.number().optional()
+}), v = t.object({
+  accountAddress: a,
+  chain: t.string(),
+  airdrops: t.array(k)
 });
 export {
   f as apiAccountTokenBalancesSchema,
@@ -138,7 +140,7 @@ export {
   u as apiDefiDecompositionProduct,
   h as apiDefiDecompositionProducts,
   S as apiDefiDecompositionSchema,
-  o as apiDefiDecompositionToken,
+  n as apiDefiDecompositionToken,
   b as apiDefiPositionSchema,
   U as apiDefiPositionsSchema,
   R as apiDelegatedTokensArraySchema,

package/dist/src/transactions/estimate/error.d.ts

@@ -1,4 +1,4 @@
-import { BaseError, BaseErrorPayload } from '../../errors/baseErrors';
+import { BaseErrorPayload, BaseError } from '../../errors/baseErrors';
 export declare enum ESTIMATE_ERROR_MESSAGES {
     SIMULATE_AND_REVIEW_FAILED = "Missing simulation"
 }

package/dist/src/transactions/index.d.ts

@@ -1,16 +1,16 @@
-export * from './aggregatedSimDataTypes';
+export type * from './aggregatedSimDataTypes';
 export * from './amount';
 export * from './buildTransactions';
-export * from './deployAccountTypes';
+export type * from './deployAccountTypes';
 export * from './errors';
 export * from './estimate';
 export * from './findTransfersAndApprovals';
 export * from './getPrettyRcpError';
 export * from './getTransactionVersion';
 export * from './service';
-export * from './transactionAction';
+export type * from './transactionAction';
 export * from './transactionReviewTypes';
-export * from './transactionSimulationTypes';
+export type * from './transactionSimulationTypes';
 export * from './transactionVersion';
 export * from './txv3';
-export * from './types';
+export type * from './types';

package/dist/src/transactions/service/index.d.ts

@@ -1,3 +1,3 @@
 export * from './implementation';
-export * from './interface';
+export type * from './interface';
 export * from './types';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@argent/x-shared",
-  "version": "1.42.1",
+  "version": "1.43.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/argentlabs/x-shared.git"