​
Overview

Your users are earning yield on other DeFi protocols when they discover better rates on your protocol. Simple enough for them to move, right? In practice, position migration involves coordination challenges that often aren’t worth the effort for your users. Consider this scenario: your users are earning yield on another protocol and find better rates on yours. They have four options:

Multiple manual transactions

Withdraw, approve, deposit - each step requiring signatures and gas fees

Custom migration contracts

Rarely built due to development complexity, audit costs, and smart contract risk

Accept the status quo

Stay put because the migration effort outweighs the benefit

Risk manual operations at scale

For funds managing large positions, manual multi-step processes create operational risk and require careful coordination
When your users scale this across chains or more complex positions, most simply don’t migrate despite better opportunities on your protocol. For larger funds, the operational risk of manual coordination becomes a significant concern that keeps them locked in suboptimal positions elsewhere.
Biconomy Move changes this entirely. Your users can move positions from any DeFi protocols to yours with a single signature. They click once. Everything happens atomically. What required careful multi-step coordination now happens seamlessly.

​
What is Move?

Move is a feature that allows your DeFi positions to simply migrate anywhere you want, in a single operation. It solves the fundamental coordination problem that makes protocol migration so painful today.

​
Use Cases

Lending positions

Find higher yield opportunities

Borrow positions

Find cheaper borrow rates

Version migration

Moving between versions e.g. Moving between Aave V3 to Aave V4

Expiring positions

Moving your expiring Pendle position to a new one

​
How Move Works

Move makes the problems associated with migrating any DeFi position a thing of the past. Instead of managing complex multi-step processes manually, users trigger intelligent migration flows that handle all the complexity automatically.

​
Fusion Mode Integration

Works with any wallet (MetaMask, Rabby, etc.) through Biconomy’s Fusion Mode - no special wallet software required.

​
Key Capabilities

​
1. Atomic Cross-Protocol Operations

Your entire position moves in one coordinated flow: 
withdraw(entire Aave position) → approve(exact amount) → deposit(exact amount to Venus)

​
2. Runtime Amount Resolution

Instead of guessing balances, Move uses exact amounts at execution time: 
// Not this: withdraw(1.5 ETH) // Hope that's still your balance!
// But this: withdraw(runtimeBalance(aTokens)) // Exact amount including accrued interest

​
3. Gasless Execution

Optional gas sponsorship means users can migrate positions without holding ETH. Pay with the tokens you’re already moving.

​
4. Graceful Failure Handling & Atomic Execution

If any step fails, automatic cleanup ensures funds return safely to your wallet. No partial states, no stuck funds.
If you’re moving positions on a single chain — all execution is done atomically.

​
Example: AAVE to Venus Migration

This example demonstrates a complete migration from AAVE to Venus Protocol using Move’s composable orchestration:
1

Transfer Accrued Interest

const transferInterest = await nexusAccount.buildComposable({
  type: 'transferFrom',
  data: {
    recipient: nexusAccountAddress,  // Companion Account address
    sender: accountAddress,          // User's EOA
    tokenAddress: position.aTokenAddress,
    amount: runtimeERC20BalanceOf({
      targetAddress: accountAddress,
      tokenAddress: position.aTokenAddress,
      constraints: [greaterThanOrEqualTo(100n)],
    }),
    chainId,
    gasLimit: 100000n,
  },
});
2

Withdraw Entire AAVE Position

const withdrawFromAave = await nexusAccount.buildComposable({
  type: 'default',
  data: {
    to: aaveV3PoolContractAddress,
    abi: aaveV3PoolAbi,
    functionName: 'withdraw',
    args: [
      position.tokenAddress,        // Asset to withdraw
      MAX_UINT256.toFixed(),       // Amount (MAX = entire position)
      nexusAccountAddress,         // Recipient
    ],
    chainId,
    gasLimit: 100000n,
  },
});
3

Approve Venus to Spend Tokens

const approveVenus = await nexusAccount.buildComposable({
  type: 'approve',
  data: {
    tokenAddress: position.tokenAddress,
    spender: vToken.address,
    amount: runtimeERC20BalanceOf({
      targetAddress: nexusAccountAddress,
      tokenAddress: position.tokenAddress,
      constraints: [greaterThanOrEqualTo(100n)],
    }),
    chainId,
    gasLimit: 100000n,
  },
});
4

Mint vTokens on Venus

const mintVTokens = await nexusAccount.buildComposable({
  type: 'default',
  data: {
    to: vToken.address,
    abi: vBep20Abi,
    functionName: 'mintBehalf',
    args: [
      accountAddress,  // Mint on behalf of user's EOA
      runtimeERC20BalanceOf({
        targetAddress: nexusAccountAddress,
        tokenAddress: position.tokenAddress,
        constraints: [greaterThanOrEqualTo(100n)],
      }),
    ],
    chainId,
    gasLimit: 100000n,
  },
});

​
Creating the Fusion Quote

// Buffer the approval amount to account for interest accrual
const approvalAmount = buffer({
  amountMantissa: position.userATokenBalanceWithInterestsMantissa,
});

const fusionQuote = await meeClient.getFusionQuote({
  trigger: {
    chainId,
    tokenAddress: position.aTokenAddress,
    amount: position.userATokenBalanceMantissa,
    approvalAmount,  // Buffered amount
    gasLimit: 500000n,
  },
  instructions: [
    transferInterest,
    withdrawFromAave,
    approveVenus,
    mintVTokens
  ],
  sponsorship: true,  // Enable gasless execution
});

​
Key Features Demonstrated

Runtime Balance Resolution

Uses runtimeERC20BalanceOf to capture exact amounts at execution time

Atomic Execution

All operations succeed together or fail together with automatic cleanup

Buffer Strategy

Accounts for interest accrual between signing and execution

Gasless Execution

Optional gas sponsorship for seamless user experience

Fusion Mode

Works with any external wallet through Companion Account mechanism

​
Summary

Think of Move as replacing the entire manual coordination of DeFi position movements with an automated system that understands protocol dependencies, timing, and user safety.