Merge pull request #114 from rabbitholegg/mmackz-add_balancer

feat(balancer): add support for balancer swap

Author: Quazia

.changeset/curly-jeans-dress.md

@@ -0,0 +1,6 @@
+---
+"@rabbitholegg/questdk-plugin-balancer": minor
+"@rabbitholegg/questdk-plugin-registry": minor
+---
+
+add swap support for balancer

packages/balancer/CHANGELOG.md

@@ -0,0 +1,50 @@
+{
+  "name": "@rabbitholegg/questdk-plugin-balancer",
+  "version": "1.0.0-alpha.4",
+  "type": "module",
+  "exports": {
+    "require": "./dist/cjs/index.js",
+    "import": "./dist/esm/index.js",
+    "types": "./dist/types/index.d.ts"
+  },
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "packageManager": "pnpm@8.3.1",
+  "description": "",
+  "scripts": {
+    "bench": "vitest bench",
+    "bench:ci": "CI=true vitest bench",
+    "build": "pnpm run clean && pnpm run build:cjs && pnpm run build:esm && pnpm run build:types",
+    "build:cjs": "tsc --project tsconfig.build.json --module commonjs --outDir ./dist/cjs --removeComments --verbatimModuleSyntax false && echo > ./dist/cjs/package.json '{\"type\":\"commonjs\"}'",
+    "build:esm": "tsc --project tsconfig.build.json --module es2015 --outDir ./dist/esm && echo > ./dist/esm/package.json '{\"type\":\"module\",\"sideEffects\":false}'",
+    "build:types": "tsc --project tsconfig.build.json --module esnext --declarationDir ./dist/types --emitDeclarationOnly --declaration --declarationMap",
+    "clean": "rimraf dist",
+    "format": "rome format . --write",
+    "lint": "rome check .",
+    "lint:fix": "pnpm lint --apply",
+    "preinstall": "npx only-allow pnpm",
+    "test": "vitest dev",
+    "test:cov": "vitest dev --coverage",
+    "test:ci": "CI=true vitest --coverage",
+    "test:ui": "vitest dev --ui"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "types": "./dist/types/index.d.ts",
+  "typings": "./dist/types/index.d.ts",
+  "devDependencies": {
+    "@types/node": "^20.4.5",
+    "@vitest/coverage-v8": "^0.33.0",
+    "rimraf": "^5.0.1",
+    "rome": "^12.1.3",
+    "ts-node": "^10.9.1",
+    "tsconfig": "workspace:*",
+    "typescript": "^5.1.6",
+    "vitest": "^0.33.0"
+  },
+  "dependencies": {
+    "@rabbitholegg/questdk": "2.0.0-alpha.27",
+    "viem": "^1.2.15"
+  }
+}

packages/balancer/README.md

@@ -0,0 +1,115 @@
+import { apply, GreaterThanOrEqual } from '@rabbitholegg/questdk/filter'
+import { describe, expect, test } from 'vitest'
+import { zeroAddress, parseEther, parseUnits } from 'viem'
+import { swap, getSupportedTokenAddresses } from './Balancer'
+import { Chains } from './utils'
+import { BALANCER_ABI } from './abi'
+import { VAULT_CONTRACT, CHAIN_ID_ARRAY } from './constants'
+import { failingTestCases, passingTestCases } from './test-transactions'
+
+describe('Given the balancer plugin', () => {
+  describe('When handling the swap action', () => {
+    describe('should return a valid action filter', () => {
+      test('when making a swap', async () => {
+        const filter = await swap({
+          chainId: Chains.POLYGON_POS,
+          contractAddress: VAULT_CONTRACT,
+          tokenIn: zeroAddress,
+          tokenOut: '0x2791bca1f2de4661ed88a30c99a7a9449aa84174', // USDC.e
+          amountIn: GreaterThanOrEqual(parseEther('3')),
+          amountOut: GreaterThanOrEqual(parseUnits('2', 6)),
+          recipient: '0xa99f898530df1514a566f1a6562d62809e99557d',
+        })
+
+        expect(filter).to.deep.equal({
+          chainId: Chains.POLYGON_POS,
+          to: VAULT_CONTRACT,
+          input: {
+            $abiAbstract: BALANCER_ABI,
+            $or: [
+              {
+                singleSwap: {
+                  assetIn: '0x0000000000000000000000000000000000000000',
+                  assetOut: '0x2791bca1f2de4661ed88a30c99a7a9449aa84174',
+                  amount: {
+                    $gte: '3000000000000000000',
+                  },
+                },
+                funds: {
+                  recipient: '0xa99f898530df1514a566f1a6562d62809e99557d',
+                },
+              },
+              {
+                assets: {
+                  $and: [
+                    {
+                      $first: '0x0000000000000000000000000000000000000000',
+                    },
+                    {
+                      $last: '0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174',
+                    },
+                  ],
+                },
+                limits: {
+                  $and: [
+                    {
+                      $first: {
+                        $gte: '3000000000000000000',
+                      },
+                    },
+                    {
+                      $last: {
+                        $lte: '-2000000',
+                      },
+                    },
+                  ],
+                },
+                funds: {
+                  recipient: '0xa99f898530df1514a566f1a6562d62809e99557d',
+                },
+              },
+            ],
+          },
+        })
+      })
+    })
+
+    describe('should pass filter when all parameters are valid', () => {
+      passingTestCases.forEach((testCase) => {
+        const { transaction, params, description } = testCase
+        test(description, async () => {
+          const filter = await swap(params)
+          expect(apply(transaction, filter)).to.be.true
+        })
+      })
+    })
+
+    describe('should not pass filter when parameters are invalid', () => {
+      failingTestCases.forEach((testCase) => {
+        const { transaction, params, description } = testCase
+        test(description, async () => {
+          const filter = await swap(params)
+          expect(apply(transaction, filter)).to.be.false
+        })
+      })
+    })
+
+    describe('should return a valid list of tokens for each supported chain', () => {
+      CHAIN_ID_ARRAY.forEach((chainId) => {
+        test(`for chainId: ${chainId}`, async () => {
+          const tokens = await getSupportedTokenAddresses(chainId)
+          const addressRegex = /^0x[a-fA-F0-9]{40}$/
+          expect(tokens).to.be.an('array')
+          expect(tokens).to.have.length.greaterThan(0)
+          expect(tokens).to.have.length.lessThan(100)
+          tokens.forEach((token) => {
+            expect(token).to.match(
+              addressRegex,
+              `Token address ${token} is not a valid Ethereum address`,
+            )
+          })
+        })
+      })
+    })
+  })
+})

packages/balancer/package.json

@@ -0,0 +1,65 @@
+import {
+  type TransactionFilter,
+  type SwapActionParams,
+  compressJson,
+} from '@rabbitholegg/questdk'
+import { type Address } from 'viem'
+import { BALANCER_ABI } from './abi'
+import { CHAIN_ID_ARRAY, VAULT_CONTRACT, PATCH_CONTRACT } from './constants'
+import { buildAmountQuery, buildPathQuery } from './utils'
+import { CHAIN_TO_TOKENS } from './token-addresses'
+
+export const swap = async (
+  swap: SwapActionParams,
+): Promise<TransactionFilter> => {
+  const {
+    chainId,
+    contractAddress,
+    tokenIn,
+    tokenOut,
+    amountIn,
+    amountOut,
+    recipient,
+  } = swap
+
+  return compressJson({
+    chainId: chainId,
+    to: contractAddress ?? {
+      $or: [VAULT_CONTRACT.toLowerCase(), PATCH_CONTRACT.toLowerCase()],
+    },
+    input: {
+      $abiAbstract: BALANCER_ABI,
+      $or: [
+        {
+          // swap
+          singleSwap: {
+            assetIn: tokenIn,
+            assetOut: tokenOut,
+            amount: amountIn,
+          },
+          funds: {
+            recipient: recipient,
+          },
+        },
+        {
+          // batch swap
+          assets: buildPathQuery(tokenIn, tokenOut),
+          limits: buildAmountQuery(amountIn, amountOut),
+          funds: {
+            recipient: recipient,
+          },
+        },
+      ],
+    },
+  })
+}
+
+export const getSupportedTokenAddresses = async (
+  _chainId: number,
+): Promise<Address[]> => {
+  return CHAIN_TO_TOKENS[_chainId] ?? []
+}
+
+export const getSupportedChainIds = async (): Promise<number[]> => {
+  return CHAIN_ID_ARRAY as number[]
+}