Multi-Token Routing with DeepBook

public struct RoutingPotato<phantom FundingCoin, phantom PlatformCoin> {
    account_id: ID,
    platform_id: ID,
    amount_needed: u64,
}

import { Transaction } from '@mysten/sui/transactions';
import { buildOnboardWithSwapTx } from '@paystreamer/sdk/core';
import { createDeepBookClient, swapExactQuantity } from '@paystreamer/sdk/core/deepbook';
import { testnetCoins, testnetPools } from '@mysten/deepbook-v3';
 
const tx = new Transaction();
 
const deepbook = createDeepBookClient({
  client: suiClient,
  address: userAddress,
  network: 'testnet',
  coins: testnetCoins,
  pools: testnetPools,
});
 
buildOnboardWithSwapTx({
  tx,
  packageId: PACKAGE_ID,
  clockId: CLOCK_OBJECT_ID,
  denomination: platformCoinType, // e.g. "0x...::pusd::PUSD"
  platformId,
  tierIndex: 0,
  tierAmount,
  tierFrequencyMs,
  performSwap: () => {
    const usdcCoin = tx.object(userOwnedUsdcCoinId);
    const { outputCoin, inputChange, deepChange } = swapExactQuantity({
      deepbook,
      tx,
      poolKey: 'USDC_PUSD',
      isBaseToCoin: true, // USDC is the pool's base asset
      amount: 0, // unused when `baseCoin` is supplied — see the note below
      minOut: tierAmount,
      deepAmount: 1_000_000n,
      baseCoin: usdcCoin,
    });
 
    // process_routed_payment isn't in play here (this is the one-shot
    // onboarding flow, not the recurring one), but `deposit` doesn't
    // require an exact amount — depositing the full swap output is fine.
    // `inputChange`/`deepChange` still need consuming (Coin<T> has no
    // `drop`); refund them to the user rather than letting them vanish.
    tx.transferObjects([inputChange, deepChange], tx.pure.address(userAddress));
    return outputCoin;
  },
});

import { buildProcessRoutedPaymentTx } from '@paystreamer/sdk/core';
 
buildProcessRoutedPaymentTx({
  tx,
  packageId: PACKAGE_ID,
  registryId: REGISTRY_ID,
  clockId: CLOCK_OBJECT_ID,
  fundingCoinType: account.denomination,     // what the account actually holds
  platformCoinType: tier.denomination,        // what the platform settles in
  accountId,
  platformId,
  platformInitVersion,
  schedulerId: PAYMENT_SCHEDULER_ID,
  schedulerInitVersion,
  maxSpend, // upper bound on FundingCoin this cycle may spend — see below
  performSwap: (fundingCoin) => {
    const { outputCoin, inputChange, deepChange } = swapExactQuantity({
      deepbook, tx,
      poolKey: pool.poolKey,
      isBaseToCoin: pool.isBaseToCoin,
      amount: maxSpend, // ignored — `fundingCoin` is supplied below
      minOut: tierAmount,
      deepAmount: pool.deepAmount,
      deepCoin: tx.object(schedulerDeepCoinId),
      ...(pool.isBaseToCoin ? { baseCoin: fundingCoin } : { quoteCoin: fundingCoin }),
    });
 
    // process_routed_payment requires exactly tierAmount in PlatformCoin.
    const [exactPlatformCoin] = tx.splitCoins(outputCoin, [tx.pure.u64(tierAmount)]);
    tx.transferObjects([outputCoin, deepChange], tx.pure.address(schedulerAddress));
 
    // `inputChange` is Coin<FundingCoin> — process_routed_payment deposits
    // it straight back into the user's account as change.
    return { platformCoin: exactPlatformCoin, fundingChange: inputChange };
  },
});

# platformId -> fundingCoinType -> pool config. The operator sets maxSpend
# explicitly — there's no price oracle here to derive a FundingCoin bound
# from the tier's PlatformCoin amount, the same reason withdraw_for_route
# itself takes max_spend as a caller-supplied bound rather than computing
# one on-chain.
ROUTING_ALLOWLIST_JSON={"0xPLATFORM_ID":{"0xFUNDING_COIN_TYPE":{"poolKey":"SUI_PUSD","isBaseToCoin":true,"deepAmount":"1000000","maxSpend":"2000000000"}}}
 
# The DEEP token type, needed to pay DeepBook trading fees. The scheduler
# must hold DEEP at this address for routing to work.
DEEP_COIN_TYPE=0x...::deep::DEEP