Integrator Fees

import { Bps } from '@1inch/cross-chain-sdk'

// 1% fee = 100 basis points
const fee = new Bps(100n)

// 0.5% fee = 50 basis points
const fee = new Bps(50n)

// 2.5% fee = 250 basis points
const fee = new Bps(250n)

import {
  SDK,
  PrivateKeyProviderConnector,
  NetworkEnum,
  PresetEnum,
  HashLock,
  Bps,
  EvmAddress
} from '@1inch/cross-chain-sdk'
import Web3 from 'web3'
import { randomBytes } from 'node:crypto'

const privateKey = '0x...'
const rpc = 'https://polygon-rpc.com'
const authKey = 'your-auth-key'

const web3 = new Web3(rpc)
const walletAddress = web3.eth.accounts.privateKeyToAccount(privateKey).address

const sdk = new SDK({
  url: 'https://api.1inch.com/fusion-plus',
  authKey,
  blockchainProvider: new PrivateKeyProviderConnector(privateKey, web3)
})

async function swapWithFee() {
  // Define integrator fee (1%)
  const integratorFeeReceiver = '0xYourFeeReceiverAddress'
  
  const quote = await sdk.getQuote({
    amount: '10000000',
    srcChainId: NetworkEnum.POLYGON,
    dstChainId: NetworkEnum.BINANCE,
    srcTokenAddress: '0xc2132d05d31c914a87c6611c10748aeb04b58e8f',
    dstTokenAddress: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
    walletAddress,
    enableEstimate: true,
    integratorFee: {
      receiver: EvmAddress.fromString(integratorFeeReceiver),
      value: new Bps(100n) // 1% fee
    }
  })

  console.log('Fee details:', {
    integratorFee: quote.integratorFee,
    resolverFee: quote.resolverFee
  })

  const preset = PresetEnum.fast
  const secrets = Array.from({
    length: quote.presets[preset].secretsCount
  }).map(() => '0x' + randomBytes(32).toString('hex'))

  const hashLock = secrets.length === 1
    ? HashLock.forSingleFill(secrets[0])
    : HashLock.forMultipleFills(HashLock.getMerkleLeaves(secrets))

  const secretHashes = secrets.map((s) => HashLock.hashSecret(s))

  const { hash, quoteId, order } = await sdk.createOrder(quote, {
    walletAddress,
    hashLock,
    preset,
    source: 'my-integration',
    secretHashes
  })

  await sdk.submitOrder(quote.srcChainId, order, quoteId, secretHashes)
  
  console.log('Order submitted with integrator fee:', hash)
}

swapWithFee()

type IntegratorFeeResponse = {
  receiver: EvmAddress  // Your fee receiver address
  value: Bps            // Fee in basis points (100 = 1%)
  share: Bps            // Your share (rest goes to protocol)
}

type ResolverFeeParams = {
  receiver: EvmAddress      // Resolver fee receiver
  bps: Bps                  // Resolver fee in basis points
  whitelistDiscount: Bps    // Discount for whitelisted integrators
}

// Example swap: 100 USDT → BNB with 1% integrator fee
const swapAmount = 100 // USDT
const integratorFeeBps = 100n // 1%

// Fee calculation
const feeAmount = (swapAmount * Number(integratorFeeBps)) / 10000
console.log('Fee amount:', feeAmount) // 1 USDT equivalent in BNB
console.log('User receives:', swapAmount - feeAmount) // 99 USDT equivalent in BNB

// Different fee percentages
const fees = [
  { bps: 50n, percent: '0.5%' },
  { bps: 100n, percent: '1%' },
  { bps: 250n, percent: '2.5%' },
  { bps: 500n, percent: '5%' }
]

fees.forEach(({ bps, percent }) => {
  const fee = new Bps(bps)
  console.log(`${percent} = ${bps} bps = new Bps(${bps}n)`)
})

function validateIntegratorFee(
  receiver: string,
  bps: bigint
): { valid: boolean; error?: string } {
  // Validate receiver address
  if (!receiver.match(/^0x[a-fA-F0-9]{40}$/)) {
    return { valid: false, error: 'Invalid receiver address format' }
  }

  // Validate fee range (0-10% = 0-1000 bps)
  if (bps < 0n || bps > 1000n) {
    return { valid: false, error: 'Fee must be between 0 and 10%' }
  }

  return { valid: true }
}

const validation = validateIntegratorFee(integratorFeeReceiver, 100n)
if (!validation.valid) {
  throw new Error(validation.error)
}

import { EvmAddress } from '@1inch/cross-chain-sdk'

async function trackFees(orders: string[]) {
  let totalFeesCollected = 0n

  for (const orderHash of orders) {
    const status = await sdk.getOrderStatus(orderHash)
    
    if (status.status === OrderStatus.Executed) {
      // Fee info is in the order details
      console.log('Order executed:', orderHash)
      console.log('Fee collected:', status.integratorFee)
      // Add to analytics/database
    }
  }
}