Init piperx swap

Author: tunghp2002

package.json

@@ -105,7 +105,7 @@
     "@polkadot/types-support": "^15.0.1",
     "@polkadot/util": "^13.2.3",
     "@polkadot/util-crypto": "^13.2.3",
-    "@subwallet/chain-list": "0.2.98",
+    "@subwallet/chain-list": "/home/tug/Subwallet/SubWallet-ChainList/packages/chain-list/build",
     "@subwallet/keyring": "^0.1.8-beta.0",
     "@subwallet/react-ui": "5.1.2-b79",
     "@subwallet/ui-keyring": "0.1.8-beta.0",

packages/extension-base/package.json

@@ -55,7 +55,7 @@
     "@reduxjs/toolkit": "^1.9.1",
     "@sora-substrate/type-definitions": "^1.17.7",
     "@substrate/connect": "^0.8.9",
-    "@subwallet/chain-list": "0.2.98",
+    "@subwallet/chain-list": "/home/tug/Subwallet/SubWallet-ChainList/packages/chain-list/build",
     "@subwallet/extension-base": "^1.3.15-0",
     "@subwallet/extension-chains": "^1.3.15-0",
     "@subwallet/extension-dapp": "^1.3.15-0",

packages/extension-base/src/services/swap-service/handler/piperx/constant.ts

@@ -0,0 +1,38 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { getCreate2Address, keccak256, solidityPacked } from 'ethers';
+import Web3 from 'web3';
+
+export const defaultTokens: string[] = [
+  '0x40fCa9cB1AB15eD9B5bDA19A52ac00A78AE08e1D',
+  '0x02F75bdBb4732cc6419aC15EeBeE6BCee66e826f',
+  '0x6D46EF45795B1c3e2a5f2A3F7aba5ea551be966f'
+];
+
+export const fee2TickSpace: { [key: string]: number } = {
+  10000: 200,
+  3000: 60,
+  500: 10
+};
+export const provider = new Web3.providers.HttpProvider('https://odyssey.storyrpc.io/');
+export const web3 = new Web3(provider);
+export const WIP_ADDRESS = '0xe8CabF9d1FFB6CE23cF0a86641849543ec7BD7d5';
+export const v2FactoryAddress = '0x700722D24f9256Be288f56449E8AB1D27C4a70ca';
+export const v2RouterAddress = '0x8812d810EA7CC4e1c3FB45cef19D6a7ECBf2D85D';
+export const piperv3QuoterAddress = '0x82C210d4aA5948f68E46Af355C0399c2E921e8e4';
+export const piperv3SwapRouterAddress = '0xbBb8B63596d5447a12Ddee557ac9fA326f42B57D';
+export const piperv3FactoryAddress = '0xf3d448d7A83F749695c49d8411247fC3868fB633';
+export const piperv3NFTPositionManagerAddress = '0xf03c65d9be145746f800E2781eD140F6dd238F38';
+export const multicallAddress = '0xcA11bde05977b3631167028862bE2a173976CA11';
+
+export const v2ComputeAddress = (token0: string, token1: string) => {
+  const [token0Sorted, token1Sorted] = token0.toLowerCase() < token1.toLowerCase()
+    ? [token0, token1]
+    : [token1, token0];
+
+  const salt = keccak256(solidityPacked(['address', 'address'], [token0Sorted, token1Sorted]));
+  const initCodeHash = '0x754f724019203c806610a02ada224eb21dbe068a93d50486e52cf0ae30de457a';
+
+  return getCreate2Address(v2FactoryAddress, salt, initCodeHash) as `0x${string}`;
+};

packages/extension-base/src/services/swap-service/handler/piperx/core.ts

@@ -0,0 +1,77 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { piperv3FactoryAddress, v2ComputeAddress, web3 } from './constant';
+import { piperv3FactoryAbi, piperv3PoolAbi, v2PoolAbi } from './piperx_abi';
+
+interface Reserves {
+  _reserve0: string;
+  _reserve1: string;
+  _blockTimestampLast: string;
+}
+
+export const v2GetPrice = async (
+  token1: string,
+  token2: string
+) => {
+  const pairAddress = v2ComputeAddress(token1, token2);
+
+  const pairContract = new web3.eth.Contract(v2PoolAbi, pairAddress);
+
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
+    const reserve = (await pairContract.methods.getReserves().call()) as Reserves;
+
+    // Determine token order (tokens are stored in ascending order by address in Uniswap V2)
+    const token1_ = token1.toLowerCase() < token2.toLowerCase() ? token1 : token2;
+
+    const reserve0 = reserve._reserve0;
+    const reserve1 = reserve._reserve1;
+    // Calculate price based on reserves
+    const price = token1_ === token1
+      ? BigInt(reserve1) / BigInt(reserve0)
+      : BigInt(reserve0) / BigInt(reserve1);
+
+    console.log('price', Number(price) * 10 ** (6 - 18));
+
+    return price;
+  } catch (error) {
+    console.error('Error fetching reserves:', error);
+    throw error;
+  }
+};
+
+export const v3GetPrice = async (
+  token1: string,
+  token2: string,
+  fee = 3000 // Default to 0.3% fee tier
+): Promise<number> => {
+  // Compute pool address using V3 factory
+  const factory = new web3.eth.Contract(piperv3FactoryAbi, piperv3FactoryAddress);
+  const poolAddress = await factory.methods.getPool(token1, token2, fee).call();
+
+  if (poolAddress === '0x0000000000000000000000000000000000000000') {
+    throw new Error('Pool does not exist');
+  }
+
+  const poolContract = new web3.eth.Contract(piperv3PoolAbi, poolAddress);
+
+  try {
+    const slot0 = await poolContract.methods.slot0().call();
+
+    const sqrtPriceX96 = slot0.sqrtPriceX96;
+
+    // Convert sqrtPriceX96 to regular price
+    const price = (Number(sqrtPriceX96) / 2 ** 96) ** 2;
+
+    // Determine if price needs to be inverted based on token order
+    const token0 = await poolContract.methods.token0().call();
+
+    console.log('token', [token0, token1]);
+
+    return token0.toLowerCase() === token1.toLowerCase() ? price : 1 / price;
+  } catch (error) {
+    console.error('Error fetching V3 price:', error);
+    throw error;
+  }
+};

packages/extension-base/src/services/swap-service/handler/piperx/handler.ts

@@ -0,0 +1,134 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { SwapError } from '@subwallet/extension-base/background/errors/SwapError';
+import { TransactionError } from '@subwallet/extension-base/background/errors/TransactionError';
+import { _getSimpleSwapEarlyValidationError } from '@subwallet/extension-base/core/logic-validation';
+import { BalanceService } from '@subwallet/extension-base/services/balance-service';
+import { ChainService } from '@subwallet/extension-base/services/chain-service';
+import { _getChainNativeTokenSlug, _getContractAddressOfToken, _isNativeToken } from '@subwallet/extension-base/services/chain-service/utils';
+import { BaseStepDetail, CommonFeeComponent, CommonOptimalPath, CommonStepFeeInfo, CommonStepType, OptimalSwapPathParams, SimpleSwapValidationMetadata, SwapEarlyValidation, SwapErrorType, SwapFeeType, SwapProviderId, SwapQuote, SwapRequest, SwapStepType, SwapSubmitParams, SwapSubmitStepData, ValidateSwapProcessParams } from '@subwallet/extension-base/types';
+import Web3 from 'web3';
+
+import { calculateSwapRate, SWAP_QUOTE_TIMEOUT_MAP } from '../../utils';
+import { SwapBaseHandler, SwapBaseInterface } from '../base-handler';
+import { v2GetPrice } from './core';
+import { routingExactInput, v2RoutingExactInput, WIP_ADDRESS } from './logic';
+
+export class PiperXSwapHandler implements SwapBaseInterface {
+  private swapBaseHandler: SwapBaseHandler;
+  providerSlug: SwapProviderId;
+  constructor (chainService: ChainService, balanceService: BalanceService) {
+    this.swapBaseHandler = new SwapBaseHandler({
+      chainService,
+      balanceService,
+      providerName: 'PiperX',
+      providerSlug: SwapProviderId.PIPERX
+    });
+    this.providerSlug = SwapProviderId.PIPERX;
+  }
+
+  get chainService () {
+    return this.swapBaseHandler.chainService;
+  }
+
+  get balanceService () {
+    return this.swapBaseHandler.balanceService;
+  }
+
+  get providerInfo () {
+    return this.swapBaseHandler.providerInfo;
+  }
+
+  get name () {
+    return this.swapBaseHandler.name;
+  }
+
+  get slug () {
+    return this.swapBaseHandler.slug;
+  }
+
+  validateSwapProcess: (params: ValidateSwapProcessParams) => Promise<TransactionError[]>;
+  isReady?: boolean | undefined;
+  init?: (() => Promise<void>) | undefined;
+
+  async getSwapQuote (request: SwapRequest): Promise<SwapQuote | SwapError> {
+    const fromAsset = this.chainService.getAssetBySlug(request.pair.from);
+    const toAsset = this.chainService.getAssetBySlug(request.pair.to);
+    const fromChain = this.chainService.getChainInfoByKey(fromAsset.originChain);
+    const fromChainNativeTokenSlug = _getChainNativeTokenSlug(fromChain);
+
+    const fromContract = _getContractAddressOfToken(fromAsset);
+    const toContract = _getContractAddressOfToken(toAsset);
+    // const earlyValidation = await this.validateSwapRequest(request);
+
+    // if (earlyValidation.error) {
+    //   const metadata = earlyValidation.metadata as SimpleSwapValidationMetadata;
+
+    //   return _getSimpleSwapEarlyValidationError(earlyValidation.error, metadata);
+    // }
+
+    const defaultFeeToken = _isNativeToken(fromAsset) ? fromAsset.slug : fromChainNativeTokenSlug;
+    const toAmount = await v2GetPrice(fromContract, toContract);
+    const networkFee: CommonFeeComponent = {
+      tokenSlug: fromChainNativeTokenSlug,
+      amount: '1',
+      feeType: SwapFeeType.NETWORK_FEE
+    };
+
+    try {
+      return {
+        pair: request.pair,
+        fromAmount: request.fromAmount,
+        toAmount: toAmount.toString(),
+        rate: calculateSwapRate(request.fromAmount, toAmount.toString(), fromAsset, toAsset),
+        provider: this.providerInfo,
+        aliveUntil: +Date.now() + (SWAP_QUOTE_TIMEOUT_MAP[this.slug] || SWAP_QUOTE_TIMEOUT_MAP.default),
+        feeInfo: {
+          feeComponent: [networkFee],
+          defaultFeeToken,
+          feeOptions: [defaultFeeToken]
+        }
+      } as SwapQuote;
+    } catch (e) {
+      return new SwapError(SwapErrorType.ERROR_FETCHING_QUOTE);
+    }
+  }
+
+  generateOptimalProcess (params: OptimalSwapPathParams): Promise<CommonOptimalPath> {
+    return this.swapBaseHandler.generateOptimalProcess(params, [
+      this.getSubmitStep
+    ]);
+  }
+
+  async getSubmitStep (params: OptimalSwapPathParams): Promise<[BaseStepDetail, CommonStepFeeInfo] | undefined> {
+    if (params.selectedQuote) {
+      const submitStep = {
+        name: 'Swap',
+        type: SwapStepType.SWAP
+      };
+
+      return Promise.resolve([submitStep, params.selectedQuote.feeInfo]);
+    }
+
+    return Promise.resolve(undefined);
+  }
+
+  validateSwapRequest: (request: SwapRequest) => Promise<SwapEarlyValidation>;
+  public async handleSwapProcess (params: SwapSubmitParams): Promise<SwapSubmitStepData> {
+    const { currentStep, process } = params;
+    const type = process.steps[currentStep].type;
+
+    switch (type) {
+      case CommonStepType.DEFAULT:
+        return Promise.reject(new TransactionError(BasicTxErrorType.UNSUPPORTED));
+      case SwapStepType.SWAP:
+        return this.handleSubmitStep(params);
+      default:
+        return this.handleSubmitStep(params);
+    }
+  }
+
+  handleSwapProcess: (params: SwapSubmitParams) => Promise<SwapSubmitStepData>;
+  handleSubmitStep: (params: SwapSubmitParams) => Promise<SwapSubmitStepData>;
+}

packages/extension-base/src/services/swap-service/handler/piperx/index.ts

@@ -0,0 +1,4 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+export { PiperXSwapHandler } from './handler';

packages/extension-base/src/services/swap-service/handler/piperx/logic.ts

@@ -0,0 +1,106 @@
+// Copyright 2019-2022 @subwallet/extension-base
+// SPDX-License-Identifier: Apache-2.0
+
+import { fee2TickSpace, multicallAddress, piperv3QuoterAddress, v2RouterAddress, web3 } from './constant';
+import { v2GetPrice, v3GetPrice } from './core';
+import { multicallAbi, piperv3QuoterAbi, v2RouterAbi } from './piperx_abi';
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires,@typescript-eslint/no-unsafe-assignment
+
+export const WIP_ADDRESS = '0xe8CabF9d1FFB6CE23cF0a86641849543ec7BD7d5';
+const multicallContract = new web3.eth.Contract(multicallAbi, multicallAddress);
+const v2RouterContract = new web3.eth.Contract(v2RouterAbi, v2RouterAddress);
+
+export const v3RoutingExactInput = async (
+  tokenIn: string,
+  tokenOut: string,
+  tokenInAmount: bigint,
+  signerAddress: string
+): Promise<{ bestRoute: string[]; maxAmountOut: bigint }> => {
+  const quoterContract = new web3.eth.Contract(piperv3QuoterAbi, piperv3QuoterAddress);
+  let bestRoute: string[] = [];
+  let maxAmountOut = BigInt(0);
+
+  const calls = Object.keys(fee2TickSpace).map((feeTier) => ({
+    target: piperv3QuoterAddress,
+    callData: quoterContract.methods
+      .quoteExactInputSingle({
+        tokenIn,
+        tokenOut,
+        fee: feeTier,
+        amountIn: tokenInAmount.toString(),
+        sqrtPriceLimitX96: '0'
+      })
+      .encodeABI()
+  }));
+
+  try {
+    const aggregateResult = await multicallContract.methods.tryAggregate(false, calls).call({
+      from: signerAddress,
+      gas: calls.length * 300000
+    });
+
+    aggregateResult.forEach(([success, returnData], i) => {
+      if (success) {
+        try {
+          const decoded = web3.eth.abi.decodeParameters(['uint256', 'uint256'], returnData);
+          const amountOut = BigInt(decoded[0]);
+
+          if (amountOut > maxAmountOut) {
+            maxAmountOut = amountOut;
+            bestRoute = [tokenIn, Object.keys(fee2TickSpace)[i], tokenOut];
+          }
+        } catch (error) {
+          console.log(`Error decoding result for fee tier ${Object.keys(fee2TickSpace)[i]}:`, error);
+        }
+      }
+    });
+  } catch (error) {
+    console.error('Multicall tryAggregate failed:', error);
+  }
+
+  console.log('version3', [bestRoute, maxAmountOut]);
+
+  return { bestRoute, maxAmountOut };
+};
+
+export const v2RoutingExactInput = async (
+  tokenIn: string,
+  tokenOut: string,
+  tokenInAmount: bigint
+): Promise<{ bestRoute: string[]; maxAmountOut: bigint }> => {
+  let bestRoute: string[] = [];
+  let maxAmountOut = BigInt(0);
+
+  try {
+    const directResult = await v2RouterContract.methods.getAmountsOut(tokenInAmount.toString(), [tokenIn, tokenOut]).call();
+
+    console.log('directResult', directResult);
+
+    maxAmountOut = BigInt(directResult[1]);
+    bestRoute = [tokenIn, tokenOut];
+  } catch (error) {
+    console.log('Error in direct route calculation:', error);
+  }
+
+  console.log('version2', [bestRoute, maxAmountOut]);
+
+  return { bestRoute, maxAmountOut };
+};
+
+export const routingExactInput = async (
+  tokenIn: string,
+  tokenOut: string,
+  tokenInAmount: bigint,
+  signerAddress: string
+): Promise<{ bestRoute: string[]; maxAmountOut: bigint }> => {
+  const { bestRoute: bestRouteV2, maxAmountOut: maxAmountOutV2 } = await v2RoutingExactInput(tokenIn, tokenOut, tokenInAmount);
+  const { bestRoute: bestRouteV3, maxAmountOut: maxAmountOutV3 } = await v3RoutingExactInput(tokenIn, tokenOut, tokenInAmount, signerAddress);
+
+  console.log('Hmm', await v2GetPrice(tokenIn, tokenOut));
+  console.log('Hmm1', await v3GetPrice(tokenIn, tokenOut));
+
+  return maxAmountOutV2 > maxAmountOutV3
+    ? { bestRoute: bestRouteV2, maxAmountOut: maxAmountOutV2 }
+    : { bestRoute: bestRouteV3, maxAmountOut: maxAmountOutV3 };
+};