Skip to main content

Overview

The 1inch Fusion SDK provides multiple methods for creating and placing orders. This guide covers the complete workflow from getting a quote to submitting an order.

Order Flow

1

Get a Quote

Request quote information for your swap parameters
2

Create Order

Build the order structure with your parameters
3

Submit Order

Submit the signed order to the 1inch Fusion network
4

Monitor Status

Track the order status until it’s filled or expires

Method 1: Using placeOrder()

The placeOrder() method is the simplest way to create and submit an order. It handles the entire process in one call.

Basic Example

import { FusionSDK, NetworkEnum, PrivateKeyProviderConnector } from '@1inch/fusion-sdk'
import { Address, Bps } from '@1inch/limit-order-sdk'

const makerPrivateKey = '0x123....'
const makerAddress = '0x123....'

const blockchainProvider = new PrivateKeyProviderConnector(
    makerPrivateKey,
    web3Provider
)

const sdk = new FusionSDK({
    url: 'https://api.1inch.dev/fusion',
    network: NetworkEnum.ETHEREUM,
    blockchainProvider,
    authKey: 'YOUR_DEV_PORTAL_API_TOKEN'
})

const orderInfo = await sdk.placeOrder({
    fromTokenAddress: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2', // WETH
    toTokenAddress: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', // USDC
    amount: '50000000000000000', // 0.05 ETH
    walletAddress: makerAddress
})

console.log('Order placed:', orderInfo.orderHash)

With Optional Parameters

const orderInfo = await sdk.placeOrder({
    fromTokenAddress: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
    toTokenAddress: '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48',
    amount: '50000000000000000',
    walletAddress: makerAddress,
    // Optional: specify custom receiver
    receiver: '0x...',
    // Optional: choose execution speed preset
    preset: PresetEnum.fast, // 'fast' | 'medium' | 'slow'
    // Optional: custom nonce for batch cancellations
    nonce: 1n,
    // Optional: add integrator fee
    integratorFee: {
        receiver: new Address('0x...'),
        value: new Bps(100n) // 1% = 100 bps
    }
})

Method 2: Manual Order Creation

For more control, you can manually create and submit orders using separate method calls.

Step-by-Step Process

import {
    FusionSDK,
    NetworkEnum,
    OrderStatus,
    PrivateKeyProviderConnector,
    Web3Like
} from '@1inch/fusion-sdk'
import { computeAddress, formatUnits, JsonRpcProvider } from 'ethers'

const PRIVATE_KEY = 'YOUR_PRIVATE_KEY'
const NODE_URL = 'YOUR_WEB3_NODE_URL'
const DEV_PORTAL_API_TOKEN = 'YOUR_DEV_PORTAL_API_TOKEN'

const ethersRpcProvider = new JsonRpcProvider(NODE_URL)

const ethersProviderConnector: Web3Like = {
    eth: {
        call(transactionConfig): Promise<string> {
            return ethersRpcProvider.call(transactionConfig)
        }
    },
    extend(): void {}
}

const connector = new PrivateKeyProviderConnector(
    PRIVATE_KEY,
    ethersProviderConnector
)

const sdk = new FusionSDK({
    url: 'https://api.1inch.dev/fusion',
    network: NetworkEnum.BINANCE,
    blockchainProvider: connector,
    authKey: DEV_PORTAL_API_TOKEN
})

async function main() {
    // Define swap parameters
    const params = {
        fromTokenAddress: '0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d', // USDC
        toTokenAddress: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',  // BNB
        amount: '10000000000000000000', // 10 USDC
        walletAddress: computeAddress(PRIVATE_KEY),
        source: 'sdk-test'
    }

    // Step 1: Get quote
    const quote = await sdk.getQuote(params)

    const dstTokenDecimals = 18
    console.log(
        'Auction start amount',
        formatUnits(
            quote.presets[quote.recommendedPreset].auctionStartAmount,
            dstTokenDecimals
        )
    )
    console.log(
        'Auction end amount',
        formatUnits(
            quote.presets[quote.recommendedPreset].auctionEndAmount,
            dstTokenDecimals
        )
    )

    // Step 2: Create order
    const preparedOrder = await sdk.createOrder(params)

    // Step 3: Submit order
    const info = await sdk.submitOrder(
        preparedOrder.order,
        preparedOrder.quoteId
    )

    console.log('OrderHash', info.orderHash)

    // Step 4: Monitor order status
    const start = Date.now()

    while (true) {
        try {
            const data = await sdk.getOrderStatus(info.orderHash)

            if (data.status === OrderStatus.Filled) {
                console.log('fills', data.fills)
                break
            }

            if (data.status === OrderStatus.Expired) {
                console.log('Order Expired')
                break
            }
            
            if (data.status === OrderStatus.Cancelled) {
                console.log('Order Cancelled')
                break
            }
        } catch (e) {
            console.log(e)
        }
    }

    console.log('Order executed for', (Date.now() - start) / 1000, 'sec')
}

main()

Order Parameters

Required Parameters

  • fromTokenAddress: Address of the token you’re selling
  • toTokenAddress: Address of the token you’re buying
  • amount: Amount to sell (in wei/smallest unit)
  • walletAddress: Your wallet address (order maker)

Optional Parameters

  • receiver: Address to receive the output tokens (defaults to walletAddress)
  • preset: Execution speed preset (fast, medium, slow)
  • nonce: Custom nonce for batch order cancellations
  • permit: EIP-2612 permit call data for gasless approvals
  • integratorFee: Fee configuration for integrators
  • source: String identifier for tracking order sources

Execution Presets

Presets control the auction duration and price curve for your order.
  • fast: Quick execution with smaller price improvement
  • medium: Balanced execution time and price (recommended)
  • slow: Longer auction for maximum price improvement

Best Practices

Always monitor order status after submission to handle expired or failed orders appropriately.
  1. Error Handling: Wrap order submission in try-catch blocks
  2. Status Monitoring: Poll order status regularly or use WebSocket integration
  3. Allowances: Ensure token approvals are set before placing orders
  4. Gas Estimation: Consider network conditions when choosing presets
  5. Testing: Test with small amounts first on testnets

Common Issues

Insufficient Allowance

If you haven’t approved the Fusion contract to spend your tokens:
// First, approve the token
import { getContractAddress } from '@1inch/fusion-sdk'

const fusionContract = getContractAddress(NetworkEnum.ETHEREUM)
// Use your web3 library to approve the token for fusionContract

Invalid Order Parameters

Ensure amounts are in the smallest token unit (wei) and addresses are valid checksummed addresses.

Next Steps

Build docs developers (and LLMs) love