@swapkit/helpers 3.0.0-beta.11 → 3.0.0-beta.12

package/src/api/midgard/endpoints.ts

@@ -1,14 +1,45 @@
-import { AssetValue, BaseDecimal, Chain, RequestClient, SwapKitNumber } from "@swapkit/helpers";
-import type {
-  BorrowerDetails,
-  MemberDetailsMayachain,
-  MemberDetailsThorchain,
-  SaverDetails,
-  THORNameDetails,
-} from "./types";
+import {
+  AssetValue,
+  BaseDecimal,
+  Chain,
+  RequestClient,
+  SKConfig,
+  StagenetChain,
+  SwapKitNumber,
+} from "@swapkit/helpers";
+import type { MemberDetailsMayachain, MemberDetailsThorchain, THORNameDetails } from "./types";
+
+// Create extended RequestClient instances for each API
+const getMidgardRequestClient = () => {
+  const apiHeaders = SKConfig.get("apiHeaders");
+  return RequestClient.extend({
+    headers: apiHeaders.midgard || {},
+  });
+};
 
 function getMidgardBaseUrl(isThorchain = true) {
-  return isThorchain ? "https://midgard.ninerealms.com" : "https://midgard.mayachain.info";
+  const { isStagenet } = SKConfig.get("envs");
+  const midgardUrls = SKConfig.get("midgardUrls");
+
+  if (isThorchain) {
+    const chain = isStagenet ? StagenetChain.THORChain : Chain.THORChain;
+    // Use the configured URL if available, otherwise use defaults
+    if (midgardUrls[chain]) {
+      return midgardUrls[chain];
+    }
+    // Default URLs based on environment
+    return isStagenet
+      ? "https://stagenet-midgard.ninerealms.com"
+      : "https://midgard.ninerealms.com";
+  }
+
+  const chain = isStagenet ? StagenetChain.Maya : Chain.Maya;
+  // Use the configured URL if available, otherwise use defaults
+  if (midgardUrls[chain]) {
+    return midgardUrls[chain];
+  }
+  // Default URLs based on environment
+  return isStagenet ? "https://stagenet-midgard.mayachain.info" : "https://midgard.mayachain.info";
 }
 
 function getNameServiceBaseUrl(isThorchain = true) {
@@ -16,23 +47,12 @@ function getNameServiceBaseUrl(isThorchain = true) {
   return isThorchain ? `${baseUrl}/v2/thorname` : `${baseUrl}/v2/mayaname`;
 }
 
-function getBorrowerDetailRaw(baseUrl: string) {
-  return function getBorrowerDetail(address: string) {
-    return RequestClient.get<BorrowerDetails>(`${baseUrl}/v2/borrower/${address}`);
-  };
-}
-
-function getSaverDetailRaw(baseUrl: string) {
-  return function getSaverDetail(address: string) {
-    return RequestClient.get<SaverDetails>(`${baseUrl}/v2/saver/${address}`);
-  };
-}
-
 function getLiquidityPositionRaw<Chain extends Chain.THORChain | Chain.Maya>(baseUrl: string) {
   return function getLiquidityPosition(
     address: string,
   ): Promise<Chain extends Chain.THORChain ? MemberDetailsThorchain : MemberDetailsMayachain> {
-    return RequestClient.get<
+    const MidgardRequestClient = getMidgardRequestClient();
+    return MidgardRequestClient.get<
       Chain extends Chain.THORChain ? MemberDetailsThorchain : MemberDetailsMayachain
     >(`${baseUrl}/v2/member/${address}`);
   };
@@ -40,43 +60,22 @@ function getLiquidityPositionRaw<Chain extends Chain.THORChain | Chain.Maya>(bas
 
 function getNameDetails(baseUrl: string) {
   return function getNameDetails(name: string) {
-    return RequestClient.get<THORNameDetails>(`${baseUrl}/lookup/${name}`);
+    const MidgardRequestClient = getMidgardRequestClient();
+    return MidgardRequestClient.get<THORNameDetails>(`${baseUrl}/lookup/${name}`);
   };
 }
 
 function getNamesByAddress(baseUrl: string) {
   return function getNamesByAddress(address: string) {
-    return RequestClient.get<string[]>(`${baseUrl}/rlookup/${address}`);
+    const MidgardRequestClient = getMidgardRequestClient();
+    return MidgardRequestClient.get<string[]>(`${baseUrl}/rlookup/${address}`);
   };
 }
 
 function getNamesByOwner(baseUrl: string) {
   return function getNamesByOwner(address: string) {
-    return RequestClient.get<string[]>(`${baseUrl}/owner/${address}`);
-  };
-}
-
-function getBorrowerDetail(borrowerDetailGetter: ReturnType<typeof getBorrowerDetailRaw>) {
-  return async function getBorrowerDetail(address: string) {
-    const rawBorrowerDetail = await borrowerDetailGetter(address);
-
-    return rawBorrowerDetail.pools.map((p) => ({
-      collateral_deposited: AssetValue.from({
-        asset: p.collateral_asset,
-        value: p.collateral_deposited,
-        fromBaseDecimal: BaseDecimal.THOR,
-      }),
-      collateral_withdrawn: AssetValue.from({
-        asset: p.collateral_asset,
-        value: p.collateral_withdrawn,
-        fromBaseDecimal: BaseDecimal.THOR,
-      }),
-      debt_issued_tor: SwapKitNumber.fromBigInt(BigInt(p.debt_issued_tor), BaseDecimal.THOR),
-      debt_repaid_tor: SwapKitNumber.fromBigInt(BigInt(p.debt_repaid_tor), BaseDecimal.THOR),
-      last_open_loan_timestamp: p.last_open_loan_timestamp,
-      last_repay_loan_timestamp: p.last_repay_loan_timestamp,
-      target_assets: p.target_assets.map((asset) => AssetValue.from({ asset })),
-    }));
+    const MidgardRequestClient = getMidgardRequestClient();
+    return MidgardRequestClient.get<string[]>(`${baseUrl}/owner/${address}`);
   };
 }
 
@@ -84,22 +83,6 @@ function getPoolAsset({ asset, value }: { asset: string; value: string }) {
   return AssetValue.from({ asset, value, fromBaseDecimal: BaseDecimal.THOR });
 }
 
-function getSaverDetail(saverDetailGetter: ReturnType<typeof getSaverDetailRaw>) {
-  return async function getSaverDetail(address: string) {
-    const rawSaverPositions = await saverDetailGetter(address);
-
-    return rawSaverPositions.pools.map((p) => ({
-      assetAdded: getPoolAsset({ asset: p.pool, value: p.assetAdded }),
-      assetDeposit: getPoolAsset({ asset: p.pool, value: p.assetDeposit }),
-      assetRedeem: getPoolAsset({ asset: p.pool, value: p.assetRedeem }),
-      assetWithdrawn: getPoolAsset({ asset: p.pool, value: p.assetWithdrawn }),
-      assetRegisteredAddress: p.assetAddress,
-      dateFirstAdded: p.dateFirstAdded,
-      dateLastAdded: p.dateLastAdded,
-    }));
-  };
-}
-
 function getLiquidityPosition<IsThorchain extends boolean = true>({
   liquidityPositionGetter,
   isThorchain,
@@ -134,15 +117,9 @@ function getMidgardMethodsForProtocol<T extends Chain.THORChain | Chain.Maya>(ch
   const midgardBaseUrl = getMidgardBaseUrl(isThorchain);
   const nameServiceBaseUrl = getNameServiceBaseUrl(isThorchain);
   const liquidityPositionGetter = getLiquidityPositionRaw<T>(midgardBaseUrl);
-  const borrowerDetailGetter = getBorrowerDetailRaw(midgardBaseUrl);
-  const saverDetailGetter = getSaverDetailRaw(midgardBaseUrl);
 
   return {
     getLiquidityPositionRaw: liquidityPositionGetter,
-    getBorrowerDetailRaw: borrowerDetailGetter,
-    getSaverDetailRaw: saverDetailGetter,
-    getBorrowerDetail: getBorrowerDetail(borrowerDetailGetter),
-    getSaversDetail: getSaverDetail(saverDetailGetter),
     getNameDetails: getNameDetails(nameServiceBaseUrl),
     getNamesByAddress: getNamesByAddress(nameServiceBaseUrl),
     getNamesByOwner: getNamesByOwner(nameServiceBaseUrl),

package/src/api/midgard/types.ts

@@ -1,52 +1,3 @@
-export type BorrowerDetails = {
-  /** @description List details of all the loans identified with the given address */
-  pools: BorrowerPool[];
-};
-
-export type BorrowerPool = {
-  /** @description The asset that the borrower used as collateral */
-  collateral_asset: string;
-  /** @description Int64(e8), The total amount of collateral that user deposited */
-  collateral_deposited: string;
-  /** @description Int64(e8), The total amount of collateral the system paid back to the user */
-  collateral_withdrawn: string;
-  /** @description Int64(e8), The total amount of debt issued as debt for user. denominated in TOR. */
-  debt_issued_tor: string;
-  /** @description Int64(e8), The total amount of debt that the user paid back. denominated in TOR. */
-  debt_repaid_tor: string;
-  /** @description Int64, Unix timestamp for the last time borrower opened a loan */
-  last_open_loan_timestamp: string;
-  /** @description Int64, Unix timestamp for the last time borrower repayment occurred */
-  last_repay_loan_timestamp: string;
-  target_assets: string[];
-};
-
-export type SaverDetails = {
-  /** @description List details of all the savers identified with the given address */
-  pools: SaverPool[];
-};
-
-export type SaverPool = {
-  /** @description Int64(e8), total asset added in the saver pool by member */
-  assetAdded: string;
-  /** @description saver address used by the member */
-  assetAddress: string;
-  /** @description Int64(e8), total asset that is currently deposited by the member */
-  assetDeposit: string;
-  /** @description Int64(e8), total asset can be redeemed from the saver pool by member */
-  assetRedeem: string;
-  /** @description Int64(e8), total asset withdrawn from the saver pool by member */
-  assetWithdrawn: string;
-  /** @description Int64, Unix timestamp for the first time member deposited into the saver pool */
-  dateFirstAdded: string;
-  /** @description Int64, Unix timestamp for the last time member deposited into the saver pool */
-  dateLastAdded: string;
-  /** @description The Pool rest of the data are refering to (only those pools can show up which have a corresponding saver pool) */
-  pool: string;
-  /** @description Int64, saver liquidity units that belong the the member */
-  saverUnits: string;
-};
-
 export type MemberDetailsMayachain = {
   /** @MemberPool List details of all the liquidity providers identified with the given address */
   pools: MemberPoolMayachain[];

package/src/api/swapkitApi/endpoints.ts

@@ -9,6 +9,14 @@ import {
   isGasAsset,
 } from "@swapkit/helpers";
 
+// Create extended RequestClient for swapkitApi with custom headers
+const getSwapkitApiRequestClient = () => {
+  const apiHeaders = SKConfig.get("apiHeaders");
+  return RequestClient.extend({
+    headers: apiHeaders.swapkitApi || {},
+  });
+};
+
 import {
   type BalanceResponse,
   type BrokerDepositChannelParams,
@@ -29,11 +37,13 @@ import {
 } from "./types";
 
 export function getTrackerDetails(json: TrackerParams) {
-  return RequestClient.post<TrackerResponse>(getApiUrl("/track"), { json });
+  const SwapkitApiRequestClient = getSwapkitApiRequestClient();
+  return SwapkitApiRequestClient.post<TrackerResponse>(getApiUrl("/track"), { json });
 }
 
 export async function getSwapQuote(json: QuoteRequest) {
-  const response = await RequestClient.post<QuoteResponse>(getApiUrl("/quote"), { json });
+  const SwapkitApiRequestClient = getSwapkitApiRequestClient();
+  const response = await SwapkitApiRequestClient.post<QuoteResponse>(getApiUrl("/quote"), { json });
 
   if (response.error) {
     throw new SwapKitError("api_v2_server_error", { message: response.error });
@@ -59,26 +69,30 @@ export async function getChainBalance<T extends Chain>({
   address,
   scamFilter = true,
 }: { chain: T; address: string; scamFilter?: boolean }) {
+  const SwapkitApiRequestClient = getSwapkitApiRequestClient();
   const url = getApiUrl(`/balance?chain=${chain}&address=${address}`);
-  const balanceResponse = await RequestClient.get<BalanceResponse>(url);
+  const balanceResponse = await SwapkitApiRequestClient.get<BalanceResponse>(url);
   const balances = Array.isArray(balanceResponse) ? balanceResponse : [];
 
   return scamFilter ? filterAssets(balances) : balances;
 }
 
 export function getTokenListProviders() {
+  const SwapkitApiRequestClient = getSwapkitApiRequestClient();
   const url = getApiUrl("/providers");
-  return RequestClient.get<TokenListProvidersResponse>(url);
+  return SwapkitApiRequestClient.get<TokenListProvidersResponse>(url);
 }
 
 export function getTokenList(provider: ProviderName) {
+  const SwapkitApiRequestClient = getSwapkitApiRequestClient();
   const url = getApiUrl(`/tokens?provider=${provider}`);
-  return RequestClient.get<TokensResponseV2>(url);
+  return SwapkitApiRequestClient.get<TokensResponseV2>(url);
 }
 
 export async function getPrice(body: PriceRequest) {
+  const SwapkitApiRequestClient = getSwapkitApiRequestClient();
   const url = getApiUrl("/price");
-  const response = await RequestClient.post<PriceResponse>(url, {
+  const response = await SwapkitApiRequestClient.post<PriceResponse>(url, {
     json: body,
   });
 
@@ -96,8 +110,9 @@ export async function getPrice(body: PriceRequest) {
 }
 
 export async function getGasRate() {
+  const SwapkitApiRequestClient = getSwapkitApiRequestClient();
   const url = getApiUrl("/gas");
-  const response = await RequestClient.get<GasResponse>(url);
+  const response = await SwapkitApiRequestClient.get<GasResponse>(url);
 
   try {
     const parsedResponse = GasResponseSchema.safeParse(response);
@@ -118,9 +133,10 @@ export async function getChainflipDepositChannel(body: BrokerDepositChannelParam
   if (!destinationAddress) {
     throw new SwapKitError("chainflip_broker_invalid_params");
   }
+  const SwapkitApiRequestClient = getSwapkitApiRequestClient();
   const url = SKConfig.get("integrations").chainflip?.brokerUrl || getApiUrl("/channel");
 
-  const response = await RequestClient.post<DepositChannelResponse>(url, { json: body });
+  const response = await SwapkitApiRequestClient.post<DepositChannelResponse>(url, { json: body });
 
   try {
     const parsedResponse = DepositChannelResponseSchema.safeParse(response);

package/src/api/thornode/endpoints.ts

@@ -10,6 +10,14 @@ import type {
   THORNodeType,
 } from "./types";
 
+// Create extended RequestClient for thornode with custom headers
+const getThornodeRequestClient = () => {
+  const apiHeaders = SKConfig.get("apiHeaders");
+  return RequestClient.extend({
+    headers: apiHeaders.thornode || {},
+  });
+};
+
 function baseUrl(type?: THORNodeType) {
   const { isStagenet } = SKConfig.get("envs");
   const nodeUrls = SKConfig.get("nodeUrls");
@@ -35,23 +43,28 @@ function getNameServiceBaseUrl(type?: THORNodeType) {
 }
 
 export function getLastBlock<T extends THORNodeType = "thorchain">(type: T = "thorchain" as T) {
-  return RequestClient.get<LastBlockItem<T>[]>(`${baseUrl(type)}/lastblock`);
+  const ThornodeRequestClient = getThornodeRequestClient();
+  return ThornodeRequestClient.get<LastBlockItem<T>[]>(`${baseUrl(type)}/lastblock`);
 }
 
 export function getThorchainQueue(type?: THORNodeType) {
-  return RequestClient.get(`${baseUrl(type)}/queue`);
+  const ThornodeRequestClient = getThornodeRequestClient();
+  return ThornodeRequestClient.get(`${baseUrl(type)}/queue`);
 }
 
 export function getNodes(type?: THORNodeType) {
-  return RequestClient.get<NodeItem[]>(`${baseUrl(type)}/nodes`);
+  const ThornodeRequestClient = getThornodeRequestClient();
+  return ThornodeRequestClient.get<NodeItem[]>(`${baseUrl(type)}/nodes`);
 }
 
 export function getMimirInfo(type?: THORNodeType) {
-  return RequestClient.get<MimirData>(`${baseUrl(type)}/mimir`);
+  const ThornodeRequestClient = getThornodeRequestClient();
+  return ThornodeRequestClient.get<MimirData>(`${baseUrl(type)}/mimir`);
 }
 
 export function getInboundAddresses(type?: THORNodeType) {
-  return RequestClient.get<InboundAddressesItem[]>(`${baseUrl(type)}/inbound_addresses`);
+  const ThornodeRequestClient = getThornodeRequestClient();
+  return ThornodeRequestClient.get<InboundAddressesItem[]>(`${baseUrl(type)}/inbound_addresses`);
 }
 
 export async function getTHORNodeTNSDetails({
@@ -59,7 +72,8 @@ export async function getTHORNodeTNSDetails({
   name,
 }: { type?: THORNodeType; name: string }): Promise<THORNodeTNSDetails> {
   try {
-    const result = await RequestClient.get<THORNodeTNSDetails>(
+    const ThornodeRequestClient = getThornodeRequestClient();
+    const result = await ThornodeRequestClient.get<THORNodeTNSDetails>(
       `${getNameServiceBaseUrl(type)}/${name}`,
     );
     return result;
@@ -85,12 +99,16 @@ export async function getTNSPreferredAsset({ type, tns }: { type?: THORNodeType;
 }
 
 export function getRunePoolInfo(type?: THORNodeType) {
-  return RequestClient.get<RunePoolInfo>(`${baseUrl(type)}/runepool`);
+  const ThornodeRequestClient = getThornodeRequestClient();
+  return ThornodeRequestClient.get<RunePoolInfo>(`${baseUrl(type)}/runepool`);
 }
 
 export function getRunePoolProviderInfo({
   type,
   thorAddress,
 }: { type?: THORNodeType; thorAddress: string }) {
-  return RequestClient.get<RunePoolProviderInfo>(`${baseUrl(type)}/rune_provider/${thorAddress}`);
+  const ThornodeRequestClient = getThornodeRequestClient();
+  return ThornodeRequestClient.get<RunePoolProviderInfo>(
+    `${baseUrl(type)}/rune_provider/${thorAddress}`,
+  );
 }

package/src/modules/swapKitConfig.ts

@@ -1,5 +1,5 @@
 import { createStore } from "zustand/vanilla";
-import { Chain, EXPLORER_URLS, NODE_URLS, RPC_URLS, WalletOption } from "../types";
+import { Chain, EXPLORER_URLS, NODE_URLS, RPC_URLS, StagenetChain, WalletOption } from "../types";
 
 export type SKConfigIntegrations = {
   chainflip?: { useSDKBroker?: boolean; brokerUrl: string };
@@ -24,6 +24,12 @@ export type SKConfigIntegrations = {
   };
 };
 
+export type SKApiHeaders = {
+  midgard?: Record<string, string>;
+  thornode?: Record<string, string>;
+  swapkitApi?: Record<string, string>;
+};
+
 const initialState = {
   // TODO: figure out how to type apis without using toolbox directly
   // Maybe move rpc/toolbox apis to helpers?
@@ -34,6 +40,15 @@ const initialState = {
   nodeUrls: NODE_URLS,
   rpcUrls: RPC_URLS,
 
+  midgardUrls: {
+    [Chain.THORChain]: "https://midgard.ninerealms.com",
+    [Chain.Maya]: "https://midgard.mayachain.info",
+    [StagenetChain.THORChain]: "https://stagenet-midgard.ninerealms.com",
+    [StagenetChain.Maya]: "https://stagenet-midgard.mayachain.info",
+  } as Partial<Record<Chain | StagenetChain, string>>,
+
+  apiHeaders: {} as SKApiHeaders,
+
   apiKeys: {
     blockchair: "",
     keepKey: "",
@@ -65,10 +80,12 @@ type SKState = typeof initialState;
 
 export type SKConfigState = {
   apiKeys?: Partial<SKState["apiKeys"]>;
+  apiHeaders?: Partial<SKApiHeaders>;
   chains?: SKState["chains"];
   envs?: Partial<SKState["envs"]>;
   explorerUrls?: Partial<SKState["explorerUrls"]>;
   integrations?: Partial<SKConfigIntegrations>;
+  midgardUrls?: Partial<SKState["midgardUrls"]>;
   nodeUrls?: Partial<SKState["nodeUrls"]>;
   rpcUrls?: Partial<SKState["rpcUrls"]>;
   wallets?: SKState["wallets"];
@@ -76,9 +93,11 @@ export type SKConfigState = {
 
 type SwapKitConfigStore = SKState & {
   setApiKey: (key: keyof SKState["apiKeys"], apiKey: string) => void;
+  setApiHeaders: (api: keyof SKApiHeaders, headers: Record<string, string>) => void;
   setConfig: (config: SKConfigState) => void;
   setEnv: <T extends keyof SKState["envs"]>(key: T, value: SKState["envs"][T]) => void;
   setExplorerUrl: (chain: keyof SKState["explorerUrls"], url: string) => void;
+  setMidgardUrl: (chain: keyof SKState["midgardUrls"], url: string) => void;
   setNodeUrl: (chain: keyof SKState["nodeUrls"], url: string) => void;
   setRpcUrl: (chain: keyof SKState["rpcUrls"], url: string) => void;
   setIntegrationConfig: (
@@ -91,9 +110,12 @@ const swapKitState = createStore<SwapKitConfigStore>((set) => ({
   ...initialState,
 
   setApiKey: (key, apiKey) => set((s) => ({ apiKeys: { ...s.apiKeys, [key]: apiKey } })),
+  setApiHeaders: (api, headers) =>
+    set((s) => ({ apiHeaders: { ...s.apiHeaders, [api]: headers } })),
   setEnv: (key, value) => set((s) => ({ envs: { ...s.envs, [key]: value } })),
   setExplorerUrl: (chain, url) =>
     set((s) => ({ explorerUrls: { ...s.explorerUrls, [chain]: url } })),
+  setMidgardUrl: (chain, url) => set((s) => ({ midgardUrls: { ...s.midgardUrls, [chain]: url } })),
   setNodeUrl: (chain, url) => set((s) => ({ nodeUrls: { ...s.nodeUrls, [chain]: url } })),
   setRpcUrl: (chain, url) => set((s) => ({ rpcUrls: { ...s.rpcUrls, [chain]: url } })),
   setIntegrationConfig: (integration, config) =>
@@ -101,9 +123,11 @@ const swapKitState = createStore<SwapKitConfigStore>((set) => ({
   setConfig: (config) =>
     set((s) => ({
       apiKeys: { ...s.apiKeys, ...config.apiKeys },
+      apiHeaders: { ...s.apiHeaders, ...config.apiHeaders },
       envs: { ...s.envs, ...config.envs },
       explorerUrls: { ...s.explorerUrls, ...config.explorerUrls },
       integrations: { ...s.integrations, ...config.integrations },
+      midgardUrls: { ...s.midgardUrls, ...config.midgardUrls },
       nodeUrls: { ...s.nodeUrls, ...config.nodeUrls },
       rpcUrls: { ...s.rpcUrls, ...config.rpcUrls },
       chains: s.chains.concat(config.chains || []),
@@ -118,10 +142,14 @@ export const SKConfig = {
 
   setApiKey: <T extends keyof SKState["apiKeys"]>(key: T, apiKey: string) =>
     swapKitState.getState().setApiKey(key, apiKey),
+  setApiHeaders: <T extends keyof SKApiHeaders>(api: T, headers: Record<string, string>) =>
+    swapKitState.getState().setApiHeaders(api, headers),
   setEnv: <T extends keyof SKState["envs"]>(key: T, value: SKState["envs"][T]) =>
     swapKitState.getState().setEnv(key, value),
   setExplorerUrl: <T extends keyof SKState["explorerUrls"]>(chain: T, url: string) =>
     swapKitState.getState().setExplorerUrl(chain, url),
+  setMidgardUrl: <T extends keyof SKState["midgardUrls"]>(chain: T, url: string) =>
+    swapKitState.getState().setMidgardUrl(chain, url),
   setNodeUrl: <T extends keyof SKState["nodeUrls"]>(chain: T, url: string) =>
     swapKitState.getState().setNodeUrl(chain, url),
   setRpcUrl: <T extends keyof SKState["rpcUrls"]>(chain: T, url: string) =>

package/src/types/quotes.ts

@@ -76,7 +76,6 @@ export enum ErrorCode {
   addressScreeningFailed = "addressScreeningFailed",
   noLiquidtyProvidersFound = "noLiquidtyProvidersFound",
   insufficientLiquidity = "insufficientLiquidity",
-  noSaversFound = "noSaversFound",
   noInboundDataFound = "noInbounDataFound",
   noInboundAddressesFound = "noInboundAddressesFound",
   noInboundAddressFoundForChain = "noInboundAddressFoundForChain",
@@ -110,7 +109,6 @@ export enum ErrorCode {
   thorchainPoolUnavailable = "thorchainPoolUnavailable",
   noOhlcvDataFound = "noOhlcvDataFound",
   noTradingPairs = "noTradingPairs",
-  noLoanPositionFound = "noLoanPositionFound",
   noLendingAvailability = "noLendingAvailability",
   lendingRepayTooSmall = "lendingRepayTooSmall",
   missingState = "missingState",

package/src/types/sdk.ts

@@ -34,8 +34,6 @@ export enum MemoType {
   LEAVE = "LEAVE",
   UNBOND = "UNBOND",
   WITHDRAW = "-",
-  OPEN_LOAN = "$+",
-  CLOSE_LOAN = "$-",
   RUNEPOOL_DEPOSIT = "POOL+",
   RUNEPOOL_WITHDRAW = "POOL-",
 }

package/src/utils/__tests__/memo.test.ts

@@ -8,29 +8,9 @@ import {
   getMemoForNameRegister,
   getMemoForRunePoolDeposit,
   getMemoForRunePoolWithdraw,
-  getMemoForSaverDeposit,
-  getMemoForSaverWithdraw,
   getMemoForWithdraw,
 } from "../memo";
 
-describe("getMemoForSaverDeposit", () => {
-  test("returns correct memo for single side", () => {
-    const result = getMemoForSaverDeposit({ chain: Chain.Ethereum, symbol: "ETH" });
-    expect(result).toBe("+:ETH/ETH");
-  });
-});
-
-describe("getMemoForSaverWithdraw", () => {
-  test("returns correct memo for single side", () => {
-    const result = getMemoForSaverWithdraw({
-      basisPoints: 5000,
-      chain: Chain.Ethereum,
-      symbol: "ETH",
-    });
-    expect(result).toBe("-:ETH/ETH:5000");
-  });
-});
-
 describe("getMemoForLeaveAndBond", () => {
   test("returns correct memo for Leave", () => {
     const result = getMemoForLeaveAndBond({ address: "ABC123", type: MemoType.LEAVE });

package/src/utils/memo.ts

@@ -16,14 +16,6 @@ export function getMemoForRunePoolDeposit(affiliate?: WithAffiliate<{}>) {
   return addAffiliate(MemoType.RUNEPOOL_DEPOSIT, affiliate);
 }
 
-export function getMemoForSaverDeposit({
-  chain,
-  symbol,
-  ...affiliate
-}: WithAffiliate<{ chain: Chain; symbol: string }>) {
-  return addAffiliate(`${MemoType.DEPOSIT}:${chain}/${symbol}`, affiliate);
-}
-
 export function getMemoForDeposit({
   chain,
   symbol,
@@ -43,14 +35,6 @@ export function getMemoForDeposit({
 /**
  * Withdraw
  */
-export function getMemoForSaverWithdraw({
-  chain,
-  symbol,
-  basisPoints,
-}: { chain: Chain; symbol: string; basisPoints: number }) {
-  return `${MemoType.WITHDRAW}:${chain}/${symbol}:${basisPoints}`;
-}
-
 export function getMemoForWithdraw({
   chain,
   symbol,
@@ -92,21 +76,6 @@ export function getMemoForNamePreferredAssetRegister({
   return `${MemoType.NAME_REGISTER}:${name}:${chain}:${payout}:${owner}:${asset}`;
 }
 
-export function getMemoForLoan(
-  memoType: MemoType.OPEN_LOAN | MemoType.CLOSE_LOAN,
-  {
-    asset,
-    address,
-    minAmount,
-    ...affiliate
-  }: WithAffiliate<{ address: string; asset: string; minAmount?: string }>,
-) {
-  const baseMemo = `${memoType}:${asset}:${address}`;
-  const minAmountPart = minAmount ? `:${minAmount}` : "";
-
-  return addAffiliate(`${baseMemo}${minAmountPart}`, affiliate);
-}
-
 /**
  * Internal helpers
  */