@merkl/api 0.12.12 → 0.13.2

package/dist/src/modules/v4/kyberzap/kyberzap.service.js

@@ -1,4 +1,4 @@
-import { InteractionService } from "../interaction/interaction.service";
+import { TokenService } from "../token";
 import { chainToKyberLabel, dexIdToProtocolId, } from "./kyberzap.model";
 const KYBERZAP = `https://zap-api.kyberswap.com/`;
 export class KyberZapService {
@@ -45,6 +45,69 @@ export class KyberZapService {
     static getFullRangeTicks() {
         return [-886800, 886800];
     }
+    /**
+     * Converts the breakdown of actions
+     * @param zapActions
+     * @returns provider-agnostic interaction actions
+     */
+    static async getActions(chainId, zapActions) {
+        const actions = [];
+        const processors = {
+            ACTION_TYPE_PROTOCOL_FEE: async ({ protocolFee: { tokens: zapTokens } }) => {
+                const tokens = await TokenService.getManyOrCreate(zapTokens.map(({ address }) => ({ address, chainId })));
+                return [
+                    {
+                        action: "fee",
+                        tokens: tokens.filter(t => !!t).map((t, i) => ({ ...t, amount: BigInt(zapTokens[i].amount) })),
+                    },
+                ];
+            },
+            ACTION_TYPE_AGGREGATOR_SWAP: async ({ aggregatorSwap: { swaps } }) => {
+                const swapActions = [];
+                for (const { tokenIn, tokenOut } of swaps) {
+                    const [from, to] = await TokenService.getManyOrCreate([
+                        { address: tokenIn.address, chainId },
+                        { address: tokenOut.address, chainId },
+                    ]);
+                    swapActions.push({
+                        action: "swap",
+                        from: { ...from, amount: BigInt(tokenIn.amount) },
+                        to: { ...to, amount: BigInt(tokenOut.amount) },
+                    });
+                }
+                return swapActions;
+            },
+            ACTION_TYPE_POOL_SWAP: async ({ poolSwap: { swaps } }) => {
+                const swapActions = [];
+                for (const { tokenIn, tokenOut } of swaps) {
+                    const [from, to] = await TokenService.getManyOrCreate([
+                        { address: tokenIn.address, chainId },
+                        { address: tokenOut.address, chainId },
+                    ]);
+                    swapActions.push({
+                        action: "swap",
+                        from: { ...from, amount: BigInt(tokenIn.amount) },
+                        to: { ...to, amount: BigInt(tokenOut.amount) },
+                    });
+                }
+                return swapActions;
+            },
+            ACTION_TYPE_ADD_LIQUIDITY: async ({ addLiquidity: { tokens: zapTokens } }) => {
+                const tokens = await TokenService.getManyOrCreate(zapTokens.map(({ address }) => ({ address, chainId })));
+                return [
+                    {
+                        action: "deposit",
+                        tokens: tokens.filter(t => !!t).map((t, i) => ({ ...t, amount: BigInt(zapTokens[i].amount) })),
+                    },
+                ];
+            },
+        };
+        for (const { type, ...zapAction } of zapActions) {
+            const action = await processors[type](zapAction);
+            actions.push(...action);
+        }
+        return actions;
+    }
     static async getTransaction(chainId, protocol, identifier, userAddress, fromTokenAddress, fromTokenAmount, slippage) {
         const [lower, upper] = KyberZapService.getFullRangeTicks();
         const { data: route } = await KyberZapService.#fetch("/api/v1/in/route", {
@@ -60,6 +123,11 @@ export class KyberZapService {
             },
             chainId,
         });
+        const actions = await KyberZapService.getActions(chainId, route.zapDetails.actions);
+        const [tokenIn] = await TokenService.getManyOrCreate([{ address: fromTokenAddress, chainId }]);
+        const deposit = actions.findLast(({ action }) => action === "deposit");
+        const tokenInValue = await TokenService.getValue([{ ...tokenIn, amount: fromTokenAmount }]);
+        const depositValue = await TokenService.getValue(deposit.tokens);
         const { data: transaction } = await KyberZapService.#post("/api/v1/in/route/build", {
             query: {},
             body: {
@@ -72,16 +140,36 @@ export class KyberZapService {
             },
             chainId,
         });
-        const { allowance, approval, approved } = await InteractionService.getApproval(chainId, userAddress, route.routerAddress, fromTokenAddress, fromTokenAmount);
         return {
-            allowance,
-            approval,
-            approved,
-            amountIn: fromTokenAmount,
+            actions,
+            depositValue,
             transaction: {
                 to: transaction.routerAddress,
                 data: transaction.callData,
-                value: !!transaction.value && BigInt(transaction.value),
+                value: transaction.value,
+            },
+        };
+    }
+    /**
+     * Defines abstract router functions
+     * @returns Router
+     */
+    static getRouter() {
+        return {
+            name: "zap",
+            async getTarget(chainId, protocolId, identifier) {
+                const dexId = KyberZapService.getDexId(protocolId);
+                const chainLabel = KyberZapService.getChainLabel(chainId);
+                if (!dexId || !chainLabel)
+                    return;
+                return {
+                    provider: "zap",
+                    chainId: chainId,
+                    identifier: identifier,
+                };
+            },
+            async getTransaction(chainId, protocolId, identifier, userAddress, fromTokenAddress, fromTokenAmount, options) {
+                return await KyberZapService.getTransaction(chainId, protocolId, identifier, userAddress, fromTokenAddress, fromTokenAmount, options.slippage);
             },
         };
     }

package/dist/src/modules/v4/router.d.ts

@@ -2727,6 +2727,8 @@ export declare const v4: Elysia<"/v4", false, {
                             approved: boolean;
                             transaction: import("./interaction/interaction.model").UserTransaction;
                             approval: import("./interaction/interaction.model").UserTransaction;
+                            actions?: import("./interaction/interaction.model").InteractionAction[] | undefined;
+                            depositValue?: number | undefined;
                         } | undefined;
                     };
                 };

package/dist/src/utils/pricer.d.ts

@@ -48,5 +48,7 @@ export declare class Pricer {
     /** Saves the current price data in the cache */
     save(): Promise<void>;
     /** Recomputes all prices and saves them in the cache */
-    update(): Promise<void>;
+    update(): Promise<{
+        [token: string]: number;
+    }>;
 }

package/dist/src/utils/pricer.js

@@ -176,5 +176,6 @@ export class Pricer {
             }
         } // Update extraPricesData
         await this.save();
+        return this.prices;
     }
 }

package/dist/src/utils/prices/priceService.js

@@ -76,16 +76,6 @@ export default class PriceService {
                 this._prices["0x3Df8AAC90Eb2FeeA4378368D46a72AF47eBDc268"] = uni_WETH_YIELD;
             }
         }));
-        promises.push((async () => {
-            try {
-                const d = await new Contract("0x3a29cab2e124919d14a6f735b6033a3aad2b260f", ["function discount() external view returns(uint256)"], providers[ChainId.POLYGON]).discount();
-                this._prices["oRETRO"] = this._prices["RETRO"] * (1 - Number.parseInt(d.toString()) / 100);
-            }
-            catch (e) {
-                log.error(`❌ error fetching oRetro discount:`, e);
-                this._prices["oRETRO"] = this._prices["RETRO"] * 0.6;
-            }
-        })());
         this.setConstantPrices(tokenPriceSources);
         this.setEqualsToPrices(tokenPriceSources);
         /** Hardcoded prices  */
@@ -251,18 +241,6 @@ export default class PriceService {
         catch (error) {
             log.error("❌ call to fetch blueprint api price failed", error);
         }
-        promises.push((async () => {
-            try {
-                const d = await new Contract("0xEdb73D4ED90bE7A49D06d0D940055e6d181d22fa", ["function discount() external view returns(uint256)"], providers[ChainId.MAINNET]).discount();
-                this._prices["oBLUE"] = this._prices["BLUE"] * (1 - Number.parseInt(d.toString()) / 100);
-            }
-            catch (e) {
-                log.error("❌ error fetching oBLUE discount:", e);
-                this._prices["oBLUE"] = this._prices["BLUE"] * 0.6;
-            }
-        })());
-        this._prices["bveBLUE"] = this._prices["oBLUE"] * 0.85;
-        this._prices["BVEBLUE"] = this._prices["bveBLUE"];
         /** Flux price completion */
         promises.push((async () => {
             try {