interface Swap {
  poolId: string;
  assetInIndex: number;
  assetOutIndex: number;
  amount: BigNumberish;
  userData?: string;
}

interface BatchSwapStep {
  poolId: string;
  assetInIndex: number;
  assetOutIndex: number;
  amount: BigNumberish;
  userData: string;
}

interface SwapExecution {
  limitAmount: BigNumberish;
}

type EncodedSwap = [BatchSwapStep[], string[], Trade];

encoder.encodeSwapStep(swap: Swap | Swap[]): void;

encoder.encodeTrade(order: Order, signature: Signature, execution?: SwapExecution): void;

await encoder.signEncodeTrade(
  order: Order,
  signer: Signer,
  scheme: SigningScheme,
  execution?: SwapExecution
): Promise<void>;

encoder.encodedSwap(): EncodedSwap;

static SwapEncoder.encodeSwap(swap: Swap, order: Order, signature: Signature): EncodedSwap;

import { SwapEncoder } from "@cowprotocol/contracts";

const encoder = new SwapEncoder(domain);

encoder.encodeSwapStep({
  poolId: "0x...",
  assetInIndex: 0,  // WETH
  assetOutIndex: 1, // DAI
  amount: ethers.utils.parseEther("1"),
});

await encoder.signEncodeTrade(order, wallet, SigningScheme.EIP712);
const encoded = encoder.encodedSwap();

encoder.encodeSwapStep([
  {
    poolId: "0xPoolA...",
    assetInIndex: 0,  // WETH
    assetOutIndex: 1, // USDC
    amount: ethers.utils.parseEther("1"),
  },
  {
    poolId: "0xPoolB...",
    assetInIndex: 1,  // USDC
    assetOutIndex: 2, // DAI
    amount: 0, // determined by first swap output
  },
]);

encoder.encodeTrade(order, signature, {
  limitAmount: ethers.utils.parseEther("1990"), // Tighter than order's buyAmount
});