@leather.io/models 0.47.0 → 0.49.0

package/src/activity/activity.utils.ts

@@ -0,0 +1,89 @@
+import { CryptoAsset } from '../assets/asset.model';
+import { ChainId, NetworkConfiguration } from '../network/network.model';
+
+export type BitcoinNetworkPreference = 'mainnet' | 'testnet4' | 'signet';
+type StacksNetworkPreference = 'mainnet' | 'testnet';
+
+const HIRO_EXPLORER_URL = 'https://explorer.hiro.so';
+const MEMPOOL_BASE_URL = 'https://mempool.space';
+
+export interface MakeActivityArgs {
+  txid: string;
+  networkPreference: NetworkConfiguration;
+  asset?: CryptoAsset;
+}
+export function makeActivityLink({ txid, networkPreference, asset }: MakeActivityArgs) {
+  if (txid && asset) {
+    return makeActivityExplorerLink({
+      asset,
+      txid,
+      networkPreference,
+    });
+  }
+  return null;
+}
+
+interface MakeActivityExplorerLinkArgs {
+  asset: CryptoAsset;
+  txid: string;
+  networkPreference: NetworkConfiguration;
+}
+function makeActivityExplorerLink({
+  asset,
+  txid,
+  networkPreference,
+}: MakeActivityExplorerLinkArgs) {
+  if (asset.chain === 'bitcoin') {
+    return getMempoolExplorerLink({
+      networkPreference: networkPreference.chain.bitcoin.bitcoinNetwork as BitcoinNetworkPreference,
+      id: txid,
+      type: 'txid',
+    });
+  }
+  return makeStacksTxExplorerLink({
+    networkPreference:
+      networkPreference.chain.stacks.chainId === ChainId.Testnet ? 'testnet' : 'mainnet',
+    searchParams: undefined,
+    txid,
+    explorerUrl: HIRO_EXPLORER_URL,
+  });
+}
+
+interface MakeStacksTxExplorerLinkArgs {
+  networkPreference: StacksNetworkPreference;
+  searchParams?: URLSearchParams;
+  txid: string;
+  explorerUrl: string;
+}
+function makeStacksTxExplorerLink({
+  networkPreference,
+  searchParams = new URLSearchParams(),
+  txid,
+  explorerUrl,
+}: MakeStacksTxExplorerLinkArgs) {
+  searchParams.append('chain', networkPreference);
+  return `${explorerUrl}/txid/${txid}?${searchParams.toString()}`;
+}
+
+export interface GetMempoolExplorerLinkArgs {
+  id: string;
+  type: 'txid' | 'block';
+  networkPreference: BitcoinNetworkPreference;
+}
+
+export function getMempoolExplorerLink({
+  id,
+  type,
+  networkPreference,
+}: GetMempoolExplorerLinkArgs) {
+  switch (networkPreference) {
+    case 'mainnet':
+      return `${MEMPOOL_BASE_URL}/${type}/${id}`;
+    case 'testnet4':
+      return `${MEMPOOL_BASE_URL}/testnet4/${type}/${id}`;
+    case 'signet':
+      return `${MEMPOOL_BASE_URL}/signet/${type}/${id}`;
+    default:
+      return null;
+  }
+}

package/src/assets/asset-id.model.ts

@@ -3,5 +3,4 @@ import { CryptoAssetProtocol } from './asset.model';
 export interface CryptoAssetId {
   protocol: CryptoAssetProtocol;
   id: string;
-  tokenId?: number;
 }

package/src/assets/asset.model.ts

@@ -51,11 +51,13 @@ interface BaseFungibleCryptoAsset extends BaseCryptoAsset {
 export interface BtcAsset extends BaseFungibleCryptoAsset {
   readonly chain: 'bitcoin';
   readonly protocol: 'nativeBtc';
+  readonly name: 'Bitcoin';
   readonly symbol: 'BTC';
 }
 export interface StxAsset extends BaseFungibleCryptoAsset {
   readonly chain: 'stacks';
   readonly protocol: 'nativeStx';
+  readonly name: 'Stacks';
   readonly symbol: 'STX';
 }
 export interface Brc20Asset extends BaseFungibleCryptoAsset {
@@ -120,6 +122,7 @@ export interface InscriptionAsset extends BaseNonFungibleCryptoAsset {
   readonly offset: string;
   readonly preview: string;
   readonly src: string;
+  readonly thumbnailSrc?: string;
   readonly value: string;
   readonly genesisBlockHash: string;
   readonly genesisTimestamp: number;

package/src/assets/sip9-asset.model.ts

@@ -47,6 +47,8 @@ export interface Sip9Collection {
   name: string;
   collectionExplorerUrl: string;
   totalItems?: number;
+  floorPrice?: Money;
+  latestSale?: Money;
 }
 
 export interface Sip9AssetContent {
@@ -72,7 +74,5 @@ export interface Sip9Asset extends BaseNonFungibleCryptoAsset {
   readonly attributes?: Sip9Attribute[];
   readonly collection?: Sip9Collection;
   readonly creator?: string;
-  readonly floorPrice?: Money;
-  readonly latestSale?: Money;
   readonly rarityRank?: number;
 }

package/src/index.ts

@@ -29,11 +29,24 @@ export * from './types';
 export * from './types.utils';
 export * from './utxo.model';
 export * from './yield/helpers/yield.helpers';
-export * from './yield/providers/bitflow.model';
-export * from './yield/providers/granite.model';
-export * from './yield/providers/stacking-dao.model';
-export * from './yield/providers/zest.model';
+export * from './yield/providers/bitflow-position.model';
+export * from './yield/providers/fast-pool-position.model';
+export * from './yield/providers/granite-position.model';
+export * from './yield/providers/hermetica-position.model';
+export * from './yield/providers/lisa-position.model';
+export * from './yield/providers/stacking-dao-position.model';
+export * from './yield/providers/velar-position.model';
+export * from './yield/providers/xverse-position.model';
+export * from './yield/providers/zest-position.model';
 export * from './yield/yield-position.base.model';
 export * from './yield/yield-position.model';
 export * from './yield/yield-product.model';
 export * from './yield/yield-provider.model';
+export * from './activity/activity-level.model';
+export * from './activity/activity-status.model';
+export * from './activity/activity-type.model';
+export * from './activity/activity.model';
+export * from './activity/activity.utils';
+export * from './account.model';
+export * from './bns.model';
+export * from './swap/swap.model';

package/src/swap/swap.model.ts

@@ -23,7 +23,13 @@ export interface SwapProviderAsset {
   assetId: CryptoAssetId;
 }
 
-export interface SwapQuote {
+export type SwapQuote =
+  | AlexSdkSwapQuote
+  | VelarSdkSwapQuote
+  | BitflowSdkSwapQuote
+  | SbtcBridgeSwapQuote;
+
+export interface BaseSwapQuote {
   executionType: SwapExecutionType;
   providerId: SwapProviderId;
   providerQuoteData: unknown;
@@ -34,6 +40,34 @@ export interface SwapQuote {
   assetPath: (NativeCryptoAsset | Sip10Asset)[];
 }
 
+export interface AlexSdkSwapQuote extends BaseSwapQuote {
+  providerId: 'alex-sdk';
+  providerQuoteData: {
+    baseProviderAssetId: string;
+    targetProviderAssetId: string;
+    alexSdkAmmRoute: unknown;
+  };
+}
+
+export interface VelarSdkSwapQuote extends BaseSwapQuote {
+  providerId: 'velar-sdk';
+  providerQuoteData: {
+    baseProviderAssetId: string;
+    targetProviderAssetId: string;
+  };
+}
+
+export interface BitflowSdkSwapQuote extends BaseSwapQuote {
+  providerId: 'bitflow-sdk';
+  providerQuoteData: {
+    bitflowSdkSelectedSwapRoute: unknown;
+  };
+}
+
+export interface SbtcBridgeSwapQuote extends BaseSwapQuote {
+  providerId: 'sbtc-bridge';
+}
+
 export interface SwapDex {
   name: string;
   url: string;

package/src/yield/helpers/yield.helpers.ts

@@ -1,10 +1,17 @@
-import type { BitflowAmmLpPosition } from '../providers/bitflow.model';
-import type { GraniteV1Position } from '../providers/granite.model';
 import type {
-  StackingDaoLstPosition,
+  BitflowAmmLpPosition,
+  BitflowAmmStakingPosition,
+} from '../providers/bitflow-position.model';
+import type {
+  GraniteV1BorrowPosition,
+  GraniteV1EarnPosition,
+} from '../providers/granite-position.model';
+import type {
   StackingDaoPooledStackingPosition,
-} from '../providers/stacking-dao.model';
-import type { ZestBorrowPosition } from '../providers/zest.model';
+  StackingDaoStStxBtcPosition,
+  StackingDaoStStxPosition,
+} from '../providers/stacking-dao-position.model';
+import type { ZestBorrowMarketPosition } from '../providers/zest-position.model';
 import type { YieldPosition } from '../yield-position.model';
 import {
   YieldProduct,
@@ -12,24 +19,38 @@ import {
   YieldProductCategory,
   YieldProductKey,
   YieldProductKeys,
-  YieldProductToProtocolMap,
+  YieldProductToProviderMap,
 } from '../yield-product.model';
 import { YieldProvider, YieldProviderKey } from '../yield-provider.model';
 
-export function isBitflowPosition(pos: YieldPosition): pos is BitflowAmmLpPosition {
+export function isBitflowAmmLpPosition(pos: YieldPosition): pos is BitflowAmmLpPosition {
   return pos.product === YieldProductKeys.bitflowAmmLp;
 }
 
-export function isZestPosition(pos: YieldPosition): pos is ZestBorrowPosition {
-  return pos.product === YieldProductKeys.zestBorrow;
+export function isBitflowAmmStakingPosition(pos: YieldPosition): pos is BitflowAmmStakingPosition {
+  return pos.product === YieldProductKeys.bitflowAmmStaking;
 }
 
-export function isGranitePosition(pos: YieldPosition): pos is GraniteV1Position {
-  return pos.product === YieldProductKeys.graniteV1;
+export function isZestPosition(pos: YieldPosition): pos is ZestBorrowMarketPosition {
+  return pos.product === YieldProductKeys.zestBorrowMarket;
 }
 
-export function isStackingDaoLstPosition(pos: YieldPosition): pos is StackingDaoLstPosition {
-  return pos.product === YieldProductKeys.stackingDaoLst;
+export function isGraniteEarnPosition(pos: YieldPosition): pos is GraniteV1EarnPosition {
+  return pos.product === YieldProductKeys.graniteV1Earn;
+}
+
+export function isGraniteBorrowPosition(pos: YieldPosition): pos is GraniteV1BorrowPosition {
+  return pos.product === YieldProductKeys.graniteV1Borrow;
+}
+
+export function isStackingDaoStStxPosition(pos: YieldPosition): pos is StackingDaoStStxPosition {
+  return pos.product === YieldProductKeys.stackingDaoStstx;
+}
+
+export function isStackingDaoStStxBtcPosition(
+  pos: YieldPosition
+): pos is StackingDaoStStxBtcPosition {
+  return pos.product === YieldProductKeys.stackingDaoStstxbtc;
 }
 
 export function isStackingDaoPooledPosition(
@@ -38,11 +59,11 @@ export function isStackingDaoPooledPosition(
   return pos.product === YieldProductKeys.stackingDaoPooledStacking;
 }
 
-export function filterPositionsByProtocol(
+export function filterPositionsByProvider(
   positions: YieldPosition[],
-  protocol: YieldProviderKey
+  provider: YieldProviderKey
 ): YieldPosition[] {
-  return positions.filter(p => p.provider === protocol);
+  return positions.filter(p => p.provider === provider);
 }
 
 export function filterPositionsByProduct(
@@ -73,8 +94,8 @@ export function sortPositionsByBalance(
 
 export function sortPositionsByApy(positions: YieldPosition[], ascending = false): YieldPosition[] {
   return [...positions].sort((a, b) => {
-    const apyA = a.netApy ?? 0;
-    const apyB = b.netApy ?? 0;
+    const apyA = a.apy;
+    const apyB = b.apy;
     return ascending ? apyA - apyB : apyB - apyA;
   });
 }
@@ -84,27 +105,27 @@ export function sortPositionsByUpdateTime(
   ascending = false
 ): YieldPosition[] {
   return [...positions].sort((a, b) => {
-    const timeA = a.updatedAt?.getTime() ?? 0;
-    const timeB = b.updatedAt?.getTime() ?? 0;
+    const timeA = 'updatedAt' in a && a.updatedAt instanceof Date ? a.updatedAt.getTime() : 0;
+    const timeB = 'updatedAt' in b && b.updatedAt instanceof Date ? b.updatedAt.getTime() : 0;
     return ascending ? timeA - timeB : timeB - timeA;
   });
 }
 
-export function getProtocolForProduct(product: YieldProductKey): YieldProviderKey {
-  return YieldProductToProtocolMap[product];
+export function getProviderForProduct(product: YieldProductKey): YieldProviderKey {
+  return YieldProductToProviderMap[product];
 }
 
 export function getCategoryForProduct(product: YieldProduct): YieldProductCategory {
   return product.category;
 }
 
-export function isProductInProtocol(product: YieldProductKey, protocol: YieldProviderKey): boolean {
-  return YieldProductToProtocolMap[product] === protocol;
+export function isProductInProvider(product: YieldProductKey, provider: YieldProviderKey): boolean {
+  return YieldProductToProviderMap[product] === provider;
 }
 
-export function getProductsForProtocol(protocol: YieldProviderKey): YieldProductKey[] {
-  return Object.entries(YieldProductToProtocolMap)
-    .filter(([_, p]) => p === protocol)
+export function getProductsForProvider(provider: YieldProviderKey): YieldProductKey[] {
+  return Object.entries(YieldProductToProviderMap)
+    .filter(([_, p]) => p === provider)
     .map(([product]) => product as YieldProductKey);
 }
 
@@ -115,17 +136,17 @@ export function getProductsInCategory(
   return products.filter(p => p.category === category);
 }
 
-export function groupPositionsByProtocol(
+export function groupPositionsByProvider(
   positions: YieldPosition[]
 ): Record<YieldProviderKey, YieldPosition[]> {
   const grouped: Partial<Record<YieldProviderKey, YieldPosition[]>> = {};
 
   for (const position of positions) {
-    const protocol = position.provider;
-    if (!grouped[protocol]) {
-      grouped[protocol] = [];
+    const provider = position.provider;
+    if (!grouped[provider]) {
+      grouped[provider] = [];
     }
-    grouped[protocol].push(position);
+    grouped[provider].push(position);
   }
 
   return grouped as Record<YieldProviderKey, YieldPosition[]>;
@@ -165,11 +186,11 @@ export function getPositionsInCategories(
   });
 }
 
-export function hasPositionsInProtocol(
+export function hasPositionsInProvider(
   positions: YieldPosition[],
-  protocol: YieldProviderKey
+  provider: YieldProviderKey
 ): boolean {
-  return positions.some(p => p.provider === protocol);
+  return positions.some(p => p.provider === provider);
 }
 
 export function hasPositionsInCategory(
@@ -181,11 +202,11 @@ export function hasPositionsInCategory(
   return positions.some(pos => productMap.get(pos.product)?.category === category);
 }
 
-export function enrichPositionWithProtocol<T extends YieldPosition>(
+export function enrichPositionWithProvider<T extends YieldPosition>(
   position: T,
-  protocol: YieldProvider
-): T & { protocolData: YieldProvider } {
-  return { ...position, protocolData: protocol };
+  provider: YieldProvider
+): T & { providerData: YieldProvider } {
+  return { ...position, providerData: provider };
 }
 
 export function enrichPositionWithProduct<T extends YieldPosition>(
@@ -197,19 +218,19 @@ export function enrichPositionWithProduct<T extends YieldPosition>(
 
 export function enrichPositionWithMetadata<T extends YieldPosition>(
   position: T,
-  protocol: YieldProvider,
+  provider: YieldProvider,
   product: YieldProduct
-): T & { protocolData: YieldProvider; productData: YieldProduct } {
-  return { ...position, protocolData: protocol, productData: product };
+): T & { providerData: YieldProvider; productData: YieldProduct } {
+  return { ...position, providerData: provider, productData: product };
 }
 
 export function getCategoryDisplayName(category: YieldProductCategory): string {
   const displayNames: Record<YieldProductCategory, string> = {
     [YieldProductCategories.AMM]: 'Liquidity Pools',
     [YieldProductCategories.LENDING]: 'Lending & Borrowing',
-    [YieldProductCategories.LST]: 'Liquid Stacking',
-    [YieldProductCategories.CDP]: 'Collateralized Debt',
-    [YieldProductCategories.POOLED_STACKING]: 'Stacking',
+    [YieldProductCategories.LIQUID_STACKING]: 'Liquid Stacking',
+    [YieldProductCategories.POOLED_STACKING]: 'Pooled Stacking',
+    [YieldProductCategories.STAKING]: 'Staking',
     [YieldProductCategories.PERPS]: 'Perpetuals',
   };
   return displayNames[category] || category;

package/src/yield/providers/{bitflow.model.ts → bitflow-position.model.ts}

@@ -1,17 +1,10 @@
 import type { FungibleCryptoAsset } from '../../assets/asset.model';
 import type { Money } from '../../money.model';
 import type { BaseYieldPosition } from '../yield-position.base.model';
-import type { YieldProductKeys } from '../yield-product.model';
-import type { YieldProviderKeys } from '../yield-provider.model';
 
 export interface BitflowAmmLpPosition extends BaseYieldPosition {
-  provider: typeof YieldProviderKeys.bitflow;
-  product: typeof YieldProductKeys.bitflowAmmLp;
-  pools: BitflowAmmLpPool[];
-}
-
-export interface BitflowAmmLpPool {
-  apy: number;
+  provider: 'bitflow';
+  product: 'bitflow-amm-lp';
   poolSharePercentage: number;
   lpToken: {
     asset: FungibleCryptoAsset;
@@ -29,3 +22,18 @@ export interface BitflowAmmLpPool {
     balanceQuote: Money;
   };
 }
+
+export interface BitflowAmmStakingPosition extends BaseYieldPosition {
+  provider: 'bitflow';
+  product: 'bitflow-amm-staking';
+  stakedLpToken: {
+    asset: FungibleCryptoAsset;
+    balance: Money;
+    balanceQuote: Money;
+  };
+  rewardToken?: {
+    asset: FungibleCryptoAsset;
+    balance: Money;
+    balanceQuote: Money;
+  };
+}

package/src/yield/providers/fast-pool-position.model.ts

@@ -0,0 +1,6 @@
+import type { BasePooledStackingPosition } from '../yield-position.base.model';
+
+export interface FastPoolPooledStackingPosition extends BasePooledStackingPosition {
+  provider: 'fast-pool';
+  product: 'fast-pool-pooled-stacking';
+}

package/src/yield/providers/granite-position.model.ts

@@ -0,0 +1,27 @@
+import type { FungibleCryptoAsset } from '../../assets/asset.model';
+import type { Money } from '../../money.model';
+import type { BaseYieldPosition } from '../yield-position.base.model';
+
+export interface GraniteV1EarnPosition extends BaseYieldPosition {
+  provider: 'granite';
+  product: 'granite-v1-earn';
+  marketAsset: FungibleCryptoAsset;
+  marketAssetSupplyBalance: Money;
+  marketAssetSupplyBalanceQuote: Money;
+}
+
+export interface GraniteV1BorrowPosition extends BaseYieldPosition {
+  provider: 'granite';
+  product: 'granite-v1-borrow';
+  marketAsset: FungibleCryptoAsset;
+  marketAssetBorrowBalance: Money;
+  marketAssetBorrowBalanceQuote: Money;
+  collateralBalanceQuote: Money;
+  collateral: GraniteV1CollateralAsset[];
+}
+
+export interface GraniteV1CollateralAsset {
+  asset: FungibleCryptoAsset;
+  balance: Money;
+  balanceQuote: Money;
+}

package/src/yield/providers/hermetica-position.model.ts

@@ -0,0 +1,19 @@
+import type { FungibleCryptoAsset } from '../../assets/asset.model';
+import type { Money } from '../../money.model';
+import type { BaseYieldPosition } from '../yield-position.base.model';
+
+export interface HermeticaUsdhStakingPosition extends BaseYieldPosition {
+  provider: 'hermetica';
+  product: 'hermetica-usdh-staking';
+  staking: HermeticaStaking;
+}
+
+export interface HermeticaStaking {
+  asset: FungibleCryptoAsset;
+  balance: Money;
+  balanceQuote: Money;
+  apy: number;
+  rewardAsset?: FungibleCryptoAsset;
+  rewardBalance?: Money;
+  rewardBalanceQuote?: Money;
+}

package/src/yield/providers/lisa-position.model.ts

@@ -0,0 +1,22 @@
+import type { FungibleCryptoAsset } from '../../assets/asset.model';
+import type { Money } from '../../money.model';
+import type { BaseYieldPosition } from '../yield-position.base.model';
+
+export interface LisaLiStxPosition extends BaseYieldPosition {
+  provider: 'lisa';
+  product: 'lisa-listx';
+  holding: LisaLstHolding;
+}
+
+export interface LisaLiquidStakingPosition extends BaseYieldPosition {
+  provider: 'lisa';
+  product: 'lisa-liquid-staking';
+  holding: LisaLstHolding;
+}
+
+export interface LisaLstHolding {
+  asset: FungibleCryptoAsset;
+  balance: Money;
+  balanceQuote: Money;
+  apy: number;
+}

package/src/yield/providers/{stacking-dao.model.ts → stacking-dao-position.model.ts}

@@ -1,20 +1,23 @@
 import type { FungibleCryptoAsset } from '../../assets/asset.model';
 import type { Money } from '../../money.model';
-import type { BaseYieldPosition } from '../yield-position.base.model';
-import type { YieldProductKeys } from '../yield-product.model';
-import type { YieldProviderKeys } from '../yield-provider.model';
+import type { BasePooledStackingPosition, BaseYieldPosition } from '../yield-position.base.model';
 
-export interface StackingDaoLstPosition extends BaseYieldPosition {
-  provider: typeof YieldProviderKeys.stackingDao;
-  product: typeof YieldProductKeys.stackingDaoLst;
-  totalBalance: Money;
+interface BaseStackingDaoLstPosition extends BaseYieldPosition {
+  provider: 'stackingdao';
   withdrawalsBalance: Money;
-  ststx?: StackingDaoLstHolding;
-  ststxbtc?: StackingDaoLstHolding;
-  sbtcReward?: StackingDaoReward;
+  lstHolding?: StackingDaoLstHolding;
   withdrawals: StackingDaoLstWithdrawal[];
 }
 
+export interface StackingDaoStStxPosition extends BaseStackingDaoLstPosition {
+  product: 'stackingdao-ststx';
+}
+
+export interface StackingDaoStStxBtcPosition extends BaseStackingDaoLstPosition {
+  product: 'stackingdao-ststxbtc';
+  sbtcReward?: StackingDaoReward;
+}
+
 export interface StackingDaoLstHolding {
   asset: FungibleCryptoAsset;
   balance: Money;
@@ -39,7 +42,7 @@ export interface StackingDaoLstWithdrawal {
   unlockBurnHeight: number;
 }
 
-export interface StackingDaoPooledStackingPosition extends BaseYieldPosition {
-  provider: typeof YieldProviderKeys.stackingDao;
-  product: typeof YieldProductKeys.stackingDaoPooledStacking;
+export interface StackingDaoPooledStackingPosition extends BasePooledStackingPosition {
+  provider: 'stackingdao';
+  product: 'stackingdao-pooled-stacking';
 }

package/src/yield/providers/velar-position.model.ts

@@ -0,0 +1,39 @@
+import type { FungibleCryptoAsset } from '../../assets/asset.model';
+import type { Money } from '../../money.model';
+import type { BaseYieldPosition } from '../yield-position.base.model';
+
+export interface VelarAmmLpPosition extends BaseYieldPosition {
+  provider: 'velar';
+  product: 'velar-amm-lp';
+  poolSharePercentage: number;
+  lpToken: {
+    asset: FungibleCryptoAsset;
+    balance: Money;
+    balanceQuote: Money;
+  };
+  tokenX: {
+    asset: FungibleCryptoAsset;
+    balance: Money;
+    balanceQuote: Money;
+  };
+  tokenY: {
+    asset: FungibleCryptoAsset;
+    balance: Money;
+    balanceQuote: Money;
+  };
+}
+
+export interface VelarFarmPosition extends BaseYieldPosition {
+  provider: 'velar';
+  product: 'velar-amm-lp-farming';
+  stakedLpToken: {
+    asset: FungibleCryptoAsset;
+    balance: Money;
+    balanceQuote: Money;
+  };
+  rewardToken?: {
+    asset: FungibleCryptoAsset;
+    balance: Money;
+    balanceQuote: Money;
+  };
+}

package/src/yield/providers/xverse-position.model.ts

@@ -0,0 +1,6 @@
+import type { BasePooledStackingPosition } from '../yield-position.base.model';
+
+export interface XversePooledStackingPosition extends BasePooledStackingPosition {
+  provider: 'xverse';
+  product: 'xverse-pooled-stacking';
+}

package/src/yield/providers/{zest.model.ts → zest-position.model.ts}

@@ -1,12 +1,10 @@
 import type { FungibleCryptoAsset } from '../../assets/asset.model';
 import type { Money } from '../../money.model';
 import type { BaseYieldPosition } from '../yield-position.base.model';
-import type { YieldProductKeys } from '../yield-product.model';
-import type { YieldProviderKeys } from '../yield-provider.model';
 
-export interface ZestBorrowPosition extends BaseYieldPosition {
-  provider: typeof YieldProviderKeys.zest;
-  product: typeof YieldProductKeys.zestBorrow;
+export interface ZestBorrowMarketPosition extends BaseYieldPosition {
+  provider: 'zest';
+  product: 'zest-borrow-market';
   supplyBalance: Money;
   borrowBalance: Money;
   ltvPercentage: number;

package/src/yield/yield-position.base.model.ts

@@ -3,10 +3,13 @@ import type { YieldProductKey } from './yield-product.model';
 import type { YieldProviderKey } from './yield-provider.model';
 
 export interface BaseYieldPosition {
+  readonly id: string;
   readonly provider: YieldProviderKey;
   readonly product: YieldProductKey;
   readonly totalBalance: Money;
-  readonly netApy?: number;
-  readonly updatedAtBlockHeight: number;
-  readonly updatedAt: Date;
+  readonly apy: number;
+}
+
+export interface BasePooledStackingPosition extends BaseYieldPosition {
+  readonly stackedBalanceStx: Money;
 }