feat: add PanoraSwapper implementation (web-ohh.11)

Author: Discostu

packages/chain-adapters/src/aptos/AptosChainAdapter.ts

@@ -234,18 +234,14 @@ export class ChainAdapter implements IChainAdapter<KnownChainIds.AptosMainnet> {
     return recommended > MIN_MAX_GAS_AMOUNT ? recommended : MIN_MAX_GAS_AMOUNT
   }
 
-  async buildSendApiTransaction(
-    input: BuildSendApiTxInput<KnownChainIds.AptosMainnet>,
-  ): Promise<SignTx<KnownChainIds.AptosMainnet>> {
+  async buildEntryFunctionApiTransaction(input: {
+    from: string
+    accountNumber: number
+    data: InputEntryFunctionData
+  }): Promise<SignTx<KnownChainIds.AptosMainnet>> {
     try {
-      const { from, accountNumber, to, value, chainSpecific } = input
-      const coinType = chainSpecific?.coinType ?? APT_COIN_TYPE
+      const { from, accountNumber, data } = input
 
-      const data: InputEntryFunctionData = {
-        function: '0x1::aptos_account::transfer_coins',
-        typeArguments: [coinType],
-        functionArguments: [to, BigInt(value)],
-      }
       const maxGasAmount = Number(await this.estimateMaxGasAmount(from, data))
 
       const transaction = await this.client.transaction.build.simple({
@@ -269,6 +265,21 @@ export class ChainAdapter implements IChainAdapter<KnownChainIds.AptosMainnet> {
     }
   }
 
+  buildSendApiTransaction(
+    input: BuildSendApiTxInput<KnownChainIds.AptosMainnet>,
+  ): Promise<SignTx<KnownChainIds.AptosMainnet>> {
+    const { from, accountNumber, to, value, chainSpecific } = input
+    const coinType = chainSpecific?.coinType ?? APT_COIN_TYPE
+
+    const data: InputEntryFunctionData = {
+      function: '0x1::aptos_account::transfer_coins',
+      typeArguments: [coinType],
+      functionArguments: [to, BigInt(value)],
+    }
+
+    return this.buildEntryFunctionApiTransaction({ from, accountNumber, data })
+  }
+
   async buildSendTransaction(input: BuildSendTxInput<KnownChainIds.AptosMainnet>): Promise<{
     txToSign: SignTx<KnownChainIds.AptosMainnet>
   }> {

packages/swapper/src/swappers/PanoraSwapper/PanoraSwapper.ts

@@ -0,0 +1,6 @@
+import { executeAptosTransaction } from '../..'
+import type { Swapper } from '../../types'
+
+export const panoraSwapper: Swapper = {
+  executeAptosTransaction,
+}

packages/swapper/src/swappers/PanoraSwapper/endpoints.ts

@@ -0,0 +1,116 @@
+import { TxStatus } from '@shapeshiftoss/unchained-client'
+import { bnOrZero } from '@shapeshiftoss/utils'
+import type { Result } from '@sniptt/monads'
+
+import { getDefaultSlippageDecimalPercentageForSwapper } from '../../constants'
+import type {
+  CommonTradeQuoteInput,
+  GetTradeRateInput,
+  GetUnsignedAptosTransactionArgs,
+  SwapErrorRight,
+  SwapperApi,
+  SwapperDeps,
+  TradeQuote,
+  TradeRate,
+  TradeStatus,
+} from '../../types'
+import { SwapperName } from '../../types'
+import { checkAptosSwapStatus, isExecutableTradeQuote } from '../../utils'
+import { getPanoraTradeData } from './swapperApi/getPanoraTradeData'
+import { getTradeQuote } from './swapperApi/getTradeQuote'
+import { getTradeRate } from './swapperApi/getTradeRate'
+
+export const panoraApi: SwapperApi = {
+  getTradeQuote: (
+    input: CommonTradeQuoteInput,
+    deps: SwapperDeps,
+  ): Promise<Result<TradeQuote[], SwapErrorRight>> => {
+    return getTradeQuote(input, deps)
+  },
+
+  getTradeRate: (
+    input: GetTradeRateInput,
+    deps: SwapperDeps,
+  ): Promise<Result<TradeRate[], SwapErrorRight>> => {
+    return getTradeRate(input, deps)
+  },
+
+  getUnsignedAptosTransaction: async ({
+    stepIndex,
+    tradeQuote,
+    from,
+    assertGetAptosChainAdapter,
+    config,
+  }: GetUnsignedAptosTransactionArgs) => {
+    if (!isExecutableTradeQuote(tradeQuote)) throw new Error('Unable to execute a trade rate quote')
+
+    const step = tradeQuote.steps[stepIndex ?? 0]
+    if (!step) throw new Error(`No step at index ${stepIndex}`)
+
+    const { accountNumber, sellAsset, buyAsset, sellAmountIncludingProtocolFeesCryptoBaseUnit } =
+      step
+
+    const adapter = assertGetAptosChainAdapter(sellAsset.chainId)
+
+    // Re-fetch quote from Panora to get fresh txData for execution
+    const slippagePercentage = bnOrZero(
+      tradeQuote.slippageTolerancePercentageDecimal ??
+        getDefaultSlippageDecimalPercentageForSwapper(SwapperName.Panora),
+    )
+      .times(100)
+      .toNumber()
+
+    const tradeDataResult = await getPanoraTradeData({
+      sellAsset,
+      buyAsset,
+      sellAmountIncludingProtocolFeesCryptoBaseUnit,
+      receiveAddress: from,
+      affiliateBps: tradeQuote.affiliateBps,
+      slippagePercentage,
+      config,
+    })
+
+    if (tradeDataResult.isErr()) {
+      throw new Error(`Failed to get Panora trade data: ${tradeDataResult.unwrapErr().message}`)
+    }
+
+    const { txData } = tradeDataResult.unwrap()
+
+    return adapter.buildEntryFunctionApiTransaction({
+      from,
+      accountNumber: accountNumber ?? 0,
+      data: {
+        function: txData.function as `${string}::${string}::${string}`,
+        typeArguments: txData.type_arguments,
+        functionArguments: txData.arguments,
+      },
+    })
+  },
+
+  getAptosTransactionFees: ({ tradeQuote, stepIndex }: GetUnsignedAptosTransactionArgs) => {
+    if (!isExecutableTradeQuote(tradeQuote)) throw new Error('Unable to execute a trade rate quote')
+
+    const step = tradeQuote.steps[stepIndex ?? 0]
+    if (!step) throw new Error('Missing step')
+    if (!step.feeData.networkFeeCryptoBaseUnit) {
+      throw new Error('Missing network fee in quote')
+    }
+    return Promise.resolve(step.feeData.networkFeeCryptoBaseUnit)
+  },
+
+  checkTradeStatus: ({ swap, assertGetAptosChainAdapter }): Promise<TradeStatus> => {
+    if (!swap?.sellTxHash) {
+      return Promise.resolve({
+        status: TxStatus.Unknown,
+        buyTxHash: undefined,
+        message: undefined,
+      })
+    }
+
+    return checkAptosSwapStatus({
+      txHash: swap.sellTxHash,
+      address: swap.receiveAddress,
+      assertGetAptosChainAdapter,
+    })
+  },
+}

packages/swapper/src/swappers/PanoraSwapper/index.ts

@@ -0,0 +1,5 @@
+export {
+  PANORA_NATIVE_TOKEN_ADDRESS,
+  PANORA_DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE,
+  SUPPORTED_PANORA_CHAIN_IDS,
+} from './utils/constants'

packages/swapper/src/swappers/PanoraSwapper/swapperApi/getPanoraTradeData.ts

@@ -1,16 +1,16 @@
-import { bnOrZero } from '@shapeshiftoss/utils'
+import type { AssetId } from '@shapeshiftoss/caip'
+import type { Asset } from '@shapeshiftoss/types'
+import { bnOrZero, fromBaseUnit, toBaseUnit } from '@shapeshiftoss/utils'
 import type { Result } from '@sniptt/monads'
 import { Err, Ok } from '@sniptt/monads'
 
-import type { AssetId } from '@shapeshiftoss/caip'
-import type { Asset } from '@shapeshiftoss/types'
 import type { ProtocolFee, SwapErrorRight, SwapperConfig } from '../../../types'
 import { TradeQuoteError } from '../../../types'
 import { getInputOutputRate, makeSwapErrorRight } from '../../../utils'
-import { isSupportedChainId } from '../utils/constants'
+import type { PanoraSwapResponse } from '../types'
+import { isSupportedChainId, PANORA_INTEGRATOR_FEE_ADDRESS } from '../utils/constants'
 import { getTokenAddress } from '../utils/helpers'
 import { getPanoraService } from '../utils/panoraService'
-import type { PanoraSwapResponse } from '../types'
 
 type PanoraTradeDataInput = {
   sellAsset: Asset
@@ -79,13 +79,24 @@ export const getPanoraTradeData = async (
   const requestBody: Record<string, unknown> = {
     fromTokenAddress,
     toTokenAddress,
-    fromTokenAmount: sellAmountIncludingProtocolFeesCryptoBaseUnit,
+    // The Panora API deals in human-readable token amounts, not base units
+    fromTokenAmount: fromBaseUnit(
+      sellAmountIncludingProtocolFeesCryptoBaseUnit,
+      sellAsset.precision,
+    ),
     toWalletAddress: receiveAddress,
     slippagePercentage,
   }
 
-  if (integratorFeePercentage !== undefined && integratorFeePercentage > 0) {
+  // Panora deducts integratorFeePercentage from the user even without integratorFeeAddress,
+  // but only routes it on-chain when the address is present. Never send the percentage alone.
+  if (
+    PANORA_INTEGRATOR_FEE_ADDRESS &&
+    integratorFeePercentage !== undefined &&
+    integratorFeePercentage > 0
+  ) {
     requestBody.integratorFeePercentage = integratorFeePercentage
+    requestBody.integratorFeeAddress = PANORA_INTEGRATOR_FEE_ADDRESS
   }
 
   try {
@@ -110,7 +121,7 @@ export const getPanoraTradeData = async (
     // Take the best quote (first one)
     const bestQuote = data.quotes[0]
 
-    const buyAmountAfterFeesCryptoBaseUnit = bestQuote.toTokenAmount
+    const buyAmountAfterFeesCryptoBaseUnit = toBaseUnit(bestQuote.toTokenAmount, buyAsset.precision)
 
     const rate = getInputOutputRate({
       sellAmountCryptoBaseUnit: sellAmountIncludingProtocolFeesCryptoBaseUnit,

packages/swapper/src/swappers/PanoraSwapper/swapperApi/getTradeQuote.ts

@@ -8,6 +8,7 @@ import type { CommonTradeQuoteInput, SwapErrorRight, SwapperDeps, TradeQuote } f
 import { SwapperName, TradeQuoteError } from '../../../types'
 import { makeSwapErrorRight } from '../../../utils'
 import { buildAffiliateFee } from '../../utils/affiliateFee'
+import { PANORA_INTEGRATOR_FEE_ADDRESS } from '../utils/constants'
 import { getPanoraTradeData } from './getPanoraTradeData'
 
 export const getTradeQuote = async (
@@ -49,12 +50,16 @@ export const getTradeQuote = async (
     .times(100)
     .toNumber()
 
+  // No integrator fee address is configured yet, so Panora cannot route an affiliate fee
+  // to the DAO; zero it out rather than displaying a fee that is not collected.
+  const appliedAffiliateBps = PANORA_INTEGRATOR_FEE_ADDRESS ? affiliateBps : '0'
+
   const tradeDataResult = await getPanoraTradeData({
     sellAsset,
     buyAsset,
     sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
     receiveAddress,
-    affiliateBps,
+    affiliateBps: appliedAffiliateBps,
     slippagePercentage,
     config: deps.config,
   })
@@ -71,7 +76,7 @@ export const getTradeQuote = async (
       id: uuid(),
       quoteOrRate: 'quote',
       rate,
-      affiliateBps,
+      affiliateBps: appliedAffiliateBps,
       receiveAddress,
       slippageTolerancePercentageDecimal,
       swapperName: SwapperName.Panora,
@@ -97,7 +102,7 @@ export const getTradeQuote = async (
           estimatedExecutionTimeMs: undefined,
           affiliateFee: buildAffiliateFee({
             strategy: 'buy_asset',
-            affiliateBps,
+            affiliateBps: appliedAffiliateBps,
             sellAsset,
             buyAsset,
             sellAmountCryptoBaseUnit: sellAmount,

packages/swapper/src/swappers/PanoraSwapper/swapperApi/getTradeRate.ts

@@ -8,6 +8,7 @@ import type { GetTradeRateInput, SwapErrorRight, SwapperDeps, TradeRate } from '
 import { SwapperName, TradeQuoteError } from '../../../types'
 import { makeSwapErrorRight } from '../../../utils'
 import { buildAffiliateFee } from '../../utils/affiliateFee'
+import { PANORA_INTEGRATOR_FEE_ADDRESS } from '../utils/constants'
 import { getPanoraTradeData } from './getPanoraTradeData'
 
 const DUMMY_WALLET_ADDRESS = '0x0000000000000000000000000000000000000000000000000000000000000000'
@@ -34,12 +35,16 @@ export const getTradeRate = async (
 
   const walletAddress = receiveAddress ?? DUMMY_WALLET_ADDRESS
 
+  // No integrator fee address is configured yet, so Panora cannot route an affiliate fee
+  // to the DAO; zero it out rather than displaying a fee that is not collected.
+  const appliedAffiliateBps = PANORA_INTEGRATOR_FEE_ADDRESS ? affiliateBps : '0'
+
   const tradeDataResult = await getPanoraTradeData({
     sellAsset,
     buyAsset,
     sellAmountIncludingProtocolFeesCryptoBaseUnit: sellAmount,
     receiveAddress: walletAddress,
-    affiliateBps,
+    affiliateBps: appliedAffiliateBps,
     slippagePercentage,
     config: deps.config,
   })
@@ -55,7 +60,7 @@ export const getTradeRate = async (
       id: uuid(),
       quoteOrRate: 'rate',
       rate,
-      affiliateBps,
+      affiliateBps: appliedAffiliateBps,
       receiveAddress,
       slippageTolerancePercentageDecimal,
       swapperName: SwapperName.Panora,
@@ -77,7 +82,7 @@ export const getTradeRate = async (
           estimatedExecutionTimeMs: undefined,
           affiliateFee: buildAffiliateFee({
             strategy: 'buy_asset',
-            affiliateBps,
+            affiliateBps: appliedAffiliateBps,
             sellAsset,
             buyAsset,
             sellAmountCryptoBaseUnit: sellAmount,

packages/swapper/src/swappers/PanoraSwapper/utils/constants.ts

@@ -11,3 +11,10 @@ export const isSupportedChainId = (
 
 export const PANORA_NATIVE_TOKEN_ADDRESS = '0xa'
 export const PANORA_DEFAULT_SLIPPAGE_DECIMAL_PERCENTAGE = '0.005'
+
+// Panora routes integrator fees on-chain only when integratorFeeAddress accompanies
+// integratorFeePercentage; the percentage alone is still deducted from the user but kept
+// by Panora (verified against the live /swap API). Leave unset until the DAO has an Aptos
+// treasury address (the DAO_TREASURY_APTOS placeholder was removed during review for the
+// same reason).
+export const PANORA_INTEGRATOR_FEE_ADDRESS: string | undefined = undefined