refactor: split Token into BaseToken & Token

examples/swaps/auraBalSwap.ts

@@ -14,7 +14,6 @@ import {
     Relayer,
     Slippage,
     AuraBalSwap,
-    Token,
     TokenAmount,
     SwapKind,
     isAuraBalSwap,
@@ -24,15 +23,16 @@ import { ANVIL_NETWORKS, startFork } from '../../test/anvil/anvil-global-setup';
 import { makeForkTx } from 'examples/lib/makeForkTx';
 import { getSlot } from 'examples/lib/getSlot';
 import { exit } from 'node:process';
+import { BaseToken } from '@/entities/baseToken';
 
 const auraBalSwap = async ({ rpcUrl, client, userAccount, chainId }) => {
-    const tokenIn = new Token(
+    const tokenIn = new BaseToken(
         ChainId.MAINNET,
         '0xba100000625a3754423978a60c9317c58a424e3D', // BAL
         18,
     );
 
-    const tokenOut = new Token(
+    const tokenOut = new BaseToken(
         ChainId.MAINNET,
         '0x616e8BfA43F920657B3497DBf40D6b1A02D4608d', // auraBal
         18,

examples/swaps/querySmartPath.ts

@@ -10,19 +10,19 @@ import {
     API_ENDPOINT,
     ChainId,
     SwapKind,
-    Token,
     TokenAmount,
     Swap,
     ExactInQueryOutput,
     ExactOutQueryOutput,
 } from '../../src';
+import { BaseToken } from '@/entities/baseToken';
 
 interface QuerySmartPath {
     rpcUrl: string;
     chainId: ChainId;
     swapKind: SwapKind;
-    tokenIn: Token;
-    tokenOut: Token;
+    tokenIn: BaseToken;
+    tokenOut: BaseToken;
     swapAmount: TokenAmount;
 }
 

examples/swaps/swapV2.ts

@@ -10,28 +10,29 @@ import {
     ChainId,
     Slippage,
     SwapKind,
-    Token,
-    TokenAmount,
     SwapBuildCallInput,
     VAULT_V2,
 } from '../../src';
+import { BaseToken } from '@/entities/baseToken';
 import { querySmartPath } from './querySmartPath';
 import { setupExampleFork } from '../lib/setupExampleFork';
 import { TOKENS, approveSpenderOnToken } from 'test/lib/utils';
+import { TokenAmount } from '@/entities';
+
 const swapV2 = async () => {
     // Choose chain id to start fork
     const chainId = ChainId.MAINNET;
     const { client, rpcUrl, userAccount } = await setupExampleFork({ chainId });
 
     // User defines these params for querying swap with SOR
     const swapKind = SwapKind.GivenIn;
-    const tokenIn = new Token(
+    const tokenIn = new BaseToken(
         chainId,
         TOKENS[chainId].WETH.address,
         TOKENS[chainId].WETH.decimals,
         'WETH',
     );
-    const tokenOut = new Token(
+    const tokenOut = new BaseToken(
         chainId,
         TOKENS[chainId].BAL.address,
         TOKENS[chainId].BAL.decimals,

src/entities/addLiquidity/addLiquidityCowAmm/index.ts

@@ -1,6 +1,6 @@
 import { encodeFunctionData } from 'viem';
 import { cowAmmPoolAbi } from '@/abi/cowAmmPool';
-import { Token } from '@/entities/token';
+import { BaseToken } from '@/entities/baseToken';
 import { TokenAmount } from '@/entities/tokenAmount';
 import { PoolState } from '@/entities/types';
 import { poolTypeError, protocolVersionError } from '@/utils';
@@ -47,12 +47,16 @@ export class AddLiquidityCowAmm implements AddLiquidityBase {
         );
 
         const bptOut = TokenAmount.fromRawAmount(
-            new Token(input.chainId, bptAmount.address, bptAmount.decimals),
+            new BaseToken(input.chainId, bptAmount.address, bptAmount.decimals),
             bptAmount.rawAmount,
         );
         const amountsIn = tokenAmounts.map((amountIn) =>
             TokenAmount.fromRawAmount(
-                new Token(input.chainId, amountIn.address, amountIn.decimals),
+                new BaseToken(
+                    input.chainId,
+                    amountIn.address,
+                    amountIn.decimals,
+                ),
                 amountIn.rawAmount,
             ),
         );

src/entities/addLiquidity/addLiquidityV2/composableStable/addLiquidityComposableStable.ts

@@ -1,5 +1,5 @@
 import { encodeFunctionData } from 'viem';
-import { Token } from '@/entities/token';
+import { BaseToken } from '@/entities/baseToken';
 import { TokenAmount } from '@/entities/tokenAmount';
 import { protocolVersionError, VAULT_V2, ZERO_ADDRESS } from '@/utils';
 import { vaultV2Abi } from '@/abi';
@@ -56,7 +56,7 @@ export class AddLiquidityComposableStable implements AddLiquidityBase {
             args,
         );
 
-        const bpt = new Token(input.chainId, poolState.address, 18);
+        const bpt = new BaseToken(input.chainId, poolState.address, 18);
         const bptOut = TokenAmount.fromRawAmount(bpt, queryOutput.bptOut);
 
         const amountsIn = queryOutput.amountsIn.map((a, i) =>

src/entities/addLiquidity/addLiquidityV2/stable/addLiquidityStable.ts

@@ -1,5 +1,5 @@
 import { encodeFunctionData } from 'viem';
-import { Token } from '@/entities/token';
+import { BaseToken } from '@/entities/baseToken';
 import { TokenAmount } from '@/entities/tokenAmount';
 import { StableEncoder } from '@/entities/encoders/stable';
 import { protocolVersionError, VAULT_V2, ZERO_ADDRESS } from '@/utils';
@@ -49,7 +49,7 @@ export class AddLiquidityStable implements AddLiquidityBase {
             args,
         );
 
-        const bpt = new Token(input.chainId, poolState.address, 18);
+        const bpt = new BaseToken(input.chainId, poolState.address, 18);
         const bptOut = TokenAmount.fromRawAmount(bpt, queryOutput.bptOut);
 
         const amountsIn = queryOutput.amountsIn.map((a, i) =>

src/entities/addLiquidity/addLiquidityV2/weighted/addLiquidityWeighted.ts

@@ -1,5 +1,5 @@
 import { encodeFunctionData } from 'viem';
-import { Token } from '@/entities/token';
+import { BaseToken } from '@/entities/baseToken';
 import { TokenAmount } from '@/entities/tokenAmount';
 import { WeightedEncoder } from '@/entities/encoders/weighted';
 import { protocolVersionError, VAULT_V2, ZERO_ADDRESS } from '@/utils';
@@ -51,7 +51,7 @@ export class AddLiquidityWeighted implements AddLiquidityBase {
             args,
         );
 
-        const bpt = new Token(input.chainId, poolState.address, 18);
+        const bpt = new BaseToken(input.chainId, poolState.address, 18);
         const bptOut = TokenAmount.fromRawAmount(bpt, queryOutput.bptOut);
 
         const amountsIn = queryOutput.amountsIn.map((a, i) =>

src/entities/addLiquidity/addLiquidityV3/index.ts

@@ -1,7 +1,7 @@
 import { encodeFunctionData, zeroAddress } from 'viem';
 import { balancerRouterAbiExtended } from '@/abi';
 import { Permit2 } from '@/entities/permit2Helper';
-import { Token } from '@/entities/token';
+import { BaseToken } from '@/entities/baseToken';
 import { TokenAmount } from '@/entities/tokenAmount';
 import { PoolState } from '@/entities/types';
 import {
@@ -33,7 +33,7 @@ export class AddLiquidityV3 implements AddLiquidityBase {
         block?: bigint,
     ): Promise<AddLiquidityBaseQueryOutput> {
         const sortedTokens = getSortedTokens(poolState.tokens, input.chainId);
-        const bptToken = new Token(input.chainId, poolState.address, 18);
+        const bptToken = new BaseToken(input.chainId, poolState.address, 18);
 
         let bptOut: TokenAmount;
         let amountsIn: TokenAmount[];

src/entities/addLiquidityBoosted/index.ts

@@ -19,7 +19,7 @@ import {
 } from '../addLiquidity/types';
 import { doAddLiquidityUnbalancedQuery } from './doAddLiquidityUnbalancedQuery';
 import { doAddLiquidityProportionalQuery } from './doAddLiquidityPropotionalQuery';
-import { Token } from '../token';
+import { BaseToken } from '@/entities/baseToken';
 import { balancerV3Contracts, protocolVersionError } from '@/utils';
 import {
     balancerCompositeLiquidityRouterBoostedAbiExtended,
@@ -52,7 +52,7 @@ export class AddLiquidityBoostedV3 {
             type: 'Boosted',
         });
 
-        const bptToken = new Token(input.chainId, poolState.address, 18);
+        const bptToken = new BaseToken(input.chainId, poolState.address, 18);
         const wrapUnderlying: boolean[] = new Array(
             poolState.tokens.length,
         ).fill(false);
@@ -151,7 +151,7 @@ export class AddLiquidityBoostedV3 {
                 amountsIn = tokensIn.map((t, i) => {
                     const tokenInAddress = t.toLowerCase() as Address;
                     const { decimals } = poolStateTokenMap[tokenInAddress];
-                    const token = new Token(
+                    const token = new BaseToken(
                         input.chainId,
                         tokenInAddress,
                         decimals,

src/entities/addLiquidityBuffer/index.ts

@@ -6,7 +6,7 @@ import { Permit2 } from '@/entities/permit2Helper';
 import { BufferState } from '@/entities/types';
 
 import { doAddLiquidityQuery } from './doAddLiquidityQuery';
-import { Token } from '../token';
+import { BaseToken } from '../baseToken';
 import {
     balancerBufferRouterAbiExtended,
     balancerRouterAbiExtended,
@@ -35,7 +35,7 @@ export class AddLiquidityBufferV3 {
                 input.exactSharesToIssue,
                 block,
             );
-        const underlyingToken = new Token(
+        const underlyingToken = new BaseToken(
             input.chainId,
             bufferState.underlyingToken.address,
             bufferState.underlyingToken.decimals,
@@ -44,7 +44,7 @@ export class AddLiquidityBufferV3 {
             underlyingToken,
             amountUnderlyingIn,
         );
-        const wrappedToken = new Token(
+        const wrappedToken = new BaseToken(
             input.chainId,
             bufferState.wrappedToken.address,
             bufferState.wrappedToken.decimals,

src/entities/addLiquidityNested/addLiquidityNestedV2/getQueryCallsAttributes.ts

@@ -1,5 +1,5 @@
 import { Address, PoolType } from '@/types';
-import { Token } from '@/entities/token';
+import { BaseToken } from '@/entities/baseToken';
 import {
     ZERO_ADDRESS,
     BALANCER_RELAYER,
@@ -31,7 +31,7 @@ export const getQueryCallsAttributes = (
     for (const pool of poolsSortedByLevel) {
         const sortedTokens = pool.tokens
             .sort((a, b) => a.index - b.index)
-            .map((t) => new Token(chainId, t.address, t.decimals));
+            .map((t) => new BaseToken(chainId, t.address, t.decimals));
         const maxAmountsIn = getMaxAmountsIn(sortedTokens, amountsIn, calls);
         if (maxAmountsIn.every((a) => a.amount === 0n && !a.isRef)) {
             continue;
@@ -61,7 +61,7 @@ export const getQueryCallsAttributes = (
 };
 
 const getMaxAmountsIn = (
-    sortedTokens: Token[],
+    sortedTokens: BaseToken[],
     amountsIn: { address: Address; rawAmount: bigint }[],
     calls: AddLiquidityNestedCallAttributes[],
 ): { amount: bigint; isRef: boolean }[] => {

src/entities/addLiquidityNested/addLiquidityNestedV2/index.ts

@@ -1,5 +1,5 @@
 import { encodeFunctionData } from 'viem';
-import { Token } from '../../token';
+import { BaseToken } from '../../baseToken';
 import { BALANCER_RELAYER, ZERO_ADDRESS } from '../../../utils';
 import { Relayer } from '../../relayer';
 import { encodeCalls } from './encodeCalls';
@@ -50,7 +50,7 @@ export class AddLiquidityNestedV2 {
             encodedMulticall,
         );
 
-        const tokenOut = new Token(
+        const tokenOut = new BaseToken(
             input.chainId,
             callsAttributes[callsAttributes.length - 1].poolAddress,
             18,

src/entities/addLiquidityNested/addLiquidityNestedV2/types.ts

@@ -1,7 +1,7 @@
 import { Address, Hex } from 'viem';
 import { PoolType } from '../../../types';
 import { ChainId } from '../../../utils';
-import { Token } from '../../token';
+import { BaseToken } from '../../baseToken';
 import { TokenAmount } from '../../tokenAmount';
 import { PoolKind } from '../../types';
 import { Slippage } from '@/entities/slippage';
@@ -14,7 +14,7 @@ export type AddLiquidityNestedInputV2 = AddLiquidityNestedBaseInput & {
 export type AddLiquidityNestedCallAttributes = {
     chainId: ChainId;
     wethIsEth?: boolean;
-    sortedTokens: Token[];
+    sortedTokens: BaseToken[];
     poolId: Hex;
     poolAddress: Address;
     poolType: PoolType;

src/entities/addLiquidityNested/addLiquidityNestedV2/validateInputs.ts

@@ -1,6 +1,6 @@
 import { inputValidationError, NATIVE_ASSETS } from '@/utils';
 
-import { Token } from '../../token';
+import { BaseToken } from '../../baseToken';
 import { TokenAmount } from '../../tokenAmount';
 import { NestedPoolState } from '../../types';
 import { AddLiquidityNestedInput } from '../types';
@@ -11,7 +11,7 @@ export const validateQueryInput = (
     nestedPoolState: NestedPoolState,
 ): TokenAmount[] => {
     const mainTokens = nestedPoolState.mainTokens.map(
-        (t) => new Token(input.chainId, t.address, t.decimals),
+        (t) => new BaseToken(input.chainId, t.address, t.decimals),
     );
     const amountsIn = input.amountsIn.map((amountIn) => {
         const tokenIn = mainTokens.find((t) =>
@@ -35,7 +35,7 @@ export const validateBuildCallInput = (
     if (input.wethIsEth) {
         if (
             !input.amountsIn.some((a) =>
-                a.token.isUnderlyingEqual(NATIVE_ASSETS[chainId]),
+                a.token.isSameAddress(NATIVE_ASSETS[chainId].wrapped),
             )
         ) {
             throw inputValidationError(

src/entities/addLiquidityNested/addLiquidityNestedV3/index.ts

@@ -11,7 +11,7 @@ import {
     AddLiquidityNestedBuildCallOutput,
     AddLiquidityNestedInput,
 } from '../types';
-import { Token } from '@/entities/token';
+import { BaseToken } from '@/entities/baseToken';
 import { getAmounts, getValue } from '@/entities/utils';
 import { TokenAmount } from '@/entities/tokenAmount';
 import {
@@ -57,7 +57,7 @@ export class AddLiquidityNestedV3 {
         // query function input, `tokensIn` array, must have all tokens from child pools
         // and all tokens that are not BPTs from the nested pool (parent pool).
         const mainTokens = nestedPoolState.mainTokens.map(
-            (t) => new Token(input.chainId, t.address, t.decimals),
+            (t) => new BaseToken(input.chainId, t.address, t.decimals),
         );
         // This will add 0 amount for any tokensIn the user hasn't included
         const maxAmountsIn = getAmounts(mainTokens, input.amountsIn, 0n);
@@ -74,7 +74,7 @@ export class AddLiquidityNestedV3 {
             block,
         );
 
-        const bptToken = new Token(input.chainId, parentPool.address, 18);
+        const bptToken = new BaseToken(input.chainId, parentPool.address, 18);
 
         return {
             to: BALANCER_COMPOSITE_LIQUIDITY_ROUTER_NESTED[input.chainId],

src/entities/baseToken.ts

@@ -0,0 +1,45 @@
+import { Address } from 'viem';
+import { InputToken } from '../types';
+
+/**
+ * BaseToken contains the core functionality for all tokens
+ * This class handles the essential token properties and methods
+ * without any wrapped token logic
+ */
+export class BaseToken {
+    public readonly chainId: number;
+    public readonly address: Address;
+    public readonly decimals: number;
+    public readonly symbol?: string;
+    public readonly name?: string;
+
+    public constructor(
+        chainId: number,
+        address: Address,
+        decimals: number,
+        symbol?: string,
+        name?: string,
+    ) {
+        this.chainId = chainId;
+        // Addresses are always lowercased for speed
+        this.address = address.toLowerCase() as Address;
+        this.decimals = decimals;
+        this.symbol = symbol;
+        this.name = name;
+    }
+
+    public isEqual(token: BaseToken) {
+        return this.chainId === token.chainId && this.address === token.address;
+    }
+
+    public isSameAddress(address: Address) {
+        return this.address === address.toLowerCase();
+    }
+
+    public toInputToken(): InputToken {
+        return {
+            address: this.address,
+            decimals: this.decimals,
+        };
+    }
+}