@swapkit/helpers 1.1.3 → 1.2.1

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

@@ -6,6 +6,8 @@ import {
   getMemoForLeaveAndBond,
   getMemoForNamePreferredAssetRegister,
   getMemoForNameRegister,
+  getMemoForRunePoolDeposit,
+  getMemoForRunePoolWithdraw,
   getMemoForSaverDeposit,
   getMemoForSaverWithdraw,
   getMemoForWithdraw,
@@ -73,6 +75,16 @@ describe("getMemoForDeposit", () => {
     const result = getMemoForDeposit({ chain: Chain.Ethereum, symbol: "ETH" });
     expect(result).toBe("+:ETH.ETH");
   });
+
+  test("returns correct memo when paired address is not available but affiliate info is present", () => {
+    const result = getMemoForDeposit({
+      chain: Chain.Ethereum,
+      symbol: "ETH",
+      affiliateAddress: "thor1abc123",
+      affiliateBasisPoints: 500,
+    });
+    expect(result).toBe("+:ETH.ETH::thor1abc123:500");
+  });
 });
 
 describe("getMemoForWithdraw", () => {
@@ -86,3 +98,26 @@ describe("getMemoForWithdraw", () => {
     expect(result).toBe("-:ETH.ETH:100");
   });
 });
+
+describe("getMemoForRunePoolDeposit", () => {
+  test("returns correct memo for single side", () => {
+    const result = getMemoForRunePoolDeposit();
+    expect(result).toBe("POOL+");
+  });
+});
+
+describe("getMemoForRunePoolWithdraw", () => {
+  test("returns correct memo for single side", () => {
+    const result = getMemoForRunePoolWithdraw({ basisPoints: 500 });
+    expect(result).toBe("POOL-:500");
+  });
+
+  test("returns correct memo when affiliate info is present", () => {
+    const result = getMemoForRunePoolWithdraw({
+      basisPoints: 500,
+      affiliateAddress: "thor1abc123",
+      affiliateBasisPoints: 500,
+    });
+    expect(result).toBe("POOL-:500:thor1abc123:500");
+  });
+});

package/src/helpers/memo.ts

@@ -128,7 +128,8 @@ export function getMemoForDeposit({
   address?: string;
 }>) {
   const poolIdentifier = getPoolIdentifier({ chain, symbol });
-  const addressPart = address ? `:${address}` : "";
+  const hasAffiliateInfo = !!affiliate.affiliateAddress;
+  const addressPart = address ? `:${address}` : hasAffiliateInfo ? ":" : "";
 
   return addAffiliate(`${MemoType.DEPOSIT}:${poolIdentifier}${addressPart}`, affiliate);
 }
@@ -137,9 +138,8 @@ export function getMemoForSaverWithdraw({
   chain,
   symbol,
   basisPoints,
-  ...affiliate
-}: WithAffiliate<{ chain: Chain; symbol: string; basisPoints: number }>) {
-  return addAffiliate(`${MemoType.WITHDRAW}:${chain}/${symbol}:${basisPoints}`, affiliate);
+}: { chain: Chain; symbol: string; basisPoints: number }) {
+  return `${MemoType.WITHDRAW}:${chain}/${symbol}:${basisPoints}`;
 }
 
 export function getMemoForWithdraw({
@@ -148,22 +148,29 @@ export function getMemoForWithdraw({
   ticker,
   basisPoints,
   targetAsset,
-  ...affiliate
-}: WithAffiliate<{
+}: {
   chain: Chain;
   symbol: string;
   ticker: string;
   basisPoints: number;
   targetAsset?: string;
-}>) {
+}) {
   const shortenedSymbol =
     chain === "ETH" && ticker !== "ETH" ? `${ticker}-${symbol.slice(-3)}` : symbol;
   const targetPart = targetAsset ? `:${targetAsset}` : "";
 
-  return addAffiliate(
-    `${MemoType.WITHDRAW}:${chain}.${shortenedSymbol}:${basisPoints}${targetPart}`,
-    affiliate,
-  );
+  return `${MemoType.WITHDRAW}:${chain}.${shortenedSymbol}:${basisPoints}${targetPart}`;
+}
+
+export function getMemoForRunePoolDeposit() {
+  return `${MemoType.RUNEPOOL_DEPOSIT}`;
+}
+
+export function getMemoForRunePoolWithdraw({
+  basisPoints,
+  ...affiliate
+}: WithAffiliate<{ basisPoints: number }>) {
+  return addAffiliate(`${MemoType.RUNEPOOL_WITHDRAW}:${basisPoints}`, affiliate);
 }
 
 /**
@@ -188,6 +195,12 @@ export type MemoOptions<T extends MemoType> = {
     singleSide?: boolean;
   }>;
   [MemoType.NAME_REGISTER]: { name: string; chain: string; address: string };
+  [MemoType.RUNEPOOL_DEPOSIT]: {};
+  [MemoType.RUNEPOOL_WITHDRAW]: {
+    basisPoints: number;
+    affiliateAddress?: string;
+    affiliateBasisPoints?: number;
+  };
 }[T];
 
 /**

package/src/modules/requestClient.ts

@@ -1,39 +1,56 @@
-import type { KyInstance, Options } from "ky";
-import ky from "ky";
+type Options = {
+  headers?: Record<string, string>;
+  apiKey?: string;
+  method?: "GET" | "POST";
+  onError?: (error: NotWorth) => NotWorth;
+  responseHandler?: (response: NotWorth) => NotWorth;
+  [key: string]: NotWorth;
+};
 
-let kyClientConfig: Options & { apiKey?: string } = {};
+let clientConfig: Options = {};
 
 export const defaultRequestHeaders =
   typeof window !== "undefined"
     ? ({} as Record<string, string>)
     : { referrer: "https://sk.thorswap.net", referer: "https://sk.thorswap.net" };
 
-export function setRequestClientConfig({ apiKey, ...config }: Options & { apiKey?: string }) {
-  kyClientConfig = { ...config, apiKey };
+export function setRequestClientConfig({ apiKey, ...config }: Options) {
+  clientConfig = { ...config, apiKey };
 }
 
-function getKyClient() {
-  const { apiKey, ...config } = kyClientConfig;
-  return ky.create({
-    ...config,
-    headers: { ...defaultRequestHeaders, ...config.headers, "x-api-key": apiKey },
-  });
-}
+async function fetchWithConfig(url: string, options: Options = {}) {
+  const { apiKey, ...config } = clientConfig;
+  const headers = { ...defaultRequestHeaders, ...config.headers, ...options.headers };
+
+  if (apiKey) headers["x-api-key"] = apiKey;
+
+  try {
+    const response = await fetch(url, { ...config, ...options, headers });
+    const body = await response.json();
 
-const getTypedBaseRequestClient = (ky: KyInstance) => ({
-  get: async <T>(url: string | URL | Request, options?: Options) =>
-    (await ky.get(url, options)).json<T>(),
-  post: async <T>(url: string | URL | Request, options?: Options) =>
-    (await ky.post(url, options)).json<T>(),
-});
+    if (options.responseHandler) return options.responseHandler(body);
+
+    return body;
+  } catch (error) {
+    if (options.onError) return options.onError(error);
+
+    console.error(error);
+  }
+}
 
 export const RequestClient = {
-  ...getTypedBaseRequestClient(getKyClient()),
+  get: async <T>(url: string, options?: Options): Promise<T> =>
+    fetchWithConfig(url, { ...options, method: "GET" }),
+  post: async <T>(url: string, options?: Options): Promise<T> =>
+    fetchWithConfig(url, { ...options, method: "POST" }),
   extend: (options: Options) => {
-    const extendedClient = getKyClient().extend(options);
+    const extendedConfig = { ...clientConfig, ...options };
     return {
-      ...getTypedBaseRequestClient(extendedClient),
-      extend: RequestClient.extend,
+      get: async <T>(url: string, options?: Options): Promise<T> =>
+        fetchWithConfig(url, { ...extendedConfig, ...options, method: "GET" }),
+      post: async <T>(url: string, options?: Options): Promise<T> =>
+        fetchWithConfig(url, { ...extendedConfig, ...options, method: "POST" }),
+      extend: (newOptions: Options) => RequestClient.extend({ ...extendedConfig, ...newOptions }),
     };
   },
 };

package/src/modules/swapKitError.ts

@@ -57,6 +57,7 @@ const errorCodes = {
   core_transaction_invalid_sender_address: 10313,
   core_transaction_deposit_server_error: 10314,
   core_transaction_user_rejected: 10315,
+  core_transaction_failed: 10316,
   /**
    * Wallets
    */

package/src/types/sdk.ts

@@ -62,6 +62,8 @@ export enum MemoType {
   WITHDRAW = "-",
   OPEN_LOAN = "$+",
   CLOSE_LOAN = "$-",
+  RUNEPOOL_DEPOSIT = "POOL+",
+  RUNEPOOL_WITHDRAW = "POOL-",
 }
 
 export const QuoteRequestSchema = z