@avalabs/avalanche-module 0.0.22 → 0.1.0

package/src/env.ts

@@ -1,25 +0,0 @@
-import { Environment } from '@avalabs/vm-module-types';
-
-type Env = {
-  glacierApiUrl: string;
-  proxyApiUrl: string;
-};
-
-export const prodEnv: Env = {
-  glacierApiUrl: 'https://glacier-api.avax.network',
-  proxyApiUrl: 'https://proxy-api.avax.network',
-};
-
-export const devEnv: Env = {
-  glacierApiUrl: 'https://glacier-api-dev.avax.network',
-  proxyApiUrl: 'https://proxy-api-dev.avax.network',
-};
-
-export const getEnv = (environment: Environment): Env => {
-  switch (environment) {
-    case Environment.PRODUCTION:
-      return prodEnv;
-    case Environment.DEV:
-      return devEnv;
-  }
-};

package/src/handlers/get-balances/convert-p-chain-balance.ts

@@ -1,91 +0,0 @@
-import type { AggregatedAssetAmount, PChainBalance } from '@avalabs/glacier-sdk';
-import { balanceToDisplayValue, bnToBig } from '@avalabs/utils-sdk';
-import { BN } from 'bn.js';
-import { calculateTotalBalance, getTokenValue } from './utils';
-import { TokenType, type NetworkToken, type TokenWithBalancePVM } from '@avalabs/vm-module-types';
-
-export const convertPChainBalance = ({
-  balance,
-  networkToken,
-  priceInCurrency,
-  marketCap,
-  vol24,
-  change24,
-  coingeckoId,
-}: {
-  balance: PChainBalance;
-  networkToken: NetworkToken;
-  priceInCurrency?: number;
-  marketCap?: number;
-  vol24?: number;
-  change24?: number;
-  coingeckoId: string;
-}): TokenWithBalancePVM => {
-  const decimals = networkToken.decimals;
-  const balancePerType: Record<string, number> = {};
-
-  const balanceTypes: Record<string, AggregatedAssetAmount[]> = {
-    unlockedUnstaked: balance.unlockedUnstaked,
-    unlockedStaked: balance.unlockedStaked,
-    pendingStaked: balance.pendingStaked,
-    lockedStaked: balance.lockedStaked,
-    lockedStakeable: balance.lockedStakeable,
-    lockedPlatform: balance.lockedPlatform,
-    atomicMemoryLocked: balance.atomicMemoryLocked,
-    atomicMemoryUnlocked: balance.atomicMemoryUnlocked,
-  };
-
-  for (const balanceType in balanceTypes) {
-    const balancesToAdd = balanceTypes[balanceType];
-    if (!balancesToAdd || !balancesToAdd.length) {
-      balancePerType[balanceType] = 0;
-      continue;
-    }
-
-    balancesToAdd.forEach((uxto: AggregatedAssetAmount) => {
-      const previousBalance = balancePerType[balanceType] ?? 0;
-      const newBalance = previousBalance + Number(uxto.amount);
-      balancePerType[balanceType] = newBalance;
-    });
-  }
-
-  const available = balancePerType['unlockedUnstaked'] ? new BN(balancePerType['unlockedUnstaked']) : new BN(0);
-  const availableInCurrency = priceInCurrency
-    ? bnToBig(available, decimals).mul(priceInCurrency).toNumber()
-    : undefined;
-  const availableDisplayValue = balanceToDisplayValue(available, decimals);
-  const totalBalance = calculateTotalBalance(balance);
-  const balanceInCurrency = priceInCurrency
-    ? bnToBig(totalBalance, decimals).mul(priceInCurrency).toNumber()
-    : undefined;
-  const balanceDisplayValue = balanceToDisplayValue(totalBalance, decimals);
-
-  return {
-    ...networkToken,
-    type: TokenType.NATIVE,
-    priceInCurrency,
-    balance: totalBalance,
-    balanceInCurrency,
-    balanceDisplayValue,
-    balanceCurrencyDisplayValue: balanceInCurrency?.toFixed(2),
-    available,
-    availableInCurrency,
-    availableDisplayValue,
-    availableCurrencyDisplayValue: availableInCurrency?.toFixed(2),
-    utxos: balance,
-    balancePerType: {
-      lockedStaked: getTokenValue(decimals, balancePerType['lockedStaked']),
-      lockedStakeable: getTokenValue(decimals, balancePerType['lockedStakeable']),
-      lockedPlatform: getTokenValue(decimals, balancePerType['lockedPlatform']),
-      atomicMemoryLocked: getTokenValue(decimals, balancePerType['atomicMemoryLocked']),
-      atomicMemoryUnlocked: getTokenValue(decimals, balancePerType['atomicMemoryUnlocked']),
-      unlockedUnstaked: getTokenValue(decimals, balancePerType['unlockedUnstaked']),
-      unlockedStaked: getTokenValue(decimals, balancePerType['unlockedStaked']),
-      pendingStaked: getTokenValue(decimals, balancePerType['pendingStaked']),
-    },
-    marketCap,
-    vol24,
-    change24,
-    coingeckoId,
-  };
-};

package/src/handlers/get-balances/covnert-x-chain-balance.ts

@@ -1,74 +0,0 @@
-import type { AggregatedAssetAmount, XChainBalances } from '@avalabs/glacier-sdk';
-import { balanceToDisplayValue, bnToBig } from '@avalabs/utils-sdk';
-import { calculateTotalBalance, getTokenValue } from './utils';
-import { TokenType, type NetworkToken, type TokenWithBalanceAVM } from '@avalabs/vm-module-types';
-
-export const convertXChainBalance = ({
-  balance,
-  networkToken,
-  priceInCurrency,
-  marketCap,
-  vol24,
-  change24,
-  coingeckoId,
-}: {
-  balance: XChainBalances;
-  networkToken: NetworkToken;
-  priceInCurrency?: number;
-  marketCap?: number;
-  vol24?: number;
-  change24?: number;
-  coingeckoId: string;
-}): TokenWithBalanceAVM => {
-  const decimals = networkToken.decimals;
-  const balancePerType: Record<string, number> = {};
-
-  const balanceTypes: Record<string, AggregatedAssetAmount[]> = {
-    unlocked: balance.unlocked,
-    locked: balance.locked,
-    atomicMemoryUnlocked: balance.atomicMemoryUnlocked,
-    atomicMemoryLocked: balance.atomicMemoryLocked,
-  };
-
-  for (const balanceType in balanceTypes) {
-    const balancesToAdd = balanceTypes[balanceType];
-    if (!balancesToAdd || !balancesToAdd.length) {
-      balancePerType[balanceType] = 0;
-      continue;
-    }
-
-    balancesToAdd.forEach((uxto: AggregatedAssetAmount) => {
-      const previousBalance = balancePerType[balanceType] ?? 0;
-      const newBalance = previousBalance + Number(uxto.amount);
-      balancePerType[balanceType] = newBalance;
-    });
-  }
-
-  const totalBalance = calculateTotalBalance(balance);
-  const balanceDisplayValue = balanceToDisplayValue(totalBalance, decimals);
-  const balanceInCurrency = priceInCurrency
-    ? bnToBig(totalBalance, decimals).mul(priceInCurrency).toNumber()
-    : undefined;
-  const balanceCurrencyDisplayValue = balanceInCurrency?.toFixed(2);
-
-  return {
-    ...networkToken,
-    coingeckoId,
-    type: TokenType.NATIVE,
-    priceInCurrency,
-    balance: totalBalance,
-    balanceInCurrency,
-    balanceDisplayValue,
-    balanceCurrencyDisplayValue,
-    utxos: balance,
-    balancePerType: {
-      unlocked: getTokenValue(decimals, balancePerType['unlocked']),
-      locked: getTokenValue(decimals, balancePerType['locked']),
-      atomicMemoryUnlocked: getTokenValue(decimals, balancePerType['atomicMemoryUnlocked']),
-      atomicMemoryLocked: getTokenValue(decimals, balancePerType['atomicMemoryLocked']),
-    },
-    marketCap,
-    vol24,
-    change24,
-  };
-};

package/src/handlers/get-balances/get-balances.ts

@@ -1,100 +0,0 @@
-import {
-  NetworkVMType,
-  type GetBalancesParams,
-  type GetBalancesResponse,
-  type TokenWithBalanceAVM,
-  type TokenWithBalancePVM,
-} from '@avalabs/vm-module-types';
-import { type AvalancheGlacierService } from '../../services/glacier-service/glacier-service';
-import {
-  BlockchainId,
-  Network,
-  type ListPChainBalancesResponse,
-  type ListXChainBalancesResponse,
-} from '@avalabs/glacier-sdk';
-import type { TokenService } from '@internal/utils';
-import { VsCurrencyType } from '@avalabs/coingecko-sdk';
-import { isPchainBalance, isXchainBalance } from './utils';
-import { convertPChainBalance } from './convert-p-chain-balance';
-import { convertXChainBalance } from './covnert-x-chain-balance';
-
-export const getBalances = async ({
-  addresses,
-  currency,
-  network,
-  glacierService,
-  tokenService,
-}: GetBalancesParams & {
-  glacierService: AvalancheGlacierService;
-  tokenService: TokenService;
-}): Promise<GetBalancesResponse> => {
-  const isHealthy = glacierService.isHealthy();
-  if (!isHealthy) {
-    return Promise.reject('Glacier is unhealthy. Try again later.');
-  }
-
-  const lowercaseCurrency = currency.toLowerCase();
-  const address = addresses[0] ?? '';
-  const networkToken = network.networkToken;
-  const coingeckoId = network.pricingProviders?.coingecko.nativeTokenId;
-
-  const blockchainId = network.vmName === NetworkVMType.PVM ? BlockchainId.P_CHAIN : BlockchainId.X_CHAIN;
-  const networkName = network.isTestnet ? Network.FUJI : Network.MAINNET;
-
-  const chainBalances = await glacierService
-    .getChainBalance({
-      blockchainId,
-      network: networkName,
-      addresses: addresses.join(','),
-    })
-    .then((value) => (value as ListPChainBalancesResponse | ListXChainBalancesResponse).balances);
-
-  const simplePriceResponse = coingeckoId
-    ? await tokenService.getSimplePrice({
-        coinIds: [coingeckoId],
-        currencies: [lowercaseCurrency] as VsCurrencyType[],
-      })
-    : {};
-
-  const priceInCurrency = simplePriceResponse?.[coingeckoId ?? '']?.[lowercaseCurrency]?.price ?? undefined;
-  const marketCap = simplePriceResponse?.[coingeckoId ?? '']?.[lowercaseCurrency]?.marketCap ?? undefined;
-  const vol24 = simplePriceResponse?.[coingeckoId ?? '']?.[lowercaseCurrency]?.vol24 ?? undefined;
-  const change24 = simplePriceResponse?.[coingeckoId ?? '']?.[lowercaseCurrency]?.change24 ?? undefined;
-
-  let balance: TokenWithBalanceAVM | TokenWithBalancePVM;
-  if (isPchainBalance(chainBalances)) {
-    balance = convertPChainBalance({
-      balance: chainBalances,
-      networkToken,
-      priceInCurrency,
-      marketCap,
-      vol24,
-      change24,
-      coingeckoId: coingeckoId ?? '',
-    });
-
-    return {
-      [address]: {
-        [networkToken.symbol]: balance,
-      },
-    };
-  }
-
-  if (isXchainBalance(chainBalances)) {
-    balance = convertXChainBalance({
-      balance: chainBalances,
-      networkToken,
-      priceInCurrency,
-      marketCap,
-      vol24,
-      change24,
-      coingeckoId: coingeckoId ?? '',
-    });
-    return {
-      [address]: {
-        [networkToken.symbol]: balance,
-      },
-    };
-  }
-  return Promise.reject('Incorrect type balance was returned from glacier');
-};

package/src/handlers/get-balances/typeguards.ts

@@ -1,9 +0,0 @@
-import type { TokenWithBalance, TokenWithBalanceAVM, TokenWithBalancePVM } from '@avalabs/vm-module-types';
-
-export const isTokenWithBalancePVM = (token: TokenWithBalance): token is TokenWithBalancePVM => {
-  return 'balancePerType' in token && 'unlockedUnstaked' in token.balancePerType;
-};
-
-export const isTokenWithBalanceAVM = (token: TokenWithBalance): token is TokenWithBalanceAVM => {
-  return 'balancePerType' in token && 'unlocked' in token.balancePerType;
-};

package/src/handlers/get-balances/utils.ts

@@ -1,27 +0,0 @@
-import type { PChainBalance, XChainBalances } from '@avalabs/glacier-sdk';
-import BN from 'bn.js';
-
-export const isPchainBalance = (balanceResult: PChainBalance | XChainBalances): balanceResult is PChainBalance => {
-  return Object.keys(balanceResult).includes('unlockedUnstaked');
-};
-
-export const isXchainBalance = (balanceResult: PChainBalance | XChainBalances): balanceResult is XChainBalances => {
-  return Object.keys(balanceResult).includes('locked');
-};
-
-export function calculateTotalBalance(uxtos: PChainBalance | XChainBalances): BN {
-  const sum = Object.values(uxtos).reduce(function (totalAcc, utxoList) {
-    const typeSum = utxoList.reduce(function (typeAcc, utxo) {
-      const balanceToAdd = Number(utxo.amount);
-      return typeAcc + balanceToAdd;
-    }, 0);
-
-    return totalAcc + typeSum;
-  }, 0);
-
-  return new BN(sum);
-}
-
-export function getTokenValue(decimals: number, amount?: number) {
-  return amount === undefined ? 0 : amount / 10 ** decimals;
-}

package/src/handlers/get-network-fee/get-network-fee.test.ts

@@ -1,19 +0,0 @@
-import { getNetworkFee } from './get-network-fee';
-
-describe('get-network-fee', () => {
-  it('should return fixed network fees', async () => {
-    await expect(getNetworkFee()).resolves.toEqual({
-      baseFee: 1000000n,
-      low: {
-        maxFeePerGas: 1000000n,
-      },
-      medium: {
-        maxFeePerGas: 1000000n,
-      },
-      high: {
-        maxFeePerGas: 1000000n,
-      },
-      isFixedFee: true,
-    });
-  });
-});

package/src/handlers/get-network-fee/get-network-fee.ts

@@ -1,21 +0,0 @@
-import type { NetworkFees } from '@avalabs/vm-module-types';
-
-/**
- * Returns {@link NetworkFees} based on a fixed fee.
- */
-export async function getNetworkFee(): Promise<NetworkFees> {
-  // this is 0.001 Avax denominated in nAvax, taken from https://docs.avax.network/reference/standards/guides/txn-fees#fee-schedule
-  return {
-    baseFee: BigInt(1000000),
-    low: {
-      maxFeePerGas: BigInt(1000000),
-    },
-    medium: {
-      maxFeePerGas: BigInt(1000000),
-    },
-    high: {
-      maxFeePerGas: BigInt(1000000),
-    },
-    isFixedFee: true,
-  };
-}

package/src/handlers/get-transaction-history/convert-p-chain-transaction.ts

@@ -1,132 +0,0 @@
-import { type PChainTransaction, type NetworkToken } from '@avalabs/glacier-sdk';
-import Big from 'big.js';
-import { Avalanche } from '@avalabs/wallets-sdk';
-import { TokenType, type Transaction } from '@avalabs/vm-module-types';
-import { getExplorerAddressByNetwork, getTokenValue } from './utils';
-
-export function convertPChainTransaction({
-  tx,
-  address,
-  networkToken,
-  chainId,
-  explorerUrl,
-  isTestnet,
-}: {
-  tx: PChainTransaction;
-  address: string;
-  networkToken: NetworkToken;
-  chainId: number;
-  explorerUrl?: string;
-  isTestnet?: boolean;
-}): Transaction {
-  const froms = new Set(tx.consumedUtxos.flatMap((utxo) => utxo.addresses) || []);
-  const tos = new Set(tx.emittedUtxos.flatMap((utxo) => utxo.addresses) || []);
-
-  const amount = getAmount({
-    tx,
-    isTestnet,
-    networkToken,
-    froms,
-  });
-
-  const avaxBurnedAmount = getBurnedAmount({ tx, isTestnet, networkToken });
-  const chainAddress = address.toLowerCase().startsWith('p-') ? address.slice(2) : address;
-  const isSender = froms.has(chainAddress);
-
-  return {
-    hash: tx.txHash,
-    isContractCall: false,
-    isIncoming: !isSender,
-    isOutgoing: isSender,
-    from: [...froms.values()].join(','),
-    to: [...tos.values()].join(','),
-    isSender,
-    timestamp: tx.blockTimestamp * 1000, // to millis
-    tokens: [
-      {
-        decimal: networkToken.decimals.toString(),
-        name: networkToken.name,
-        symbol: networkToken.symbol,
-        type: TokenType.NATIVE,
-        amount: amount.toString(),
-      },
-    ],
-    gasUsed: avaxBurnedAmount.toString(),
-    explorerLink: getExplorerAddressByNetwork(explorerUrl ?? '', tx.txHash, 'tx'),
-    txType: tx.txType,
-    chainId: chainId.toString(),
-  };
-}
-
-function getAmount({
-  tx,
-  isTestnet,
-  networkToken,
-  froms,
-}: {
-  tx: PChainTransaction;
-  isTestnet?: boolean;
-  networkToken: NetworkToken;
-  froms: Set<string>;
-}): Big {
-  const isImportExport = ['ImportTx', 'ExportTx'].includes(tx.txType);
-  const isBaseTx = tx.txType === 'BaseTx';
-
-  const nonChangeEmittedUtxosAmt = tx.emittedUtxos
-    .filter(
-      (utxo) => utxo.asset.assetId === getAvaxAssetId(!!isTestnet) && !utxo.addresses.some((addr) => froms.has(addr)),
-    )
-    .reduce((agg, utxo) => agg.add(utxo.asset.amount), new Big(0));
-  const txValue = tx.value.find((val) => val.assetId === getAvaxAssetId(!!isTestnet))?.amount;
-  // This ternary attempts to cover the case where users send themselves AVAX
-  // in which case the senders are the recipients and we should use the total tx value.
-  const baseTxValue = nonChangeEmittedUtxosAmt.gt(new Big(0))
-    ? nonChangeEmittedUtxosAmt
-    : txValue
-    ? new Big(txValue)
-    : new Big(0) ?? new Big(0);
-
-  const pBlockchainId = isTestnet ? Avalanche.FujiContext.pBlockchainID : Avalanche.MainnetContext.pBlockchainID;
-
-  const importExportAmount = tx.emittedUtxos
-    .filter(
-      (utxo) =>
-        utxo.asset.assetId === getAvaxAssetId(!!isTestnet) &&
-        ((tx.txType === 'ImportTx' && utxo.consumedOnChainId === pBlockchainId) ||
-          (tx.txType === 'ExportTx' && utxo.consumedOnChainId !== pBlockchainId)),
-    )
-    .reduce((agg, utxo) => agg.add(utxo.amount), new Big(0));
-  const nAvaxAmount = isBaseTx
-    ? baseTxValue
-    : isImportExport
-    ? importExportAmount
-    : tx.amountStaked.length === 0
-    ? aggregateValue(tx.value, !!isTestnet)
-    : aggregateValue(tx.amountStaked, !!isTestnet);
-  return getTokenValue({ amount: nAvaxAmount?.toNumber(), decimals: networkToken.decimals });
-}
-
-function getBurnedAmount({
-  tx,
-  isTestnet,
-  networkToken,
-}: {
-  tx: PChainTransaction;
-  isTestnet?: boolean;
-  networkToken: NetworkToken;
-}): Big {
-  const nAvaxFee = tx.amountBurned
-    ?.filter((value) => value.assetId === getAvaxAssetId(!!isTestnet))
-    .reduce((accumulator, value) => accumulator.add(value.amount), new Big(0));
-  return getTokenValue({ amount: nAvaxFee?.toNumber(), decimals: networkToken.decimals });
-}
-
-function aggregateValue(value: PChainTransaction['value'], isTestnet: boolean): Big | undefined {
-  return value
-    .filter((value_) => value_.assetId === getAvaxAssetId(isTestnet))
-    .reduce((accumulator, value_) => accumulator.add(value_.amount), new Big(0));
-}
-
-function getAvaxAssetId(isTestnet: boolean): string {
-  return isTestnet ? Avalanche.FujiContext.avaxAssetID : Avalanche.MainnetContext.avaxAssetID;
-}

package/src/handlers/get-transaction-history/convert-x-chain-transaction.ts

@@ -1,106 +0,0 @@
-import { type NetworkToken, XChainNonLinearTransaction, XChainLinearTransaction } from '@avalabs/glacier-sdk';
-import Big from 'big.js';
-import { Avalanche } from '@avalabs/wallets-sdk';
-import { TokenType, type Transaction } from '@avalabs/vm-module-types';
-import { getExplorerAddressByNetwork, getTokenValue } from './utils';
-
-export function convertXChainTransaction({
-  tx,
-  address,
-  networkToken,
-  chainId,
-  explorerUrl,
-  isTestnet,
-}: {
-  tx: XChainNonLinearTransaction | XChainLinearTransaction;
-  address: string;
-  networkToken: NetworkToken;
-  chainId: number;
-  isTestnet?: boolean;
-  explorerUrl?: string;
-}): Transaction {
-  const froms = new Set(tx.consumedUtxos.flatMap((utxo) => utxo.addresses) || []);
-  const tos = new Set(tx.emittedUtxos.flatMap((utxo) => utxo.addresses) || []);
-
-  const amount = getAmount({
-    tx,
-    isTestnet,
-    networkToken,
-  });
-  const avaxBurnedAmount = getBurnedAmount({ isTestnet, tx, totalAmountCreated: amount, networkToken });
-  const chainAddress = address.toLowerCase().startsWith('x-') ? address.slice(2) : address;
-  const isSender = froms.has(chainAddress);
-
-  return {
-    hash: tx.txHash,
-    isContractCall: false,
-    isIncoming: !isSender,
-    isOutgoing: isSender,
-    from: [...froms.values()].join(','),
-    to: [...tos.values()].join(','),
-    isSender,
-    timestamp: tx.timestamp * 1000, // to millis
-    tokens: [
-      {
-        decimal: networkToken.decimals.toString(),
-        name: networkToken.name,
-        symbol: networkToken.symbol,
-        type: TokenType.NATIVE,
-        amount: amount.toString(),
-      },
-    ],
-    gasUsed: avaxBurnedAmount.toString(),
-    explorerLink: getExplorerAddressByNetwork(explorerUrl ?? '', tx.txHash, 'tx'),
-    txType: tx.txType,
-    chainId: chainId.toString(),
-  };
-}
-
-function getAmount({
-  tx,
-  isTestnet,
-  networkToken,
-}: {
-  tx: XChainNonLinearTransaction | XChainLinearTransaction;
-  isTestnet?: boolean;
-  networkToken: NetworkToken;
-}): Big {
-  const isImportExport = ['ImportTx', 'ExportTx'].includes(tx.txType);
-  const xBlockchainId = isTestnet ? Avalanche.FujiContext.xBlockchainID : Avalanche.MainnetContext.xBlockchainID;
-  const importExportAmount = tx.emittedUtxos
-    .filter(
-      (utxo) =>
-        utxo.asset.assetId === getAvaxAssetId(!!isTestnet) &&
-        ((tx.txType === 'ImportTx' && utxo.consumedOnChainId === xBlockchainId) ||
-          (tx.txType === 'ExportTx' && utxo.consumedOnChainId !== xBlockchainId)),
-    )
-    .reduce((agg, utxo) => agg.add(utxo.asset.amount), new Big(0));
-
-  const totalAmountCreated = tx.amountCreated
-    .filter((asset) => asset.assetId === getAvaxAssetId(!!isTestnet))
-    .reduce((accumulator, asset) => accumulator.add(asset.amount), new Big(0));
-  const nAvaxAmt = isImportExport ? importExportAmount : totalAmountCreated;
-  return getTokenValue({ amount: nAvaxAmt.toNumber(), decimals: networkToken.decimals });
-}
-
-function getBurnedAmount({
-  isTestnet,
-  tx,
-  totalAmountCreated,
-  networkToken,
-}: {
-  isTestnet?: boolean;
-  tx: XChainNonLinearTransaction | XChainLinearTransaction;
-  totalAmountCreated: Big;
-  networkToken: NetworkToken;
-}): Big {
-  const totalAmountUnlocked = tx.amountUnlocked
-    .filter((asset) => asset.assetId === getAvaxAssetId(!!isTestnet))
-    .reduce((accumulator, asset) => accumulator.add(asset.amount), new Big(0));
-  const nAvaxFee = totalAmountUnlocked.minus(totalAmountCreated);
-  return getTokenValue({ amount: nAvaxFee.toNumber(), decimals: networkToken.decimals });
-}
-
-function getAvaxAssetId(isTestnet: boolean): string {
-  return isTestnet ? Avalanche.FujiContext.avaxAssetID : Avalanche.MainnetContext.avaxAssetID;
-}

package/src/handlers/get-transaction-history/get-transaction-history.ts

@@ -1,59 +0,0 @@
-import type { GetTransactionHistory, Transaction, TransactionHistoryResponse } from '@avalabs/vm-module-types';
-import { BlockchainId, Network, SortOrder } from '@avalabs/glacier-sdk';
-import { isPChainTransactions, isXChainTransactions } from './utils';
-import { convertPChainTransaction } from './convert-p-chain-transaction';
-import { convertXChainTransaction } from './convert-x-chain-transaction';
-import type { AvalancheGlacierService } from '../../services/glacier-service/glacier-service';
-
-export const getTransactionHistory = async ({
-  address,
-  nextPageToken,
-  offset,
-  network,
-  glacierService,
-}: GetTransactionHistory & { glacierService: AvalancheGlacierService }): Promise<TransactionHistoryResponse> => {
-  const { isTestnet, networkToken, explorerUrl, chainId } = network;
-  const isHealthy = glacierService.isHealthy();
-  if (!isHealthy) {
-    return {
-      transactions: [],
-      nextPageToken: '',
-    };
-  }
-
-  const response = await glacierService.listLatestPrimaryNetworkTransactions({
-    addresses: address,
-    blockchainId: getBlockchainIdByAddress(address),
-    network: isTestnet ? Network.FUJI : Network.MAINNET,
-    pageSize: offset,
-    pageToken: nextPageToken,
-    sortOrder: SortOrder.DESC,
-  });
-
-  let transactions: Transaction[] = [];
-  if (isPChainTransactions(response)) {
-    transactions = response.transactions.map((value) =>
-      convertPChainTransaction({ tx: value, isTestnet, address, networkToken, explorerUrl, chainId }),
-    );
-  }
-  if (isXChainTransactions(response)) {
-    transactions = response.transactions.map((value) =>
-      convertXChainTransaction({ tx: value, isTestnet, address, networkToken, explorerUrl, chainId }),
-    );
-  }
-
-  return {
-    transactions,
-    nextPageToken: response.nextPageToken,
-  };
-};
-
-const getBlockchainIdByAddress = (address: string) => {
-  // A comma separated list of X-Chain or P-Chain wallet addresses,
-  // starting with "avax"/"fuji", "P-avax"/"P-fuji" or "X-avax"/"X-fuji"
-  const firstAddress = address.split(',')[0];
-  if (firstAddress?.toLowerCase().startsWith('p-')) {
-    return BlockchainId.P_CHAIN;
-  }
-  return BlockchainId.X_CHAIN;
-};