@exodus/solana-api 3.20.10 → 3.22.0

package/CHANGELOG.md

@@ -3,6 +3,26 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [3.22.0](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.21.0...@exodus/solana-api@3.22.0) (2025-10-15)
+
+
+### Features
+
+
+* feat: solana update fee as zero with usedFeePayer (#6702)
+
+
+
+## [3.21.0](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.20.10...@exodus/solana-api@3.21.0) (2025-10-14)
+
+
+### Features
+
+
+* feat: integrate Solana fee payer service (#6615)
+
+
+
 ## [3.20.10](https://github.com/ExodusMovement/assets/compare/@exodus/solana-api@3.20.8...@exodus/solana-api@3.20.10) (2025-10-14)
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/solana-api",
-  "version": "3.20.10",
+  "version": "3.22.0",
   "description": "Transaction monitors, fee monitors, RPC with the blockchain node, and other networking code for Solana",
   "type": "module",
   "main": "src/index.js",
@@ -26,12 +26,14 @@
     "@exodus/asset-json-rpc": "^1.0.0",
     "@exodus/asset-lib": "^5.0.0",
     "@exodus/assets": "^11.0.0",
+    "@exodus/auth-client-base": "^2.2.0",
     "@exodus/basic-utils": "^3.0.1",
+    "@exodus/crypto": "^1.0.0-rc.16",
     "@exodus/currency": "^6.0.1",
     "@exodus/fetch": "^1.7.3",
     "@exodus/models": "^12.0.1",
     "@exodus/simple-retry": "^0.0.6",
-    "@exodus/solana-lib": "^3.11.1",
+    "@exodus/solana-lib": "^3.13.0",
     "@exodus/solana-meta": "^2.0.2",
     "@exodus/timer": "^1.1.1",
     "debug": "^4.1.1",
@@ -47,7 +49,7 @@
     "@exodus/assets-testing": "^1.0.0",
     "@exodus/solana-web3.js": "^1.63.1-exodus.9-rc3"
   },
-  "gitHead": "b0f1b6b69b7a6f7e70eee7e03db7bf71ba6be92a",
+  "gitHead": "5b5f2c1945d66ef1f0481e1822afc730dc5261d4",
   "bugs": {
     "url": "https://github.com/ExodusMovement/assets/issues?q=is%3Aissue+is%3Aopen+label%3Asolana-api"
   },

package/src/auth.js

@@ -0,0 +1,23 @@
+import { randomBytes } from '@exodus/crypto/randomBytes'
+import { generateKeyPair } from '@exodus/solana-lib'
+
+const authKeyPairCache = new Map()
+
+const normalizeServiceUrl = (serviceUrl) => {
+  const u = new URL(serviceUrl)
+  return u.origin
+}
+
+export const getAuthKeyPair = ({ assetName, apiUrl, network }) => {
+  const cacheKey = `auth_keypair:v1:${normalizeServiceUrl(apiUrl)}:${assetName}:${network || 'mainnet'}`
+
+  if (!authKeyPairCache.has(cacheKey)) {
+    const keyPair = generateKeyPair(randomBytes(32))
+    authKeyPairCache.set(cacheKey, {
+      publicKey: keyPair.publicKey.toBuffer().toString('hex'),
+      privateKey: keyPair.privateKey.toString('hex'),
+    })
+  }
+
+  return authKeyPairCache.get(cacheKey)
+}

package/src/create-unsigned-tx-for-send.js

@@ -1,4 +1,3 @@
-import { fetchival } from '@exodus/fetch'
 import {
   createUnsignedTx,
   deserializeTransaction,
@@ -7,134 +6,38 @@ import {
   prepareForSigning,
   TOKEN_2022_PROGRAM_ID,
   TOKEN_PROGRAM_ID,
-  verifyOnlyFeePayerChanged,
 } from '@exodus/solana-lib'
 import assert from 'minimalistic-assert'
 
+import { maybeAddFeePayerWithAuth } from './fee-payer.js'
+
 const CU_FOR_COMPUTE_BUDGET_INSTRUCTIONS = 300
 const TOKEN_ACCOUNT_CREATION_SIZE = 165 // size of the token account
 
-export const createUnsignedTxForSend = async ({
-  api,
-  asset,
-  feeData,
-  toAddress,
-  fromAddress,
-  amount,
-  reference,
-  memo,
-  nft,
-  feePayerApiUrl,
-  useFeePayer = true,
-  // token related
-  tokenStandard,
-  customMintAddress,
-  // staking
-  method,
-  stakeAddresses,
-  accounts,
-  seed,
-  pool,
-  // <MagicEden>
-  initializerAddress,
-  initializerDepositTokenAddress,
-  takerAmount,
-  escrowAddress,
-  escrowBump,
-  pdaAddress,
-  takerAddress,
-  expectedTakerAmount,
-  expectedMintAddress,
-  metadataAddress,
-  creators,
-  // </MagicEden>
-  isExchange,
-}) => {
+export const createTxFactory = ({ assetClientInterface, api, feePayerClient }) => {
   assert(api, 'api is required')
-  assert(asset, 'asset is required')
-  assert(feeData, 'feeData is required')
-  let tokenParams = Object.create(null)
-  const baseAsset = asset.baseAsset
-
-  if (nft) {
-    const [, nftAddress] = nft.id.split(':')
-    customMintAddress = nftAddress
-    tokenStandard = nft.tokenStandard
-    method = tokenStandard === 4 ? 'metaplexTransfer' : undefined
-    amount = asset.currency.baseUnit(1)
-  }
-
-  const isToken = asset.name !== asset.baseAsset.name
-
-  // Check if receiver has address active when sending tokens.
-  if (isToken) {
-    // check address mint is the same
-    const targetMint = await api.getAddressMint(toAddress) // null if it's a SOL address
-    if (targetMint && targetMint !== asset.mintAddress) {
-      const err = new Error('Wrong Destination Wallet')
-      err.mintAddressMismatch = true
-      throw err
-    }
-  } else {
-    // sending SOL
-    const addressType = await api.getAddressType(toAddress)
-    if (addressType === 'token') {
-      const err = new Error('Destination Wallet is a Token address')
-      err.wrongAddressType = true
-      throw err
-    }
-  }
+  assert(assetClientInterface, 'assetClientInterface is required')
 
-  if (isToken || customMintAddress) {
-    const tokenMintAddress = customMintAddress || asset.mintAddress
-    const tokenProgramPublicKey =
-      (await api.getAddressType(tokenMintAddress)) === 'token-2022'
-        ? TOKEN_2022_PROGRAM_ID
-        : TOKEN_PROGRAM_ID
-
-    const tokenProgram = tokenProgramPublicKey.toBase58()
-    const tokenAddress = findAssociatedTokenAddress(toAddress, tokenMintAddress, tokenProgram)
-
-    const [destinationAddressType, isAssociatedTokenAccountActive, fromTokenAccountAddresses] =
-      await Promise.all([
-        api.getAddressType(toAddress),
-        api.isAssociatedTokenAccountActive(tokenAddress),
-        api.getTokenAccountsByOwner(fromAddress),
-      ])
-
-    const changedOwnership = await api.ataOwnershipChangedCached(toAddress, tokenAddress)
-    if (changedOwnership) {
-      const err = new Error('Destination ATA changed ownership')
-      err.ownershipChanged = true
-      throw err
-    }
-
-    const fromTokenAddresses = fromTokenAccountAddresses.filter(
-      ({ mintAddress }) => mintAddress === tokenMintAddress
-    )
-
-    tokenParams = {
-      tokenMintAddress,
-      destinationAddressType,
-      isAssociatedTokenAccountActive,
-      fromTokenAddresses,
-      tokenStandard,
-      tokenProgram,
-    }
-  }
-
-  const stakingParams = {
+  return async ({
+    asset,
+    walletAccount,
+    feeData: providedFeeData,
+    fromAddress: providedFromAddress,
+    toAddress,
+    amount,
+    reference,
+    memo,
+    nft,
+    // token related
+    tokenStandard,
+    customMintAddress,
+    // staking
     method,
     stakeAddresses,
     accounts,
     seed,
     pool,
-  }
-
-  const recentBlockhash = await api.getRecentBlockHash()
-
-  const magicEdenParams = {
-    method,
+    // <MagicEden>
     initializerAddress,
     initializerDepositTokenAddress,
     takerAmount,
@@ -146,111 +49,225 @@ export const createUnsignedTxForSend = async ({
     expectedMintAddress,
     metadataAddress,
     creators,
-  }
+    // </MagicEden>
+    isExchange,
+    useFeePayer = true,
+  }) => {
+    assert(asset, 'asset is required')
+    assert(walletAccount, 'walletAccount is required')
+
+    let tokenParams = Object.create(null)
+
+    const baseAsset = asset.baseAsset
+    const baseAssetName = baseAsset.name
+
+    const feeData =
+      providedFeeData ?? (await assetClientInterface.getFeeConfig({ assetName: baseAssetName }))
+
+    const fromAddress =
+      providedFromAddress ??
+      (await assetClientInterface.getReceiveAddress({
+        assetName: baseAssetName,
+        walletAccount,
+      }))
+
+    if (nft) {
+      const [, nftAddress] = nft.id.split(':')
+      customMintAddress = nftAddress
+      tokenStandard = nft.tokenStandard
+      method = tokenStandard === 4 ? 'metaplexTransfer' : undefined
+      amount = asset.currency.baseUnit(1)
+    }
 
-  const unsignedTx = createUnsignedTx({
-    asset,
-    from: fromAddress,
-    to: toAddress,
-    amount,
-    recentBlockhash,
-    reference,
-    memo,
-    useFeePayer,
-    ...tokenParams,
-    ...stakingParams,
-    ...magicEdenParams,
-  })
-
-  const resolveUnitConsumed = async () => {
-    // this avoids unnecessary simulations. Also the simulation fails with InsufficientFundsForRent when sending all.
-    if (asset.name === asset.baseAsset.name && amount && !nft && !method) {
-      return 150 + CU_FOR_COMPUTE_BUDGET_INSTRUCTIONS
+    const isToken = asset.name !== asset.baseAsset.name
+
+    // Check if receiver has address active when sending tokens.
+    if (isToken) {
+      // check address mint is the same
+      const targetMint = await api.getAddressMint(toAddress) // null if it's a SOL address
+      if (targetMint && targetMint !== asset.mintAddress) {
+        const err = new Error('Wrong Destination Wallet')
+        err.mintAddressMismatch = true
+        throw err
+      }
+    } else {
+      // sending SOL
+      const addressType = await api.getAddressType(toAddress)
+      if (addressType === 'token') {
+        const err = new Error('Destination Wallet is a Token address')
+        err.wrongAddressType = true
+        throw err
+      }
     }
 
-    const transactionForFeeEstimation = await maybeAddFeePayer({
-      unsignedTx,
-      feePayerApiUrl,
-      assetName: asset.baseAsset.name,
-    })
-    const message = transactionForFeeEstimation.txMeta.usedFeePayer
-      ? deserializeTransaction(transactionForFeeEstimation.txData.transactionBuffer).message
-      : prepareForSigning(transactionForFeeEstimation).message
+    if (isToken || customMintAddress) {
+      const tokenMintAddress = customMintAddress || asset.mintAddress
+      const tokenProgramPublicKey =
+        (await api.getAddressType(tokenMintAddress)) === 'token-2022'
+          ? TOKEN_2022_PROGRAM_ID
+          : TOKEN_PROGRAM_ID
+
+      const tokenProgram = tokenProgramPublicKey.toBase58()
+      const tokenAddress = findAssociatedTokenAddress(toAddress, tokenMintAddress, tokenProgram)
+
+      const changedOwnership = await api.ataOwnershipChangedCached(toAddress, tokenAddress)
+      if (changedOwnership) {
+        const err = new Error('Destination ATA changed ownership')
+        err.ownershipChanged = true
+        throw err
+      }
 
-    const { unitsConsumed, err } = await api.simulateUnsignedTransaction({
-      message,
+      const [destinationAddressType, isAssociatedTokenAccountActive, fromTokenAccountAddresses] =
+        await Promise.all([
+          api.getAddressType(toAddress),
+          api.isAssociatedTokenAccountActive(tokenAddress),
+          api.getTokenAccountsByOwner(fromAddress),
+        ])
+
+      const fromTokenAddresses = fromTokenAccountAddresses.filter(
+        ({ mintAddress }) => mintAddress === tokenMintAddress
+      )
+
+      tokenParams = {
+        tokenMintAddress,
+        destinationAddressType,
+        isAssociatedTokenAccountActive,
+        fromTokenAddresses,
+        tokenStandard,
+        tokenProgram,
+      }
+    }
+
+    const stakingParams = {
+      method,
+      stakeAddresses,
+      accounts,
+      seed,
+      pool,
+    }
+
+    const recentBlockhash = await api.getRecentBlockHash()
+
+    const magicEdenParams = {
+      method,
+      initializerAddress,
+      initializerDepositTokenAddress,
+      takerAmount,
+      escrowAddress,
+      escrowBump,
+      pdaAddress,
+      takerAddress,
+      expectedTakerAmount,
+      expectedMintAddress,
+      metadataAddress,
+      creators,
+    }
+
+    const unsignedTx = createUnsignedTx({
+      asset,
+      from: fromAddress,
+      to: toAddress,
+      amount,
+      recentBlockhash,
+      reference,
+      memo,
+      // Effective: platform enable AND per-tx intent
+      useFeePayer,
+      ...tokenParams,
+      ...stakingParams,
+      ...magicEdenParams,
     })
-    if (err) {
-      // we use this method to compute unitsConsumed
-      // we can throw error here and fallback to ~0.025 SOL or estimate fee based on the method
-      console.log('error getting units consumed:', err)
-      if (!unitsConsumed) throw new Error(err)
+
+    const resolveUnitConsumed = async () => {
+      // this avoids unnecessary simulations. Also the simulation fails with InsufficientFundsForRent when sending all.
+      if (asset.name === asset.baseAsset.name && amount && !nft && !method) {
+        return 150 + CU_FOR_COMPUTE_BUDGET_INSTRUCTIONS
+      }
+
+      const transactionForFeeEstimation = await maybeAddFeePayerWithAuth({
+        unsignedTx,
+        feePayerClient,
+        enableFeePayer: feeData.enableFeePayer,
+      })
+      const message = transactionForFeeEstimation.txMeta.usedFeePayer
+        ? deserializeTransaction(transactionForFeeEstimation.txData.transactionBuffer).message
+        : prepareForSigning(transactionForFeeEstimation).message
+
+      const { unitsConsumed, err } = await api.simulateUnsignedTransaction({
+        message,
+      })
+      if (err) {
+        // we use this method to compute unitsConsumed
+        // we can throw error here and fallback to ~0.025 SOL or estimate fee based on the method
+        console.log('error getting units consumed:', err)
+        if (!unitsConsumed) throw new Error(err)
+      }
+
+      return unitsConsumed + CU_FOR_COMPUTE_BUDGET_INSTRUCTIONS
     }
 
-    return unitsConsumed + CU_FOR_COMPUTE_BUDGET_INSTRUCTIONS
-  }
+    const priorityFee = feeData.priorityFee
+    let computeUnits
+    if (priorityFee) {
+      const unitsConsumed = await resolveUnitConsumed()
+      computeUnits = unitsConsumed * feeData.computeUnitsMultiplier
+      unsignedTx.txData.priorityFee = priorityFee
+      unsignedTx.txData.computeUnits = computeUnits
+    }
 
-  const priorityFee = feeData.priorityFee
-  let computeUnits
-  if (priorityFee) {
-    const unitsConsumed = await resolveUnitConsumed()
-    computeUnits = unitsConsumed * feeData.computeUnitsMultiplier
-    unsignedTx.txData.priorityFee = priorityFee
-    unsignedTx.txData.computeUnits = computeUnits
-  }
+    unsignedTx.txMeta.stakingParams = stakingParams
 
-  unsignedTx.txMeta.stakingParams = stakingParams
+    // we add token account creation fee
+    let tokenCreationFee = asset.feeAsset.currency.ZERO
+    if (isToken && (!unsignedTx.txData.isAssociatedTokenAccountActive || isExchange)) {
+      tokenCreationFee = asset.feeAsset.currency.baseUnit(
+        await api.getMinimumBalanceForRentExemption(TOKEN_ACCOUNT_CREATION_SIZE)
+      )
+    }
 
-  // we add token account creation fee
-  let tokenCreationFee = asset.feeAsset.currency.ZERO
-  if (isToken && (!unsignedTx.txData.isAssociatedTokenAccountActive || isExchange)) {
-    tokenCreationFee = asset.feeAsset.currency.baseUnit(
-      await api.getMinimumBalanceForRentExemption(TOKEN_ACCOUNT_CREATION_SIZE)
-    )
-  }
+    const fee = feeData.baseFee
+      .add(
+        asset.feeAsset.currency
+          .baseUnit(unsignedTx.txData.priorityFee ?? 0)
+          .mul(unsignedTx.txData.computeUnits ?? 0)
+          .div(1_000_000) // micro lamports to lamports
+      )
+      .add(tokenCreationFee)
+
+    // serialization friendlier
+    unsignedTx.txMeta.fee = fee.toBaseNumber()
+
+    const rentExemptValue = await api.getRentExemptionMinAmount(toAddress)
+    const rentExemptAmount = baseAsset.currency.baseUnit(rentExemptValue)
+
+    // differentiate between SOL and Solana token
+    let isEnoughForRent = false
+    if (asset.name === baseAsset.name && !nft) {
+      // sending SOL
+      isEnoughForRent = amount.gte(rentExemptAmount)
+    } else {
+      // sending token/nft
+      const baseAssetBalance = await api.getBalance(fromAddress)
+      isEnoughForRent = baseAsset.currency
+        .baseUnit(baseAssetBalance)
+        .sub(fee || asset.feeAsset.currency.ZERO)
+        .gte(rentExemptAmount)
+    }
 
-  const fee = feeData.baseFee
-    .add(
-      asset.feeAsset.currency
-        .baseUnit(unsignedTx.txData.priorityFee ?? 0)
-        .mul(unsignedTx.txData.computeUnits ?? 0)
-        .div(1_000_000) // micro lamports to lamports
-    )
-    .add(tokenCreationFee)
-
-  // serialization friendlier
-  unsignedTx.txMeta.fee = fee.toBaseNumber()
-
-  const rentExemptValue = await api.getRentExemptionMinAmount(toAddress)
-  const rentExemptAmount = baseAsset.currency.baseUnit(rentExemptValue)
-
-  // differentiate between SOL and Solana token
-  let isEnoughForRent = false
-  if (asset.name === baseAsset.name && !nft) {
-    // sending SOL
-    isEnoughForRent = amount.gte(rentExemptAmount)
-  } else {
-    // sending token/nft
-    const baseAssetBalance = await api.getBalance(fromAddress)
-    isEnoughForRent = baseAsset.currency
-      .baseUnit(baseAssetBalance)
-      .sub(fee || asset.feeAsset.currency.ZERO)
-      .gte(rentExemptAmount)
-  }
+    const tx = await maybeAddFeePayerWithAuth({
+      unsignedTx,
+      feePayerClient,
+      enableFeePayer: feeData.enableFeePayer,
+    })
 
-  const tx = await maybeAddFeePayer({
-    unsignedTx,
-    feePayerApiUrl,
-    assetName: asset.baseAsset.name,
-  })
+    if (!isEnoughForRent && !tx.txMeta.usedFeePayer) {
+      const err = new Error('Sending SOL amount is too low to cover the rent exemption fee.')
+      err.rentExemptAmount = true
+      throw err
+    }
 
-  if (!isEnoughForRent && !tx.txMeta.usedFeePayer) {
-    const err = new Error('Sending SOL amount is too low to cover the rent exemption fee.')
-    err.rentExemptAmount = true
-    throw err
+    return tx
   }
-
-  return tx
 }
 
 export const extractTxLogData = async ({ unsignedTx, api }) => {
@@ -274,39 +291,3 @@ export const extractTxLogData = async ({ unsignedTx, api }) => {
     fee: unsignedTx.txMeta.fee,
   }
 }
-
-export const maybeAddFeePayer = async ({ unsignedTx, feePayerApiUrl, assetName }) => {
-  let unsignedTxWithFeePayer = unsignedTx
-  let newFeePayer = false
-  if (feePayerApiUrl && unsignedTx.txMeta.useFeePayer !== false) {
-    try {
-      const unsignedTxVersionedTransaction = prepareForSigning(unsignedTx)
-
-      const { transaction: newTransactionString } = await fetchival(
-        new URL(feePayerApiUrl).toString()
-      ).post({
-        assetName,
-        transaction: Buffer.from(unsignedTxVersionedTransaction.serialize()).toString('base64'),
-      })
-
-      const newTransactionBuffer = Buffer.from(newTransactionString, 'base64')
-      const newTransaction = deserializeTransaction(newTransactionBuffer)
-
-      verifyOnlyFeePayerChanged(unsignedTxVersionedTransaction, newTransaction)
-
-      unsignedTxWithFeePayer = {
-        txData: {
-          transactionBuffer: newTransactionBuffer,
-        },
-        txMeta: unsignedTx.txMeta,
-      }
-      newFeePayer = true
-    } catch (err) {
-      console.log('error adding a new fee payer, sending original transaction', err)
-    }
-  }
-
-  unsignedTxWithFeePayer.txMeta.usedFeePayer = newFeePayer
-
-  return unsignedTxWithFeePayer
-}

package/src/fee-payer.js

@@ -0,0 +1,174 @@
+import { createClient as createAuthClient } from '@exodus/auth-client-base'
+import { signAttached } from '@exodus/crypto/ed25519'
+import { fetchival } from '@exodus/fetch'
+import {
+  deserializeTransaction,
+  prepareForSigning,
+  verifyOnlyFeePayerChanged,
+} from '@exodus/solana-lib'
+import assert from 'minimalistic-assert'
+import ms from 'ms'
+
+import { getAuthKeyPair } from './auth.js'
+
+/**
+ * Creates a fee payer client that can sponsor Solana transactions
+ *
+ * This factory creates a client configured to interact with fee payer services
+ * that can sponsor transaction fees on behalf of users. It supports both:
+ * - Base services: Simple fee sponsorship without authentication
+ * - Authenticated services: Require BinAuth and transaction eligibility checks
+ *
+ * @param {Object} config - Configuration for the fee payer client
+ * @param {string} config.assetName - The asset from the transaction
+ * @param {string} config.serviceUrl - The fee payer service URL
+ * @param {boolean} [config.requireAuthentication=false] - Whether the service requires authentication
+ * @param {Function} [config.isEligibleForSponsorship] - Eligibility checker function (defaults to allowing all)
+ */
+export const feePayerClientFactory = ({
+  assetName = 'solana', // baseAsset name
+  feePayerApiUrl,
+  requireAuthentication = false,
+  authKeyPair: customAuthKeyPair = null,
+} = {}) => {
+  assert(feePayerApiUrl, 'feePayerApiUrl is required')
+
+  // Create auth client if authentication is required
+  let authClient = null
+  if (requireAuthentication) {
+    const authKeyPair = customAuthKeyPair || getAuthKeyPair({ assetName, apiUrl: feePayerApiUrl })
+    const privateKey = Buffer.from(authKeyPair.privateKey, 'hex').subarray(0, 32)
+
+    const keyPair = {
+      publicKey: authKeyPair.publicKey,
+      sign: async (message) => signAttached({ message, privateKey, format: 'buffer' }),
+    }
+
+    authClient = createAuthClient({
+      config: {
+        keyPair,
+        baseUrl: feePayerApiUrl,
+        authTokenUrl: `${feePayerApiUrl}/auth/token`,
+        authChallengeUrl: `${feePayerApiUrl}/auth/challenge`,
+      },
+    })
+  }
+
+  const makeSponsorRequest = async ({ encodedTransaction }) => {
+    const headers = { Accept: 'application/json', 'Content-Type': 'application/json' }
+
+    if (requireAuthentication && authClient) {
+      await authClient._awaitAuthenticated()
+      if (authClient.token) {
+        headers.Authorization = `Bearer ${authClient.token}`
+      }
+    }
+
+    return fetchival(`${feePayerApiUrl}/transactions/sponsor`, {
+      mode: 'cors',
+      cache: 'no-cache',
+      timeout: ms('10s'),
+      headers,
+    }).post({
+      transaction: encodedTransaction,
+    })
+  }
+
+  /**
+   * Request transaction sponsorship
+   */
+  const sponsorTransaction = async ({ transaction }) => {
+    const encodedTransaction = Buffer.from(transaction.serialize()).toString('base64')
+
+    let response
+    try {
+      response = await makeSponsorRequest({ encodedTransaction })
+    } catch (error) {
+      if (
+        requireAuthentication &&
+        (error.response?.status === 401 || error.response?.status === 403)
+      ) {
+        console.warn('Authentication failed, retrying...')
+        if (authClient) {
+          await authClient._authenticate()
+        }
+
+        response = await makeSponsorRequest({ encodedTransaction })
+      } else {
+        throw error
+      }
+    }
+
+    if (!response.transaction) {
+      throw new Error(response.error || 'Sponsorship request failed')
+    }
+
+    const usedAuthentication = requireAuthentication
+    if (usedAuthentication) {
+      console.log(
+        `Transaction sponsored (authenticated). Cost: ${response.estimatedCost || 'N/A'} lamports`
+      )
+    }
+
+    return {
+      transaction: response.transaction,
+      feePayerPublicKey: response.feePayerPublicKey,
+      estimatedCost: response.estimatedCost,
+      requestId: response.requestId,
+      usedAuthentication,
+    }
+  }
+
+  return {
+    sponsorTransaction,
+    requireAuthentication,
+  }
+}
+
+/**
+ * Attempts to add a fee payer to an unsigned transaction
+ *
+ * @param {Object} params
+ * @param {Object} params.unsignedTx - The unsigned transaction
+ * @param {Object} params.feePayerClient - The fee payer client instance
+ */
+export const maybeAddFeePayerWithAuth = async ({ unsignedTx, feePayerClient, enableFeePayer }) => {
+  let unsignedTxWithFeePayer = unsignedTx
+
+  // Skip if no client or explicitly disabled
+  if (!feePayerClient || !enableFeePayer || !unsignedTx.txMeta.useFeePayer) {
+    unsignedTxWithFeePayer.txMeta.usedFeePayer = false
+    return unsignedTxWithFeePayer
+  }
+
+  const unsignedTxVersionedTransaction = prepareForSigning(unsignedTx)
+
+  try {
+    const result = await feePayerClient.sponsorTransaction({
+      transaction: unsignedTxVersionedTransaction,
+    })
+
+    const newTransactionBuffer = Buffer.from(result.transaction, 'base64')
+    const sponsoredTransaction = deserializeTransaction(newTransactionBuffer)
+    verifyOnlyFeePayerChanged(unsignedTxVersionedTransaction, sponsoredTransaction)
+
+    unsignedTxWithFeePayer = {
+      txData: {
+        transactionBuffer: newTransactionBuffer,
+      },
+      txMeta: {
+        ...unsignedTx.txMeta,
+        feePayerPublicKey: result.feePayerPublicKey,
+        sponsorshipRequestId: result.requestId,
+        estimatedSponsorCost: result.estimatedCost,
+        usedAuthentication: result.usedAuthentication || false,
+        usedFeePayer: true,
+      },
+    }
+  } catch (err) {
+    console.log('Fee payer service error, sending original transaction:', err.message)
+    unsignedTxWithFeePayer.txMeta.usedFeePayer = false
+  }
+
+  return unsignedTxWithFeePayer
+}

package/src/get-fees.js

@@ -1,14 +1,12 @@
 /* eslint-disable @exodus/mutable/no-param-reassign-prop-only */
 import assert from 'minimalistic-assert'
 
-import { createUnsignedTxForSend } from './create-unsigned-tx-for-send.js'
-
 const DEFAULT_SAFE_FEE = '0.0025' // SOL (enough for rent exemption)
 
-export const getFeeAsyncFactory = ({ api }) => {
-  assert(api, 'api is required')
+export const getFeeAsyncFactory = ({ createTx }) => {
   return async ({
     asset,
+    walletAccount,
     method,
     feeData,
     unsignedTx: providedUnsignedTx,
@@ -21,12 +19,10 @@ export const getFeeAsyncFactory = ({ api }) => {
 
     if (providedUnsignedTx) {
       unsignedTx = providedUnsignedTx
-      fee = asset.feeAsset.currency.baseUnit(unsignedTx.txMeta.fee)
     } else {
       if (['delegate', 'undelegate', 'withdraw'].includes(method)) {
         assert(stakingInfo, 'stakingInfo is required for staking txs')
         assert(rest.fromAddress, 'fromAddress is required for staking txs')
-        assert(feeData, 'feeData is required for staking txs')
 
         // staking params
         rest.method = method
@@ -53,25 +49,29 @@ export const getFeeAsyncFactory = ({ api }) => {
       }
 
       try {
-        unsignedTx = await createUnsignedTxForSend({
+        unsignedTx = await createTx({
           asset,
+          walletAccount,
           feeData,
-          api,
           amount: amount ?? asset.currency.baseUnit(1),
           toAddress: toAddress ?? rest.fromAddress,
-          useFeePayer: false,
           ...rest,
         })
-
-        fee = asset.feeAsset.currency.baseUnit(unsignedTx.txMeta.fee)
       } catch (err) {
         console.log('error computing right SOL fee:', err)
         // simulating a tx will fail if the user has not enough balance
         // we fallback to a default fee (but we could leave some dust)
-        fee = asset.feeAsset.currency.defaultUnit(DEFAULT_SAFE_FEE)
       }
     }
 
+    if (unsignedTx?.txMeta?.fee) {
+      fee = unsignedTx.txMeta.usedFeePayer
+        ? asset.feeAsset.currency.ZERO
+        : asset.feeAsset.currency.baseUnit(unsignedTx.txMeta.fee)
+    } else {
+      fee = asset.feeAsset.currency.defaultUnit(DEFAULT_SAFE_FEE)
+    }
+
     return { fee, unsignedTx }
   }
 }

package/src/index.js

@@ -18,7 +18,8 @@ export { createAndBroadcastTXFactory } from './tx-send.js'
 export { getBalancesFactory } from './get-balances.js'
 export { getFeeAsyncFactory } from './get-fees.js'
 export { stakingProviderClientFactory } from './staking-provider-client.js'
-export { createUnsignedTxForSend } from './create-unsigned-tx-for-send.js'
+export { createTxFactory } from './create-unsigned-tx-for-send.js'
+export { feePayerClientFactory } from './fee-payer.js'
 
 // These are not the same asset objects as the wallet creates, so they should never be returned to the wallet.
 // Initially this may be violated by the Solana code until the first monitor tick updates assets with setTokens()

package/src/tx-send.js

@@ -1,13 +1,13 @@
 import assert from 'minimalistic-assert'
 
-import { createUnsignedTxForSend, extractTxLogData } from './create-unsigned-tx-for-send.js'
+import { extractTxLogData } from './create-unsigned-tx-for-send.js'
 
-export const createAndBroadcastTXFactory =
-  ({ api, assetClientInterface, feePayerApiUrl }) =>
-  async ({ asset, walletAccount, unsignedTx: predefinedUnsignedTx, ...legacyParams }) => {
-    const assetName = asset.name
-    assert(assetClientInterface, `assetClientInterface must be supplied in sendTx for ${assetName}`)
+export const createAndBroadcastTXFactory = ({ api, assetClientInterface }) => {
+  assert(assetClientInterface, 'assetClientInterface is required')
+  assert(api, 'api is required')
 
+  return async ({ asset, walletAccount, unsignedTx: predefinedUnsignedTx, ...legacyParams }) => {
+    const assetName = asset.name
     const baseAsset = asset.baseAsset
 
     const resolveTxs = async () => {
@@ -15,21 +15,11 @@ export const createAndBroadcastTXFactory =
         return predefinedUnsignedTx
       }
 
-      // handle legacy mode
-      const feeData = await assetClientInterface.getFeeData({ assetName })
-      const fromAddress = await assetClientInterface.getReceiveAddress({
-        assetName: baseAsset.name,
-        walletAccount,
-      })
-
-      return createUnsignedTxForSend({
-        api,
+      return baseAsset.api.createTx({
         asset,
-        feeData,
-        fromAddress,
-        feePayerApiUrl,
         amount: legacyParams.amount,
         toAddress: legacyParams.address,
+        ...legacyParams,
         ...legacyParams.options,
       })
     }
@@ -136,3 +126,4 @@ export const createAndBroadcastTXFactory =
 
     return { txId }
   }
+}