Add Add/Remove Liquidity Nested

.changeset/swift-wasps-flash.md

@@ -0,0 +1,7 @@
+---
+"@balancer/sdk": minor
+---
+
+- Add AddLiquidityNested
+- Add RemoveLiquidityNestedProportional
+- Add RemoveLiquidityNestedSingleToken

.vscode/settings.json

@@ -1,10 +1,7 @@
 {
-    "editor.defaultFormatter": "rome.rome",
+    "editor.defaultFormatter": "biomejs.biome",
     "editor.formatOnSave": true,
-    "[json]": {
-        "editor.defaultFormatter": "rome.rome"
-    },
     "[typescript]": {
-        "editor.defaultFormatter": "rome.rome"
+        "editor.defaultFormatter": "biomejs.biome"
     }
 }

examples/addLiquidityNested.ts

@@ -0,0 +1,174 @@
+// pnpm example ./examples/addLiquidityNested.ts
+import { config } from 'dotenv';
+config();
+
+import {
+    Address,
+    BALANCER_RELAYER,
+    BalancerApi,
+    ChainId,
+    CHAINS,
+    AddLiquidityNested,
+    NestedPoolState,
+    replaceWrapped,
+    Slippage,
+} from '../src';
+import {
+    Client,
+    createTestClient,
+    http,
+    parseUnits,
+    PublicActions,
+    publicActions,
+    TestActions,
+    WalletActions,
+    walletActions,
+} from 'viem';
+import { AddLiquidityNestedInput } from '../src/entities/addLiquidityNested/types';
+import { Relayer } from '../src/entities/relayer';
+import {
+    forkSetup,
+    sendTransactionGetBalances,
+} from '../test/lib/utils/helper';
+import { ANVIL_NETWORKS, startFork } from '../test/anvil/anvil-global-setup';
+
+const balancerApiUrl = 'https://backend-v3-canary.beets-ftm-node.com/graphql';
+const poolId =
+    '0x08775ccb6674d6bdceb0797c364c2653ed84f3840002000000000000000004f0'; // WETH-3POOL
+const chainId = ChainId.MAINNET;
+
+const addLiquidityNested = async () => {
+    // User approve vault to spend their tokens and update user balance
+    const { client, accountAddress, nestedPoolState, rpcUrl } =
+        await exampleSetup();
+
+    // setup add liquidity helper
+    const addLiquidityNested = new AddLiquidityNested();
+
+    const amountsIn = [
+        {
+            address: '0x6b175474e89094c44da98b954eedeac495271d0f' as Address, // DAI
+            rawAmount: parseUnits('1', 18),
+        },
+    ];
+
+    const useNativeAssetAsWrappedAmountIn = false;
+
+    const addLiquidityInput: AddLiquidityNestedInput = {
+        amountsIn,
+        chainId,
+        rpcUrl,
+        accountAddress,
+        useNativeAssetAsWrappedAmountIn,
+    };
+    const queryOutput = await addLiquidityNested.query(
+        addLiquidityInput,
+        nestedPoolState,
+    );
+
+    // build add liquidity nested call with expected minBpOut based on slippage
+    const slippage = Slippage.fromPercentage('1'); // 1%
+
+    const signature = await Relayer.signRelayerApproval(
+        BALANCER_RELAYER[chainId],
+        accountAddress,
+        client,
+    );
+
+    const { call, to, value } = addLiquidityNested.buildCall({
+        ...queryOutput,
+        slippage,
+        sender: accountAddress,
+        recipient: accountAddress,
+        relayerApprovalSignature: signature,
+    });
+
+    let tokensIn = queryOutput.amountsIn.map((a) => a.token);
+    if (useNativeAssetAsWrappedAmountIn) {
+        tokensIn = replaceWrapped(tokensIn, chainId);
+    }
+
+    const tokens = [
+        ...tokensIn.map((t) => t.address),
+        queryOutput.bptOut.token.address,
+    ];
+
+    // send add liquidity nested transaction and check balance changes
+    const { transactionReceipt, balanceDeltas } =
+        await sendTransactionGetBalances(
+            tokens,
+            client,
+            accountAddress,
+            to,
+            call,
+            value,
+        );
+    console.log(`transaction status: ${transactionReceipt.status}`);
+    console.table({
+        tokens,
+        balanceDeltas,
+    });
+};
+
+const exampleSetup = async (): Promise<{
+    client: Client & PublicActions & TestActions & WalletActions;
+    accountAddress: Address;
+    nestedPoolState: NestedPoolState;
+    rpcUrl: string;
+}> => {
+    const { rpcUrl } = await startFork(ANVIL_NETWORKS.MAINNET);
+    const balancerApi = new BalancerApi(balancerApiUrl, chainId);
+    const nestedPoolState =
+        await balancerApi.nestedPools.fetchNestedPoolState(poolId);
+
+    const client: Client & PublicActions & TestActions & WalletActions =
+        createTestClient({
+            mode: 'anvil',
+            chain: CHAINS[chainId],
+            transport: http(rpcUrl),
+        })
+            .extend(publicActions)
+            .extend(walletActions);
+
+    const accountAddress = (await client.getAddresses())[0];
+
+    const mainTokens = [
+        {
+            address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2' as Address,
+            balance: parseUnits('1000', 18),
+            slot: 3,
+        },
+        {
+            address: '0x6b175474e89094c44da98b954eedeac495271d0f' as Address,
+            balance: parseUnits('1000', 18),
+            slot: 2,
+        },
+        {
+            address: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48' as Address,
+            balance: parseUnits('1000', 6),
+            slot: 9,
+        },
+        {
+            address: '0xdac17f958d2ee523a2206206994597c13d831ec7' as Address,
+            balance: parseUnits('1000', 6),
+            slot: 2,
+        },
+    ];
+
+    await forkSetup(
+        client,
+        accountAddress,
+        mainTokens.map((t) => t.address),
+        mainTokens.map((t) => t.slot),
+        mainTokens.map((t) => t.balance),
+    );
+
+    return {
+        client,
+        accountAddress,
+        nestedPoolState,
+        rpcUrl,
+    };
+};
+
+export default addLiquidityNested;

examples/createPoolComposableStable.ts

@@ -46,6 +46,7 @@ const createPoolComposableStable = async (): Promise<{
     const createPoolComposableStableInput: CreatePoolComposableStableInput = {
         name: 'Test Pool',
         symbol: '50BAL-50WETH',
+        poolType,
         tokens: [
             {
                 tokenAddress: '0xba100000625a3754423978a60c9317c58a424e3d',
@@ -62,11 +63,9 @@ const createPoolComposableStable = async (): Promise<{
         exemptFromYieldProtocolFeeFlag: false,
         swapFee: '0.01',
         poolOwnerAddress: signerAddress, // Balancer DAO Multisig
+        balancerVersion: 2,
     };
-    const { call } = createPool.buildCall(
-        poolType,
-        createPoolComposableStableInput,
-    );
+    const { call } = createPool.buildCall(createPoolComposableStableInput);
     const hash = await client.sendTransaction({
         to: COMPOSABLE_STABLE_POOL_FACTORY[chainId],
         data: call,

examples/createPoolWeighted.ts

@@ -15,7 +15,7 @@ import {
     startFork,
     stopAnvilForks,
 } from '../test/anvil/anvil-global-setup';
-import { CHAINS, ChainId, WEIGHTED_POOL_FACTORY } from '../src';
+import { CHAINS, ChainId, PoolType, WEIGHTED_POOL_FACTORY } from '../src';
 import { findEventInReceiptLogs } from '../test/lib/utils/findEventInReceiptLogs';
 import { weightedFactoryV4Abi } from '../src/abi/weightedFactoryV4';
 import { CreatePoolWeightedInput } from '../src/entities/createPool/types';
@@ -33,10 +33,11 @@ const createPool = async (stopForkAfterExecution = true) => {
         .extend(walletActions);
     const signerAddress = (await client.getAddresses())[0];
     const createPool = new CreatePool();
-    const poolType = 'WEIGHTED';
+    const poolType = PoolType.Weighted;
     const createWeightedPoolInput: CreatePoolWeightedInput = {
         name: 'Test Pool',
         symbol: '50BAL-25WETH-25DAI',
+        poolType,
         tokens: [
             {
                 tokenAddress: '0xba100000625a3754423978a60c9317c58a424e3d',
@@ -56,8 +57,9 @@ const createPool = async (stopForkAfterExecution = true) => {
         ],
         swapFee: '0.01',
         poolOwnerAddress: signerAddress, // Balancer DAO Multisig
+        balancerVersion: 2,
     };
-    const { call } = createPool.buildCall(poolType, createWeightedPoolInput);
+    const { call } = createPool.buildCall(createWeightedPoolInput);
     const hash = await client.sendTransaction({
         to: WEIGHTED_POOL_FACTORY[chainId],
         data: call,

examples/executeExample.ts

@@ -1,7 +1,8 @@
 import { stopAnvilForks } from '../test/anvil/anvil-global-setup';
 
 const executeExample = async (filePath) => {
-    const example = require(`../${filePath}`).default;
+    const exampleModule = await import(`../${filePath}`);
+    const example = exampleModule.default;
     await example();
     stopAnvilForks();
 };

package.json

@@ -15,9 +15,7 @@
     "type": "module",
     "types": "dist/index.d.ts",
     "typings": "dist/index.d.ts",
-    "files": [
-        "dist/"
-    ],
+    "files": ["dist/"],
     "scripts": {
         "build": "tsup",
         "format": "biome format --write .",
@@ -26,6 +24,7 @@
         "test:ci": "vitest run",
         "changeset": "changeset",
         "changeset:release": "pnpm build && changeset publish",
+        "anvil": "anvil --fork-url $(. ./.env && echo $ETHEREUM_RPC_URL)",
         "example": "npx tsx ./examples/executeExample.ts"
     },
     "dependencies": {

src/abi/authorizer.ts

@@ -0,0 +1,28 @@
+export const authorizerAbi = [
+    {
+        inputs: [
+            { internalType: 'bytes32', name: 'role', type: 'bytes32' },
+            { internalType: 'address', name: 'account', type: 'address' },
+        ],
+        name: 'grantRole',
+        outputs: [],
+        stateMutability: 'payable',
+        type: 'function',
+    },
+    {
+        inputs: [
+            { internalType: 'bytes32', name: 'role', type: 'bytes32' },
+            { internalType: 'address', name: 'account', type: 'address' },
+        ],
+        name: 'hasRole',
+        outputs: [
+            {
+                internalType: 'bool',
+                name: '',
+                type: 'bool',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+] as const;

src/abi/balancerRelayer.ts

@@ -0,0 +1,86 @@
+export const balancerRelayerAbi = [
+    {
+        inputs: [
+            {
+                internalType: 'contract IVault',
+                name: 'vault',
+                type: 'address',
+            },
+            {
+                internalType: 'address',
+                name: 'libraryAddress',
+                type: 'address',
+            },
+        ],
+        stateMutability: 'nonpayable',
+        type: 'constructor',
+    },
+    {
+        inputs: [],
+        name: 'getLibrary',
+        outputs: [
+            {
+                internalType: 'address',
+                name: '',
+                type: 'address',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [],
+        name: 'getVault',
+        outputs: [
+            {
+                internalType: 'contract IVault',
+                name: '',
+                type: 'address',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [
+            {
+                internalType: 'bytes[]',
+                name: 'data',
+                type: 'bytes[]',
+            },
+        ],
+        name: 'multicall',
+        outputs: [
+            {
+                internalType: 'bytes[]',
+                name: 'results',
+                type: 'bytes[]',
+            },
+        ],
+        stateMutability: 'payable',
+        type: 'function',
+    },
+    {
+        inputs: [
+            {
+                internalType: 'bytes[]',
+                name: 'data',
+                type: 'bytes[]',
+            },
+        ],
+        name: 'vaultActionsQueryMulticall',
+        outputs: [
+            {
+                internalType: 'bytes[]',
+                name: 'results',
+                type: 'bytes[]',
+            },
+        ],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+    {
+        stateMutability: 'payable',
+        type: 'receive',
+    },
+] as const;