@leather.io/models 0.45.0 → 0.47.0

package/dist/index.js

@@ -1,29 +1,54 @@
-// src/assets/asset.model.ts
-var CryptoAssetChains = {
-  bitcoin: "bitcoin",
-  stacks: "stacks"
+// src/account.model.ts
+import { z } from "zod";
+var walletIdSchema = z.object({
+  fingerprint: z.string()
+});
+var accountIdSchema = walletIdSchema.and(z.object({ accountIndex: z.number() }));
+var bitcoinAddressInfoSchema = z.object({
+  taprootDescriptor: z.string(),
+  nativeSegwitDescriptor: z.string(),
+  zeroIndexTaprootPayerAddress: z.string().optional(),
+  zeroIndexNativeSegwitPayerAddress: z.string().optional()
+});
+var stacksAddressInfoSchema = z.object({
+  stxAddress: z.string()
+});
+var accountAddressesSchema = z.object({
+  id: accountIdSchema,
+  bitcoin: bitcoinAddressInfoSchema.optional(),
+  stacks: stacksAddressInfoSchema.optional()
+});
+
+// src/activity/activity-level.model.ts
+var ActivityLevels = {
+  account: "account",
+  app: "app"
 };
-var CryptoAssetCategories = {
-  fungible: "fungible",
-  nft: "nft"
+
+// src/activity/activity-status.model.ts
+var OnChainActivityStatuses = {
+  pending: "pending",
+  success: "success",
+  failed: "failed"
 };
-var FungibleCryptoAssetProtocols = {
-  nativeBtc: "nativeBtc",
-  nativeStx: "nativeStx",
-  sip10: "sip10",
-  brc20: "brc20",
-  src20: "src20",
-  stx20: "stx20",
-  rune: "rune"
+
+// src/activity/activity-type.model.ts
+var OnChainActivityTypes = {
+  deploySmartContract: "deploySmartContract",
+  executeSmartContract: "executeSmartContract",
+  lockAsset: "lockAsset",
+  sendAsset: "sendAsset",
+  receiveAsset: "receiveAsset",
+  swapAssets: "swapAssets"
 };
-var NonFungibleCryptoAssetProtocols = {
-  stamp: "stamp",
-  sip9: "sip9",
-  inscription: "inscription"
+var WalletActivityTypes = {
+  connectApp: "connectApp",
+  signMessage: "signMessage"
 };
-var CryptoAssetProtocols = {
-  ...FungibleCryptoAssetProtocols,
-  ...NonFungibleCryptoAssetProtocols
+var GeneralActivityTypes = {
+  walletAdded: "walletAdded",
+  receiveAnnouncement: "receiveAnnouncement",
+  featureWaitlistNotification: "featureWaitlistNotification"
 };
 
 // src/assets/asset-type-guards.ts
@@ -70,6 +95,34 @@ function isSip9Asset(asset) {
   return asset.protocol === "sip9";
 }
 
+// src/assets/asset.model.ts
+var CryptoAssetChains = {
+  bitcoin: "bitcoin",
+  stacks: "stacks"
+};
+var CryptoAssetCategories = {
+  fungible: "fungible",
+  nft: "nft"
+};
+var FungibleCryptoAssetProtocols = {
+  nativeBtc: "nativeBtc",
+  nativeStx: "nativeStx",
+  sip10: "sip10",
+  brc20: "brc20",
+  src20: "src20",
+  stx20: "stx20",
+  rune: "rune"
+};
+var NonFungibleCryptoAssetProtocols = {
+  stamp: "stamp",
+  sip9: "sip9",
+  inscription: "inscription"
+};
+var CryptoAssetProtocols = {
+  ...FungibleCryptoAssetProtocols,
+  ...NonFungibleCryptoAssetProtocols
+};
+
 // src/assets/sip9-asset.model.ts
 var sip9ContentTypes = [
   "image/jpeg",
@@ -111,17 +164,16 @@ var sip9ContentTypes = [
   ""
 ];
 
-// src/inscription-mime-type.model.ts
-var inscriptionMimeTypes = [
-  "audio",
-  "gltf",
-  "html",
-  "image",
-  "svg",
-  "text",
-  "video",
-  "other"
-];
+// src/bitcoin.model.ts
+import { z as z2 } from "zod";
+var bitcoinUnitSchema = z2.enum(["bitcoin", "satoshi"]);
+
+// src/bns.model.ts
+var bnsContractAddress = {
+  mainnet: "SP2QEZ06AGJ3RKJPBV14SY1V5BBFNAW33D96YPGZF",
+  testnet: "ST2QEZ06AGJ3RKJPBV14SY1V5BBFNAW33D9SZJQ0M"
+};
+var bnsContractName = "BNS-V2";
 
 // src/fees/bitcoin-fees.model.ts
 var btcTxTimeMap = {
@@ -154,6 +206,27 @@ var FeeCalculationTypes = /* @__PURE__ */ ((FeeCalculationTypes2) => {
   return FeeCalculationTypes2;
 })(FeeCalculationTypes || {});
 
+// src/fees/transaction-fees.model.ts
+var transactionFeeTiers = ["low", "standard", "high"];
+var transactionFeeQuoteType = [
+  "flat",
+  "bitcoinFeeRate",
+  "stacksFeeRate",
+  "evm1559"
+];
+
+// src/inscription-mime-type.model.ts
+var inscriptionMimeTypes = [
+  "audio",
+  "gltf",
+  "html",
+  "image",
+  "svg",
+  "text",
+  "video",
+  "other"
+];
+
 // src/market.model.ts
 function createMarketPair(base, quote) {
   return Object.freeze({ base, quote });
@@ -166,8 +239,10 @@ function createMarketData(pair, price) {
     throw new Error("Cannot create market data when price does not match quote");
   return Object.freeze({ pair, price });
 }
+var historicalPeriods = ["1d", "1w", "1m", "3m", "6m", "1y"];
 
 // src/network/network.model.ts
+import { z as z3 } from "zod";
 var HIRO_API_BASE_URL_MAINNET = "https://api.hiro.so";
 var HIRO_API_BASE_URL_TESTNET = "https://api.testnet.hiro.so";
 var HIRO_API_BASE_URL_NAKAMOTO_TESTNET = "https://api.nakamoto.testnet.hiro.so";
@@ -196,6 +271,15 @@ var WalletDefaultNetworkConfigurationIds = /* @__PURE__ */ ((WalletDefaultNetwor
   WalletDefaultNetworkConfigurationIds2["devnet"] = "devnet";
   return WalletDefaultNetworkConfigurationIds2;
 })(WalletDefaultNetworkConfigurationIds || {});
+var defaultNetworkConfigurationsSchema = z3.enum([
+  "mainnet",
+  "testnet",
+  "testnet4",
+  "signet",
+  "sbtcTestnet",
+  "sbtcDevenv",
+  "devnet"
+]);
 var supportedBlockchains = ["stacks", "bitcoin"];
 var networkModes = ["mainnet", "testnet"];
 var testnetModes = ["testnet", "regtest", "signet"];
@@ -347,95 +431,197 @@ var defaultNetworksKeyedById = {
 };
 
 // src/network/network.schema.ts
-import { z } from "zod";
-var bitcoinNetworkModesSchema = z.enum([...networkModes, ...testnetModes]);
-var bitcoinNetworkSchema = z.enum([...bitcoinNetworks]);
-var networkConfigurationSchema = z.object({
-  name: z.string(),
-  id: z.string(),
-  chain: z.object({
-    bitcoin: z.object({
-      blockchain: z.literal("bitcoin"),
-      bitcoinUrl: z.string(),
+import { z as z4 } from "zod";
+var bitcoinNetworkModesSchema = z4.enum([...networkModes, ...testnetModes]);
+var bitcoinNetworkSchema = z4.enum([...bitcoinNetworks]);
+var networkConfigurationSchema = z4.object({
+  name: z4.string(),
+  id: z4.string(),
+  chain: z4.object({
+    bitcoin: z4.object({
+      blockchain: z4.literal("bitcoin"),
+      bitcoinUrl: z4.string(),
       bitcoinNetwork: bitcoinNetworkSchema,
       mode: bitcoinNetworkModesSchema
     }),
-    stacks: z.object({
-      blockchain: z.literal("stacks"),
-      url: z.string(),
-      chainId: z.number(),
-      subnetChainId: z.number().optional()
+    stacks: z4.object({
+      blockchain: z4.literal("stacks"),
+      url: z4.string(),
+      chainId: z4.number(),
+      subnetChainId: z4.number().optional()
     })
   })
 });
 
 // src/settings.model.ts
-import { z as z2 } from "zod";
-var emailAddressSchema = z2.email({ error: "Invalid email address" });
+import { z as z5 } from "zod";
+var accountDisplayPreferenceSchema = z5.enum(["native-segwit", "taproot", "bns", "stacks"]);
+var analyticsPreferenceSchema = z5.enum(["consent-given", "rejects-tracking"]);
+var emailAddressSchema = z5.email({ error: "Invalid email address" });
 
-// src/activity/activity-level.model.ts
-var ActivityLevels = {
-  account: "account",
-  app: "app"
-};
+// src/swap/swap.model.ts
+var swapProviderIds = ["bitflow-sdk", "sbtc-bridge", "alex-sdk", "velar-sdk"];
+var swapExecutionTypes = ["stacks-contract-call", "sbtc-bridge-transfer"];
 
-// src/activity/activity-status.model.ts
-var OnChainActivityStatuses = {
-  pending: "pending",
-  success: "success",
-  failed: "failed"
+// src/yield/yield-provider.model.ts
+var YieldProviderKeys = {
+  bitflow: "bitflow",
+  zest: "zest",
+  granite: "granite",
+  stackingDao: "stackingdao"
+  // fastPool: 'fast-pool',
+  // xverse: 'xverse',
 };
 
-// src/activity/activity-type.model.ts
-var OnChainActivityTypes = {
-  deploySmartContract: "deploySmartContract",
-  executeSmartContract: "executeSmartContract",
-  lockAsset: "lockAsset",
-  sendAsset: "sendAsset",
-  receiveAsset: "receiveAsset",
-  swapAssets: "swapAssets"
+// src/yield/yield-product.model.ts
+var YieldProductKeys = {
+  bitflowAmmLp: "bitflow-amm-lp",
+  zestBorrow: "zest-borrow",
+  graniteV1: "granite-v1",
+  stackingDaoLst: "stackingdao-lst",
+  stackingDaoPooledStacking: "stackingdao-pooled-stacking"
+  // fastPoolPooledStacking: 'fast-pool-pooled-stacking',
+  // xversePooledStacking: 'xverse-pooled-stacking',
 };
-var WalletActivityTypes = {
-  connectApp: "connectApp",
-  signMessage: "signMessage"
+var YieldProductCategories = {
+  AMM: "amm",
+  LENDING: "lending",
+  LST: "lst",
+  CDP: "cdp",
+  POOLED_STACKING: "pooled-stacking",
+  PERPS: "perps"
 };
-var GeneralActivityTypes = {
-  walletAdded: "walletAdded",
-  receiveAnnouncement: "receiveAnnouncement",
-  featureWaitlistNotification: "featureWaitlistNotification"
+var YieldProductToProtocolMap = {
+  [YieldProductKeys.bitflowAmmLp]: YieldProviderKeys.bitflow,
+  [YieldProductKeys.zestBorrow]: YieldProviderKeys.zest,
+  [YieldProductKeys.graniteV1]: YieldProviderKeys.granite,
+  [YieldProductKeys.stackingDaoLst]: YieldProviderKeys.stackingDao,
+  [YieldProductKeys.stackingDaoPooledStacking]: YieldProviderKeys.stackingDao
+  // [YieldProductKeys.fastPoolPooledStacking]: YieldProviderKeys.fastPool,
+  // [YieldProductKeys.xversePooledStacking]: YieldProviderKeys.xverse,
 };
 
-// src/account.model.ts
-import { z as z3 } from "zod";
-var walletIdSchema = z3.object({
-  fingerprint: z3.string()
-});
-var accountIdSchema = walletIdSchema.and(z3.object({ accountIndex: z3.number() }));
-var bitcoinAddressInfoSchema = z3.object({
-  taprootDescriptor: z3.string(),
-  nativeSegwitDescriptor: z3.string(),
-  zeroIndexTaprootPayerAddress: z3.string().optional(),
-  zeroIndexNativeSegwitPayerAddress: z3.string().optional()
-});
-var stacksAddressInfoSchema = z3.object({
-  stxAddress: z3.string()
-});
-var accountAddressesSchema = z3.object({
-  id: accountIdSchema,
-  bitcoin: bitcoinAddressInfoSchema.optional(),
-  stacks: stacksAddressInfoSchema.optional()
-});
-
-// src/bns.model.ts
-var bnsContractAddress = {
-  mainnet: "SP2QEZ06AGJ3RKJPBV14SY1V5BBFNAW33D96YPGZF",
-  testnet: "ST2QEZ06AGJ3RKJPBV14SY1V5BBFNAW33D9SZJQ0M"
-};
-var bnsContractName = "BNS-V2";
-
-// src/swap/swap.model.ts
-var swapProviderIds = ["bitflow-sdk", "sbtc-bridge", "alex-sdk", "velar-sdk"];
-var swapExecutionTypes = ["stacks-contract-call", "sbtc-bridge-transfer"];
+// src/yield/helpers/yield.helpers.ts
+function isBitflowPosition(pos) {
+  return pos.product === YieldProductKeys.bitflowAmmLp;
+}
+function isZestPosition(pos) {
+  return pos.product === YieldProductKeys.zestBorrow;
+}
+function isGranitePosition(pos) {
+  return pos.product === YieldProductKeys.graniteV1;
+}
+function isStackingDaoLstPosition(pos) {
+  return pos.product === YieldProductKeys.stackingDaoLst;
+}
+function isStackingDaoPooledPosition(pos) {
+  return pos.product === YieldProductKeys.stackingDaoPooledStacking;
+}
+function filterPositionsByProtocol(positions, protocol) {
+  return positions.filter((p) => p.provider === protocol);
+}
+function filterPositionsByProduct(positions, product) {
+  return positions.filter((p) => p.product === product);
+}
+function filterPositionsByCategory(positions, products, category) {
+  const productMap = new Map(products.map((p) => [p.key, p]));
+  return positions.filter((pos) => productMap.get(pos.product)?.category === category);
+}
+function sortPositionsByBalance(positions, ascending = false) {
+  return [...positions].sort((a, b) => {
+    const diff = a.totalBalance.amount.comparedTo(b.totalBalance.amount);
+    return ascending ? diff : -diff;
+  });
+}
+function sortPositionsByApy(positions, ascending = false) {
+  return [...positions].sort((a, b) => {
+    const apyA = a.netApy ?? 0;
+    const apyB = b.netApy ?? 0;
+    return ascending ? apyA - apyB : apyB - apyA;
+  });
+}
+function sortPositionsByUpdateTime(positions, ascending = false) {
+  return [...positions].sort((a, b) => {
+    const timeA = a.updatedAt?.getTime() ?? 0;
+    const timeB = b.updatedAt?.getTime() ?? 0;
+    return ascending ? timeA - timeB : timeB - timeA;
+  });
+}
+function getProtocolForProduct(product) {
+  return YieldProductToProtocolMap[product];
+}
+function getCategoryForProduct(product) {
+  return product.category;
+}
+function isProductInProtocol(product, protocol) {
+  return YieldProductToProtocolMap[product] === protocol;
+}
+function getProductsForProtocol(protocol) {
+  return Object.entries(YieldProductToProtocolMap).filter(([_, p]) => p === protocol).map(([product]) => product);
+}
+function getProductsInCategory(products, category) {
+  return products.filter((p) => p.category === category);
+}
+function groupPositionsByProtocol(positions) {
+  const grouped = {};
+  for (const position of positions) {
+    const protocol = position.provider;
+    if (!grouped[protocol]) {
+      grouped[protocol] = [];
+    }
+    grouped[protocol].push(position);
+  }
+  return grouped;
+}
+function groupPositionsByCategory(positions, products) {
+  const grouped = {};
+  const productMap = new Map(products.map((p) => [p.key, p]));
+  for (const position of positions) {
+    const product = productMap.get(position.product);
+    if (!product) continue;
+    const category = product.category;
+    if (!grouped[category]) {
+      grouped[category] = [];
+    }
+    grouped[category].push(position);
+  }
+  return grouped;
+}
+function getPositionsInCategories(positions, products, categories) {
+  const categorySet = new Set(categories);
+  const productMap = new Map(products.map((p) => [p.key, p]));
+  return positions.filter((pos) => {
+    const product = productMap.get(pos.product);
+    return product && categorySet.has(product.category);
+  });
+}
+function hasPositionsInProtocol(positions, protocol) {
+  return positions.some((p) => p.provider === protocol);
+}
+function hasPositionsInCategory(positions, products, category) {
+  const productMap = new Map(products.map((p) => [p.key, p]));
+  return positions.some((pos) => productMap.get(pos.product)?.category === category);
+}
+function enrichPositionWithProtocol(position, protocol) {
+  return { ...position, protocolData: protocol };
+}
+function enrichPositionWithProduct(position, product) {
+  return { ...position, productData: product };
+}
+function enrichPositionWithMetadata(position, protocol, product) {
+  return { ...position, protocolData: protocol, productData: product };
+}
+function getCategoryDisplayName(category) {
+  const displayNames = {
+    [YieldProductCategories.AMM]: "Liquidity Pools",
+    [YieldProductCategories.LENDING]: "Lending & Borrowing",
+    [YieldProductCategories.LST]: "Liquid Stacking",
+    [YieldProductCategories.CDP]: "Collateralized Debt",
+    [YieldProductCategories.POOLED_STACKING]: "Stacking",
+    [YieldProductCategories.PERPS]: "Perpetuals"
+  };
+  return displayNames[category] || category;
+}
 export {
   ActivityLevels,
   BESTINSLOT_API_BASE_URL_MAINNET,
@@ -465,45 +651,81 @@ export {
   STX20_API_BASE_URL_MAINNET,
   WalletActivityTypes,
   WalletDefaultNetworkConfigurationIds,
+  YieldProductCategories,
+  YieldProductKeys,
+  YieldProductToProtocolMap,
+  YieldProviderKeys,
   accountAddressesSchema,
+  accountDisplayPreferenceSchema,
   accountIdSchema,
+  analyticsPreferenceSchema,
   bitcoinAddressInfoSchema,
   bitcoinNetworkModesSchema,
   bitcoinNetworkSchema,
   bitcoinNetworkToNetworkMode,
   bitcoinNetworks,
+  bitcoinUnitSchema,
   bnsContractAddress,
   bnsContractName,
   btcTxTimeMap,
   createMarketData,
   createMarketPair,
   defaultCurrentNetwork,
+  defaultNetworkConfigurationsSchema,
   defaultNetworksKeyedById,
   emailAddressSchema,
+  enrichPositionWithMetadata,
+  enrichPositionWithProduct,
+  enrichPositionWithProtocol,
+  filterPositionsByCategory,
+  filterPositionsByProduct,
+  filterPositionsByProtocol,
   formatMarketPair,
+  getCategoryDisplayName,
+  getCategoryForProduct,
+  getPositionsInCategories,
+  getProductsForProtocol,
+  getProductsInCategory,
+  getProtocolForProduct,
+  groupPositionsByCategory,
+  groupPositionsByProtocol,
+  hasPositionsInCategory,
+  hasPositionsInProtocol,
+  historicalPeriods,
   inscriptionMimeTypes,
+  isBitflowPosition,
   isBrc20Asset,
   isBtcAsset,
   isFungibleAsset,
+  isGranitePosition,
   isInscriptionAsset,
   isNativeAsset,
   isNonFungibleAsset,
+  isProductInProtocol,
   isRuneAsset,
   isSip10Asset,
   isSip9Asset,
   isSrc20Asset,
+  isStackingDaoLstPosition,
+  isStackingDaoPooledPosition,
   isStampAsset,
   isStx20Asset,
   isStxAsset,
   isSwappableAsset,
+  isZestPosition,
   networkConfigurationSchema,
   networkModes,
   sip9ContentTypes,
+  sortPositionsByApy,
+  sortPositionsByBalance,
+  sortPositionsByUpdateTime,
   stacksAddressInfoSchema,
   supportedBlockchains,
   swapExecutionTypes,
   swapProviderIds,
   testnetModes,
+  transactionFeeQuoteType,
+  transactionFeeTiers,
   walletIdSchema
 };
 //# sourceMappingURL=index.js.map