Manage External Wallet Priority

Overview

Manage the priority order of registered external wallets. Priority determines the order in which wallets are evaluated for funding transactions. When a transaction is initiated, the platform checks wallets in priority order (1, 2, 3…). The first wallet with sufficient balance and allowance to cover the entire transaction cost is used. Only one wallet funds each transaction - multi-funding is not supported. Lower priority numbers are checked first (priority 1 before priority 2). Use Cases:

Control wallet selection order for transactions
Optimize for network fees across chains
Ensure transactions succeed with fallback wallets
Route withdrawals to specific wallets

GET - Retrieve External Wallet Priority

Get the current priority order of all registered external wallets. Wallets are evaluated in this order for transactions, with the first wallet having sufficient balance to cover the entire transaction cost being used. Only one wallet is used per transaction.

Authentication

string

required

Your public API client key

string

required

Bearer token for authentication

Response

number

Wallet priority identifier

string

Blockchain wallet address

string

Currency code (e.g., “usdc”, “usdt”)

string

Blockchain network (e.g., “linea”, “ethereum”, “solana”)

number

Current priority value (lower = higher priority)

[
  {
    "id": 551,
    "address": "0x3a11a86cf218c448be519728cd3ac5c741fb3424",
    "currency": "usdc",
    "network": "linea",
    "priority": 1
  },
  {
    "id": 552,
    "address": "0x7b22c1e6f8a4d92b5c3d8e9f1a2b3c4d5e6f7890",
    "currency": "usdt",
    "network": "ethereum",
    "priority": 2
  },
  {
    "id": 553,
    "address": "DYw8jCTfwHNRJhhmFcbXvVDTqWMEVFBX6ZKUmG5CNSKK",
    "currency": "usdc",
    "network": "solana",
    "priority": 3
  }
]

curl -X GET "https://dev.api.baanx.com/v1/wallet/external/priority" \
  -H "x-client-key: YOUR_CLIENT_KEY" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"

import requests

url = "https://dev.api.baanx.com/v1/wallet/external/priority"
headers = {
    "x-client-key": "YOUR_CLIENT_KEY",
    "Authorization": "Bearer YOUR_ACCESS_TOKEN"
}

response = requests.get(url, headers=headers)
priorities = response.json()

print("Withdrawal Priority Order:")
for wallet in sorted(priorities, key=lambda w: w['priority']):
    print(f"{wallet['priority']}. {wallet['currency'].upper()} on {wallet['network']} - {wallet['address'][:10]}...")

interface WalletPriority {
  id: number;
  address: string;
  currency: string;
  network: string;
  priority: number;
}

async function getExternalWalletPriority(): Promise<WalletPriority[]> {
  const response = await fetch(
    'https://dev.api.baanx.com/v1/wallet/external/priority',
    {
      headers: {
        'x-client-key': 'YOUR_CLIENT_KEY',
        'Authorization': 'Bearer YOUR_ACCESS_TOKEN'
      }
    }
  );

  return await response.json();
}

const priorities = await getExternalWalletPriority();
const ordered = priorities.sort((a, b) => a.priority - b.priority);
console.log('Withdrawal order:', ordered.map(w => w.network));

PUT - Update External Wallet Priority

Update the priority order of external wallets for transaction funding. When a transaction is initiated, wallets are checked sequentially in this order until one with sufficient balance is found to fund the entire transaction. Only one wallet funds each transaction - partial funding from multiple wallets is not supported.

Request Body

array

required

Array of wallet priority updates

Show Wallet Priority Object

number

required

Wallet priority ID from GET response

number

required

New priority value (lower numbers = higher priority)

Response

boolean

Whether priority update was successful

{
  "success": true
}

{
  "message": "Not authenticated"
}

{
  "message": "Invalid priority configuration"
}

curl -X PUT "https://dev.api.baanx.com/v1/wallet/external/priority" \
  -H "x-client-key: YOUR_CLIENT_KEY" \
  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "wallets": [
      {
        "id": 552,
        "priority": 1
      },
      {
        "id": 551,
        "priority": 2
      }
    ]
  }'

import requests

url = "https://dev.api.baanx.com/v1/wallet/external/priority"
headers = {
    "x-client-key": "YOUR_CLIENT_KEY",
    "Authorization": "Bearer YOUR_ACCESS_TOKEN",
    "Content-Type": "application/json"
}

current = requests.get(url, headers=headers).json()

updated_priorities = []
for index, wallet in enumerate(current):
    updated_priorities.append({
        "id": wallet['id'],
        "priority": index + 1
    })

data = {"wallets": updated_priorities}
response = requests.put(url, headers=headers, json=data)

if response.status_code == 200:
    print("Priority updated successfully!")

async function updateExternalWalletPriority(
  priorities: Array<{ id: number; priority: number }>
): Promise<boolean> {
  const response = await fetch(
    'https://dev.api.baanx.com/v1/wallet/external/priority',
    {
      method: 'PUT',
      headers: {
        'x-client-key': 'YOUR_CLIENT_KEY',
        'Authorization': 'Bearer YOUR_ACCESS_TOKEN',
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ wallets: priorities })
    }
  );

  const result = await response.json();
  return result.success;
}

await updateExternalWalletPriority([
  { id: 552, priority: 1 },
  { id: 551, priority: 2 }
]);

Use Cases

Prioritize Low-Fee Networks

async function prioritizeByFees() {
  const wallets = await fetch('/v1/wallet/external/priority')
    .then(r => r.json());

  const feeTiers = {
    'linea': 1,
    'polygon': 2,
    'ethereum': 3
  };

  const reordered = wallets
    .sort((a, b) => (feeTiers[a.network] || 99) - (feeTiers[b.network] || 99))
    .map((w, index) => ({
      id: w.id,
      priority: index + 1
    }));

  await updateExternalWalletPriority(reordered);
  console.log('Prioritized wallets by lowest network fees');
}

Move Specific Wallet to Top

async function moveWalletToTop(targetAddress) {
  const wallets = await fetch('/v1/wallet/external/priority')
    .then(r => r.json());

  const target = wallets.find(w => w.address === targetAddress);

  if (!target) {
    throw new Error('Wallet not found');
  }

  const priorities = [
    { id: target.id, priority: 1 },
    ...wallets
      .filter(w => w.id !== target.id)
      .map((w, index) => ({ id: w.id, priority: index + 2 }))
  ];

  await updateExternalWalletPriority(priorities);
}

await moveWalletToTop('0x3a11a86cf218c448be519728cd3ac5c741fb3424');

Swap Two Wallet Priorities

async function swapPriorities(walletId1, walletId2) {
  const wallets = await fetch('/v1/wallet/external/priority')
    .then(r => r.json());

  const wallet1 = wallets.find(w => w.id === walletId1);
  const wallet2 = wallets.find(w => w.id === walletId2);

  const updates = wallets.map(w => ({
    id: w.id,
    priority:
      w.id === walletId1 ? wallet2.priority :
      w.id === walletId2 ? wallet1.priority :
      w.priority
  }));

  await updateExternalWalletPriority(updates);
}

await swapPriorities(551, 552);

Currency-Based Priority

async function prioritizeByCurrency() {
  const wallets = await fetch('/v1/wallet/external/priority')
    .then(r => r.json());

  const currencyRanking = ['usdc', 'usdt', 'dai'];

  const reordered = wallets
    .sort((a, b) => {
      const rankA = currencyRanking.indexOf(a.currency);
      const rankB = currencyRanking.indexOf(b.currency);
      return (rankA === -1 ? 999 : rankA) - (rankB === -1 ? 999 : rankB);
    })
    .map((w, index) => ({
      id: w.id,
      priority: index + 1
    }));

  await updateExternalWalletPriority(reordered);
}

Important Notes

Single-Wallet Funding: Only ONE wallet funds each transaction. The platform checks wallets in priority order and uses the first one with sufficient balance to cover the ENTIRE transaction cost. If a wallet has insufficient balance, it’s skipped entirely - partial funding from multiple wallets is NOT supported.

Update All Wallets: You must provide priority values for ALL registered external wallets. Partial updates may result in unexpected behavior.

Unique Priorities: Each wallet must have a unique priority value. Duplicate priorities will cause validation errors.

Transaction Failure: If ALL priority wallets have insufficient balance to cover the full transaction cost, the transaction will fail. Ensure at least one wallet always has adequate funds.

Priority Strategy Examples

Balanced Approach

const strategies = {
  balanced: (wallets) => {
    return wallets
      .sort((a, b) => {
        if (a.network === 'linea') return -1;
        if (b.network === 'linea') return 1;
        return a.currency.localeCompare(b.currency);
      })
      .map((w, i) => ({ id: w.id, priority: i + 1 }));
  },

  singlePreferred: (wallets, preferredAddress) => {
    const preferred = wallets.find(w => w.address === preferredAddress);
    return [
      { id: preferred.id, priority: 1 },
      ...wallets
        .filter(w => w.id !== preferred.id)
        .map((w, i) => ({ id: w.id, priority: i + 2 }))
    ];
  },

  networkFirst: (wallets, preferredNetwork) => {
    return wallets
      .sort((a, b) => {
        if (a.network === preferredNetwork && b.network !== preferredNetwork) return -1;
        if (b.network === preferredNetwork && a.network !== preferredNetwork) return 1;
        return 0;
      })
      .map((w, i) => ({ id: w.id, priority: i + 1 }));
  }
};

const wallets = await getExternalWalletPriority();
const newPriorities = strategies.balanced(wallets);
await updateExternalWalletPriority(newPriorities);

Edge Cases

Single Wallet

With only one wallet, priority is always 1:

if (wallets.length === 1) {
  console.log('Only one wallet - priority management not applicable');
}

Validation Before Update

function validatePriorityUpdate(updates) {
  const priorities = updates.map(u => u.priority);
  const ids = updates.map(u => u.id);

  if (new Set(priorities).size !== priorities.length) {
    throw new Error('Duplicate priority values not allowed');
  }

  if (new Set(ids).size !== ids.length) {
    throw new Error('Duplicate wallet IDs not allowed');
  }

  const maxPriority = Math.max(...priorities);
  if (maxPriority > updates.length) {
    console.warn('Priority gaps detected');
  }

  return true;
}

Get External Wallets - View all registered external wallets
Withdraw from Credit Wallet - Withdrawal to priority 1 external wallet (if sufficient balance)
Withdraw from Reward Wallet - Withdrawal to priority 1 external wallet (if sufficient balance)

Overview

Authentication

User

Card

Orders

Wallet

Delegation

Consent

Referral

Webhooks

Manage External Wallet Priority

Overview

GET - Retrieve External Wallet Priority

Authentication

Response

PUT - Update External Wallet Priority

Request Body

Response

Use Cases

Prioritize Low-Fee Networks

Move Specific Wallet to Top

Swap Two Wallet Priorities

Currency-Based Priority

Important Notes

Priority Strategy Examples

Balanced Approach

Edge Cases

Single Wallet

Validation Before Update

​Overview

​GET - Retrieve External Wallet Priority

​Authentication

​Response

​PUT - Update External Wallet Priority

​Request Body

​Response

​Use Cases

​Prioritize Low-Fee Networks

​Move Specific Wallet to Top

​Swap Two Wallet Priorities

​Currency-Based Priority

​Important Notes

​Priority Strategy Examples

​Balanced Approach

​Edge Cases

​Single Wallet

​Validation Before Update

​Related Endpoints

Overview

GET - Retrieve External Wallet Priority

Authentication

Response

PUT - Update External Wallet Priority

Request Body

Response

Use Cases

Prioritize Low-Fee Networks

Move Specific Wallet to Top

Swap Two Wallet Priorities

Currency-Based Priority

Important Notes

Priority Strategy Examples

Balanced Approach

Edge Cases

Single Wallet

Validation Before Update

Related Endpoints