/*
 * Copyright Haveno
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


// --------------------------------- IMPORTS ----------------------------------

// haveno imports
import {
  HavenoClient,
  HavenoError,
  HavenoUtils,
  OfferDirection,
  MarketPriceInfo,
  NotificationMessage,
  OfferInfo,
  TradeInfo,
  UrlConnection,
  XmrBalanceInfo,
  Attachment,
  DisputeResult,
  PaymentMethod,
  PaymentAccount,
  PaymentAccountForm,
  PaymentAccountFormField,
  PaymentAccountPayload,
  XmrDestination,
  XmrNodeSettings,
  XmrTx,
  XmrIncomingTransfer,
  XmrOutgoingTransfer,
} from "./index";
import AuthenticationStatus = UrlConnection.AuthenticationStatus;
import OnlineStatus = UrlConnection.OnlineStatus;

// other imports
import fs from "fs";
import path from "path";
import net from "net";
import assert from "assert";
import console from "console"; // import console because jest swallows messages in real time
import moneroTs from "monero-ts";
import * as os from 'os';

// ------------------------------ TEST CONFIG ---------------------------------

enum BaseCurrencyNetwork {
    XMR_MAINNET = "XMR_MAINNET",
    XMR_STAGENET = "XMR_STAGENET",
    XMR_LOCAL = "XMR_LOCAL"
}

// clients
const startupHavenods: HavenoClient[] = [];
let arbitrator: HavenoClient;
let user1: HavenoClient;
let user2: HavenoClient;
let monerod: moneroTs.MoneroDaemon;
let fundingWallet: moneroTs.MoneroWalletRpc;
let user1Wallet: moneroTs.MoneroWalletRpc;
let user2Wallet: moneroTs.MoneroWalletRpc;

enum TradeRole {
  MAKER = "MAKER",
  TAKER = "TAKER",
}

enum SaleRole {
  BUYER = "BUYER",
  SELLER = "SELLER"
}

enum DisputeContext {
    NONE = "NONE",
    OPEN_AFTER_DEPOSITS_UNLOCK = "OPEN_AFTER_DEPOSITS_UNLOCK",
    OPEN_AFTER_PAYMENT_SENT = "OPEN_AFTER_PAYMENT_SENT"
}

/**
 * Test context for a single peer in a trade.
 */
class PeerContext {
  havenod?: HavenoClient;
  wallet?: moneroTs.MoneroWallet;
  trade?: TradeInfo;

  // context to test balances after trade
  balancesBeforeOffer?: XmrBalanceInfo;
  splitOutputTxFee?: bigint;
  balancesBeforeTake?: XmrBalanceInfo;
  balancesAfterTake?: XmrBalanceInfo;
  balancesBeforePayout?: XmrBalanceInfo;
  balancesAfterPayout?: XmrBalanceInfo;
  tradeFee?: bigint;
  depositTx?: moneroTs.MoneroTx;
  depositTxFee?: bigint;
  securityDepositActual?: bigint;
  payoutTxFee?: bigint;
  payoutAmount?: bigint;

  constructor(ctx?: Partial<PeerContext>) {
    Object.assign(this, ctx);
  }
}

/**
 * Default trade configuration.
 */
const defaultTradeConfig: Partial<TradeContext> = {
  arbitrator: new PeerContext(),
  maker: new PeerContext(),
  taker: new PeerContext(),
  makeOffer: true,
  takeOffer: true,
  awaitFundsToMakeOffer: true,
  direction: OfferDirection.BUY, // buy or sell xmr
  offerAmount: 193312996088n,
  offerMinAmount: undefined,
  assetCode: "usd", // counter asset to trade
  makerPaymentAccountId: undefined,
  securityDepositPct: 0.15,
  price: undefined, // use market price if undefined
  triggerPrice: undefined,
  awaitFundsToTakeOffer: true,
  offerId: undefined,
  takerPaymentAccountId: undefined,
  buyerSendsPayment: true,
  sellerReceivesPayment: true,
  resolveDispute: true, // resolve dispute after opening
  disputeWinner: DisputeResult.Winner.SELLER,
  disputeReason: DisputeResult.Reason.PEER_WAS_LATE,
  disputeSummary: "Seller is winner",
  walletSyncPeriodMs: 5000,
  maxTimePeerNoticeMs: 5000,
  testChatMessages: true,
  stopOnFailure: false, // TODO: setting to true can cause error: Http response at 400 or 500 level, http status code: 503
  testPayoutConfirmed: true,
  testPayoutUnlocked: false,
  maxConcurrency: getMaxConcurrency()
}

/**
 * Configuration and context for a single trade.
 */
class TradeContext {

  // trade peers
  arbitrator!: Partial<PeerContext>;
  maker!: Partial<PeerContext>;
  taker!: Partial<PeerContext>;

  // trade flow
  concurrentTrades?: boolean; // testing trades at same time
  makeOffer?: boolean;
  takeOffer?: boolean;
  buyerOfflineAfterTake?: boolean;
  sellerOfflineAfterTake?: boolean;
  buyerOfflineAfterPaymentSent?: boolean
  buyerOfflineAfterDisputeOpened?: boolean;
  sellerOfflineAfterDisputeOpened?: boolean;
  sellerDisputeContext?: DisputeContext;
  buyerDisputeContext?: DisputeContext;
  buyerSendsPayment?: boolean;
  sellerReceivesPayment?: boolean

  // make offer
  awaitFundsToMakeOffer?: boolean
  direction?: OfferDirection;
  assetCode?: string;
  offerAmount?: bigint; // offer amount or max
  offerMinAmount?: bigint;
  tradeAmount?: bigint; // trade amount within offer range
  makerPaymentAccountId?: string;
  securityDepositPct?: number;
  price?: number;
  priceMargin?: number;
  triggerPrice?: number;
  reserveExactAmount?: boolean;

  // take offer
  awaitFundsToTakeOffer?: boolean;
  offerId?: string;
  takerPaymentAccountId?: string;
  testTraderChat?: boolean;

  // resolve dispute
  resolveDispute?: boolean
  disputeOpener?: SaleRole;
  disputeWinner?: DisputeResult.Winner;
  disputeReason?: DisputeResult.Reason;
  disputeSummary?: string;
  disputeWinnerAmount?: bigint;

  // other context
  offer?: OfferInfo;
  index?: number;
  isOfferTaken?: boolean;
  isPaymentSent?: boolean;
  isPaymentReceived?: boolean;
  phase?: string;
  payoutState?: string[];
  disputeState?: string;
  isCompleted?: boolean;
  isPayoutPublished?: boolean; // TODO: test isDepositsPublished; etc
  isPayoutConfirmed?: boolean;
  isPayoutUnlocked?: boolean
  buyerOpenedDispute?: boolean;
  sellerOpenedDispute?: boolean;
  walletSyncPeriodMs!: number;
  maxTimePeerNoticeMs!: number;
  testChatMessages!: boolean;
  stopOnFailure?: boolean;
  buyerAppName?: string;
  sellerAppName?: string;
  usedPorts?: string[];
  testPayoutConfirmed?: boolean;
  testPayoutUnlocked?: boolean;
  payoutTxId?: string
  testBalanceChangeEndToEnd?: boolean;
  isStopped!: boolean;
  maxConcurrency!: number;

  constructor(ctx?: Partial<TradeContext>) {
    Object.assign(this, ctx);
    if (this.arbitrator) this.arbitrator = new PeerContext(this.arbitrator);
    if (this.maker) this.maker = new PeerContext(this.maker);
    if (this.taker) this.taker = new PeerContext(this.taker);
  }

  getMaker(): PeerContext {
    return this.maker as PeerContext;
  }

  getTaker(): PeerContext {
    return this.taker as PeerContext;
  }

  getBuyer(): PeerContext {
    return (this.direction === OfferDirection.BUY ? this.maker : this.taker) as PeerContext;
  }

  getSeller(): PeerContext {
    return (this.direction === OfferDirection.BUY ? this.taker : this.maker) as PeerContext;
  }

  isBuyerMaker(): boolean {
    return this.direction === OfferDirection.BUY;
  }

  getDisputeOpener(): PeerContext | undefined {
    if (this.disputeOpener === undefined) return undefined;
    return this.disputeOpener === SaleRole.BUYER ? this.getBuyer() : this.getSeller();
  }

  getDisputePeer(): PeerContext | undefined {
    if (this.disputeOpener === undefined) return undefined;
    return this.disputeOpener === SaleRole.BUYER ? this.getSeller() : this.getBuyer();
  }

  getDisputeWinner(): PeerContext | undefined {
    if (this.disputeWinner === undefined) return undefined;
    return this.disputeWinner === DisputeResult.Winner.BUYER ? this.getBuyer() : this.getSeller();
  }

  getDisputeLoser(): PeerContext | undefined {
    if (this.disputeWinner === undefined) return undefined;
    return this.disputeWinner === DisputeResult.Winner.BUYER ? this.getSeller() : this.getBuyer();
  }

  isOfflineFlow() {
    return this.buyerOfflineAfterDisputeOpened || this.sellerOfflineAfterDisputeOpened || this.buyerOfflineAfterPaymentSent || this.buyerOfflineAfterTake || this.sellerOfflineAfterTake;
  }

  getPhase() {
    return this.isPaymentReceived ? "PAYMENT_RECEIVED" : this.isPaymentSent ? "PAYMENT_SENT" : "DEPOSITS_UNLOCKED";
  }

  static init(ctxP: Partial<TradeContext> | undefined): TradeContext {
    let ctx = ctxP instanceof TradeContext ? ctxP : new TradeContext(ctxP);
    if (!ctx.offerAmount && ctx.tradeAmount) ctx.offerAmount = ctx.tradeAmount;
    if (!ctx.offerMinAmount && ctx.offerAmount) ctx.offerMinAmount = ctx.offerAmount;
    Object.assign(ctx, new TradeContext(TestConfig.trade), Object.assign({}, ctx));
    return ctx;
  }

  async toSummary(): Promise<string> {
    let str: string = "";
    str += "Type: Maker/" + (this.direction === OfferDirection.BUY ? "Buyer" : "Seller") + ", Taker/" + (this.direction === OfferDirection.BUY ? "Seller" : "Buyer");
    str += "\nOffer id: " + this.offerId;
    if (this.maker.havenod) str += "\nMaker uri: " + this.maker?.havenod?.getUrl();
    if (this.taker.havenod) str += "\nTaker uri: " + this.taker?.havenod?.getUrl();
    str += "\nAsset code: " + this.assetCode?.toUpperCase();
    str += "\nMaker payment account id: " + this.makerPaymentAccountId;
    str += "\nTaker payment account id: " + this.takerPaymentAccountId;
    str += "\nTrade amount: " + this.tradeAmount;
    str += "\nMin amount: " + this.offerMinAmount;
    str += "\nMax amount: " + this.offerAmount;
    str += "\nSecurity deposit percent: " + this.securityDepositPct;
    str += "\nMaker balance before offer: " + this.maker.balancesBeforeOffer?.getBalance();
    str += "\nMaker split output tx fee: " + this.maker.splitOutputTxFee;
    if (this.offer) {
      str += "\nMaker fee percent: " + this.offer!.getMakerFeePct();
      str += "\nTaker fee percent: " + this.offer!.getTakerFeePct();
    }
    if (this.arbitrator && this.arbitrator!.trade) {
      str += "\nMaker trade fee: " + this.arbitrator?.trade?.getMakerFee();
      str += "\nMaker deposit tx id: " + this.arbitrator!.trade!.getMakerDepositTxId();
      if (this.arbitrator!.trade!.getMakerDepositTxId()) {
        let tx = await monerod.getTx(this.arbitrator!.trade!.getMakerDepositTxId());
        str += "\nMaker deposit tx fee: " + (tx ? tx?.getFee() : undefined);
      }
      str += "\nMaker security deposit received: " + (this.direction == OfferDirection.BUY ? this.arbitrator!.trade!.getBuyerSecurityDeposit() : this.arbitrator!.trade!.getSellerSecurityDeposit());
    }
    str += "\nTaker balance before offer: " + this.taker.balancesBeforeOffer?.getBalance();
    if (this.arbitrator && this.arbitrator!.trade) {
      str += "\nTaker trade fee: " + this.arbitrator?.trade?.getTakerFee();
      str += "\nTaker deposit tx id: " + this.arbitrator!.trade!.getTakerDepositTxId();
      if (this.arbitrator!.trade!.getTakerDepositTxId()) {
        let tx = await monerod.getTx(this.arbitrator!.trade!.getTakerDepositTxId());
        str += "\nTaker deposit tx fee: " + (tx ? tx?.getFee() : undefined);
      }
      str += "\nTaker security deposit received: " + (this.direction == OfferDirection.BUY ? this.arbitrator!.trade!.getSellerSecurityDeposit() : this.arbitrator!.trade!.getBuyerSecurityDeposit());
      if (this.disputeWinner) str += "\nDispute winner: " + (this.disputeWinner == DisputeResult.Winner.BUYER ? "Buyer" : "Seller");
      str += "\nPayout tx id: " + this.payoutTxId;
      if (this.payoutTxId) {
        str += "\nPayout fee: " + (await monerod.getTx(this.payoutTxId!))!.getFee()!;
        if (this.getBuyer().havenod) str += "\nBuyer payout: " + (await this.getBuyer().havenod!.getXmrTx(this.payoutTxId!))?.getIncomingTransfersList()[0].getAmount()!;
        if (this.getSeller().havenod) str += "\nSeller payout: " + (await this.getSeller().havenod!.getXmrTx(this.payoutTxId!))?.getIncomingTransfersList()[0].getAmount()!;
      }
    }
    str += "\nOffer json: " + JSON.stringify(this.offer?.toObject());
    return str;
  }
}

/**
 * Default test configuration.
 */
const TestConfig = {
    logLevel: 2,
    baseCurrencyNetwork: getBaseCurrencyNetwork(),
    networkType: getBaseCurrencyNetwork() == BaseCurrencyNetwork.XMR_MAINNET ? moneroTs.MoneroNetworkType.MAINNET : getBaseCurrencyNetwork() == BaseCurrencyNetwork.XMR_LOCAL ? moneroTs.MoneroNetworkType.TESTNET : moneroTs.MoneroNetworkType.STAGENET,
    moneroBinsDir: "../haveno/.localnet",
    testDataDir: "./testdata",
    haveno: {
        path: "../haveno",
        version: "1.0.11"
    },
    monerod: {
        url: "http://localhost:" + getNetworkStartPort() + "8081", // 18081, 28081, 38081 for mainnet, testnet, and stagenet, respectively
        username: "",
        password: ""
    },
    monerod3: { // corresponds to monerod3-local in Makefile
        url: "http://localhost:58081",
        username: "superuser",
        password: "abctesting123",
        p2pBindPort: "58080",
        rpcBindPort: "58081",
        zmqRpcBindPort: "58082"
    },
    fundingWallet: {
        url: "http://localhost:" + getNetworkStartPort() + "8084", // 18084, 28084, 38084 for mainnet, testnet, stagenet respectively
        username: "rpc_user",
        password: "abc123",
        walletPassword: "abc123",
        defaultPath: "funding_wallet-" + getBaseCurrencyNetwork(),
        minimumFunding: 5000000000000n,
        seed: "origin hickory pavements tudor sizes hornet tether segments sack technical elbow unsafe legion nitrogen adapt yearbook idols fuzzy pitched goes tusks elbow erase fossil erase",
        primaryAddress: "9xSyMy1r9h3BVjMrF3CTqQCQy36yCfkpn7uVfMyTUbez3hhumqBUqGUNNALjcd7f1HJBRdeH82bCC3veFHW7z3xm28gug4d",
        restoreHeight: 150
    },
    defaultHavenod: {
        logProcessOutput: true, // log output for processes started by tests (except arbitrator, user1, and user2 which are configured separately)
        logLevel: "info",
        apiPassword: "apitest",
        walletUsername: "haveno_user",
        walletDefaultPassword: "password", // only used if account password not set
        accountPasswordRequired: true,
        accountPassword: "abctesting789",
        autoLogin: true
    },
    startupHavenods: [{
            appName: "haveno-" + getBaseCurrencyNetwork() + "_arbitrator", // arbritrator
            logProcessOutput: true,
            port: "8079",
            accountPasswordRequired: false,
            accountPassword: "abctesting123",
        }, {
            appName: "haveno-" + getBaseCurrencyNetwork() + "_user1", // user1
            logProcessOutput: true,
            port: "8080",
            accountPasswordRequired: false,
            accountPassword: "abctesting456",
            walletUrl: "http://127.0.0.1:38091",
        }, {
            appName: "haveno-" + getBaseCurrencyNetwork() + "_user2", // user2
            logProcessOutput: true,
            port: "8081",
            accountPasswordRequired: false,
            accountPassword: "abctesting789",
            walletUrl: "http://127.0.0.1:38092",
        }
    ],
    maxFee: HavenoUtils.xmrToAtomicUnits(0.5), // local testnet fees can be relatively high
    minSecurityDeposit: moneroTs.MoneroUtils.xmrToAtomicUnits(0.1),
    maxAdjustmentPct: 0.2,
    daemonPollPeriodMs: 5000,
    maxWalletStartupMs: 10000, // TODO (woodser): make shorter by switching to jni
    maxCpuPct: 0.25,
    paymentMethods: Object.keys(PaymentAccountForm.FormId), // all supported payment methods
    assetCodes: ["USD", "GBP", "EUR", "ETH", "BTC", "BCH", "LTC"], // primary asset codes
    fixedPriceAssetCodes: ["XAG", "XAU", "XGB"],
    cryptoAddresses: [{
            currencyCode: "ETH",
            address: "0xdBdAb835Acd6fC84cF5F9aDD3c0B5a1E25fbd99f"
        }, {
            currencyCode: "BTC",
            address: "1G457efxTyci67msm2dSqyhFzxPYFWaghe"
        }, {
            currencyCode: "BCH",
            address: "qz54ydhwzn25wzf8pge5s26udvtx33yhyq3lnv6vq6"
        }, {
            currencyCode: "LTC",
            address: "LXUTUN5mTPc2LsS7cEjkyjTRcfYyJGoUuQ"
        }
    ],
    ports: new Map<string, string[]>([ // map http ports to havenod api and p2p ports
        ["8079", ["9998", "4444"]],    // arbitrator
        ["8080", ["9999", "5555"]],    // user1
        ["8081", ["10000", "6666"]],   // user2
        ["8082", ["10001", "7777"]],
        ["8083", ["10002", "7778"]],
        ["8084", ["10003", "7779"]],
        ["8085", ["10004", "7780"]],
        ["8086", ["10005", "7781"]],
    ]),
    arbitratorPrivKeys: {
        XMR_LOCAL: ["6ac43ea1df2a290c1c8391736aa42e4339c5cb4f110ff0257a13b63211977b7a", "d96c4e7be030564cfa64a4040060574a8e92a79f574104ab8bb0c1166db28047", "6d5c86cbc5fc7ce3c97b06969661eae5c018cb2923856cc51341d182a45d1e9d"],
        XMR_STAGENET: ["1aa111f817b7fdaaec1c8d5281a1837cc71c336db09b87cf23344a0a4e3bb2cb", "6b5a404eb5ff7154f2357126c84c3becfe2e7c59ca3844954ce9476bec2a6228", "fd4ef301a2e4faa3c77bc26393919895fa29b0908f2bbd51f6f6de3e46fb7a6e"],
        XMR_MAINNET: []
    },
    tradeStepTimeoutMs: getBaseCurrencyNetwork() === BaseCurrencyNetwork.XMR_LOCAL ? 60000 : 180000,
    testTimeout: getBaseCurrencyNetwork() === BaseCurrencyNetwork.XMR_LOCAL ? 2400000 : 5400000, // timeout in ms for each test to complete (40 minutes for private network, 90 minutes for public network)
    trade: new TradeContext(defaultTradeConfig)
};

interface HavenodContext {
    logProcessOutput?: boolean,
    logLevel?: string,
    apiPassword?: string,
    walletUsername?: string,
    walletDefaultPassword?: string,
    accountPasswordRequired?: boolean,
    accountPassword?: string,
    autoLogin?: boolean,
    appName?: string,
    port?: string,
    excludePorts?: string[],
    walletUrl?: string
}

interface TxContext {
    isCreatedTx: boolean;
}

// track started haveno processes
const HAVENO_PROCESSES: HavenoClient[] = [];
const HAVENO_PROCESS_PORTS: string[] = [];
const HAVENO_WALLETS: Map<HavenoClient, any> = new Map<HavenoClient, any>();

// other config
const OFFLINE_ERR_MSG = "Http response at 400 or 500 level";

function getMaxConcurrency() {
  return isGitHubActions() ? 4 : 20;
}

function isGitHubActions() {
  return process.env.GITHUB_ACTIONS === 'true';
}

// -------------------------- BEFORE / AFTER TESTS ----------------------------

jest.setTimeout(TestConfig.testTimeout);

beforeAll(async () => {
  try {

    // set log level for tests
    HavenoUtils.setLogLevel(TestConfig.logLevel);

    // initialize funding wallet
    HavenoUtils.log(0, "Initializing funding wallet");
    await initFundingWallet();
    HavenoUtils.log(0, "Funding wallet balance: " + await fundingWallet.getBalance());
    HavenoUtils.log(0, "Funding wallet unlocked balance: " + await fundingWallet.getUnlockedBalance());
    const subaddress = await fundingWallet.createSubaddress(0);
    HavenoUtils.log(0, "Funding wallet height: " + await fundingWallet.getHeight());
    HavenoUtils.log(0, "Funding wallet seed: " + await fundingWallet.getSeed());
    HavenoUtils.log(0, "Funding wallet primary address: " + await fundingWallet.getPrimaryAddress());
    HavenoUtils.log(0, "Funding wallet new subaddress: " + subaddress.getAddress());

    // initialize monerod
    try {
      monerod = await moneroTs.connectToDaemonRpc(TestConfig.monerod.url, TestConfig.monerod.username, TestConfig.monerod.password);
      await mineToHeight(160); // initialize blockchain to latest block type
    } catch (err: any) {
      HavenoUtils.log(0, "Error initializing internal monerod: " + err.message); // allowed in order to test starting and stopping local node
    }

    // start configured haveno daemons
    const promises: Promise<HavenoClient>[] = [];
    let err;
    for (const config of TestConfig.startupHavenods) promises.push(initHaveno(config));
    for (const settledPromise of await Promise.allSettled(promises)) {
      if (settledPromise.status === "fulfilled") startupHavenods.push((settledPromise as PromiseFulfilledResult<HavenoClient>).value);
      else if (!err) err = new Error((settledPromise as PromiseRejectedResult).reason);
    }
    if (err) throw err;

    // assign arbitrator, user1, user2
    arbitrator = startupHavenods[0];
    user1 = startupHavenods[1];
    user2 = startupHavenods[2];
    TestConfig.trade.arbitrator.havenod = arbitrator;
    TestConfig.trade.maker.havenod = user1;
    TestConfig.trade.taker.havenod = user2;

    // connect client wallets
    user1Wallet = await moneroTs.connectToWalletRpc(TestConfig.startupHavenods[1].walletUrl!, TestConfig.defaultHavenod.walletUsername, TestConfig.startupHavenods[1].accountPasswordRequired ? TestConfig.startupHavenods[1].accountPassword : TestConfig.defaultHavenod.walletDefaultPassword);
    user2Wallet = await moneroTs.connectToWalletRpc(TestConfig.startupHavenods[2].walletUrl!, TestConfig.defaultHavenod.walletUsername, TestConfig.startupHavenods[2].accountPasswordRequired ? TestConfig.startupHavenods[2].accountPassword : TestConfig.defaultHavenod.walletDefaultPassword);

    // register arbitrator dispute agent
    await arbitrator.registerDisputeAgent("arbitrator", getArbitratorPrivKey(0));

    // create test data directory if it doesn't exist
    if (!fs.existsSync(TestConfig.testDataDir)) fs.mkdirSync(TestConfig.testDataDir);
  } catch (err) {
    await shutDown();
    throw err;
  }
});

beforeEach(async () => {
  HavenoUtils.log(0, "BEFORE TEST \"" + expect.getState().currentTestName + "\"");
});

afterAll(async () => {
  await shutDown();
});

async function shutDown() {

  // release haveno processes
  const promises: Promise<void>[] = [];
  for (const havenod of startupHavenods) {
    promises.push(havenod.getProcess() ? releaseHavenoProcess(havenod) : havenod.disconnect());
  }
  await Promise.all(promises);

  // terminate monero-ts worker
  await moneroTs.LibraryUtils.terminateWorker();
}

// ----------------------------------- TESTS ----------------------------------

test("Can get the version (CI)", async () => {
  const version = await arbitrator.getVersion();
  expect(version).toEqual(TestConfig.haveno.version);
});

test("Can convert between XMR and atomic units (CI)", async () => {
  expect(BigInt(250000000000)).toEqual(HavenoUtils.xmrToAtomicUnits(0.25));
  expect(HavenoUtils.atomicUnitsToXmr("250000000000")).toEqual(.25);
  expect(HavenoUtils.atomicUnitsToXmr(250000000000n)).toEqual(.25);
});

test("Can manage an account (CI)", async () => {
  let user3: HavenoClient|undefined;
  let err: any;
  try {

    // start user3 without opening account
    user3 = await initHaveno({autoLogin: false});
    assert(!await user3.accountExists());

    // test errors when account not open
    await testAccountNotOpen(user3);

    // create account
    let password = "testPassword";
    await user3.createAccount(password);
    if (await user3.isConnectedToMonero()) await user3.getBalances(); // only connected if local node running
    assert(await user3.accountExists());
    assert(await user3.isAccountOpen());

    // create payment account
    const paymentAccount = await user3.createCryptoPaymentAccount("My ETH account", TestConfig.cryptoAddresses[0].currencyCode, TestConfig.cryptoAddresses[0].address);

    // close account
    await user3.closeAccount();
    assert(await user3.accountExists());
    assert(!await user3.isAccountOpen());
    await testAccountNotOpen(user3);

    // open account with wrong password
    try {
        await user3.openAccount("wrongPassword");
        throw new Error("Should have failed opening account with wrong password");
    } catch (err: any) {
        assert.equal(err.message, "Incorrect password");
    }

    // open account
    await user3.openAccount(password);
    assert(await user3.accountExists());
    assert(await user3.isAccountOpen());

    // restart user3
    const user3Config = {appName: user3.getAppName(), autoLogin: false}
    await releaseHavenoProcess(user3);
    user3 = await initHaveno(user3Config);
    assert(await user3.accountExists());
    assert(!await user3.isAccountOpen());

    // open account
    await user3.openAccount(password);
    assert(await user3.accountExists());
    assert(await user3.isAccountOpen());

    // try changing incorrect password
    try {
      await user3.changePassword("wrongPassword", "abc123");
      throw new Error("Should have failed changing wrong password");
    } catch (err: any) {
      assert.equal(err.message, "Incorrect password");
    }

    // try setting password below minimum length
    try {
      await user3.changePassword(password, "abc123");
      throw new Error("Should have failed setting password below minimum length")
    } catch (err: any) {
      assert.equal(err.message, "Password must be at least 8 characters");
    }

    // change password
    const newPassword = "newPassword";
    await user3.changePassword(password, newPassword);
    password = newPassword;
    assert(await user3.accountExists());
    assert(await user3.isAccountOpen());

    // restart user3
    await releaseHavenoProcess(user3);
    user3 = await initHaveno(user3Config);
    await testAccountNotOpen(user3);

    // open account
    await user3.openAccount(password);
    assert(await user3.accountExists());
    assert(await user3.isAccountOpen());

    // backup account to zip file
    const zipFile = TestConfig.testDataDir + "/backup.zip";
    const stream = fs.createWriteStream(zipFile);
    const size = await user3.backupAccount(stream);
    stream.end();
    assert(size > 0);

    // delete account and wait until connected
    await user3.deleteAccount();
    HavenoUtils.log(1, "Waiting to be connected to havenod after deleting account"); // TODO: build this into deleteAccount
    do { await wait(1000); }
    while(!await user3.isConnectedToDaemon());
    HavenoUtils.log(1, "Reconnecting to havenod");
    assert(!await user3.accountExists());

    // restore account
    const zipBytes: Uint8Array = new Uint8Array(fs.readFileSync(zipFile));
    await user3.restoreAccount(zipBytes);
    do { await wait(1000); }
    while(!await user3.isConnectedToDaemon());
    assert(await user3.accountExists());

    // open restored account
    await user3.openAccount(password);
    assert(await user3.isAccountOpen());

    // check the persisted payment account
    const paymentAccount2 = await user3.getPaymentAccount(paymentAccount.getId());
    testCryptoPaymentAccountsEqual(paymentAccount, paymentAccount2);
  } catch (err2) {
    err = err2;
  }

  // stop and delete instances
  if (user3) await releaseHavenoProcess(user3, true);
  if (err) throw err;

  async function testAccountNotOpen(havenod: HavenoClient): Promise<void> { // TODO: generalize this?
    try { await havenod.getMoneroConnections(); throw new Error("Should have thrown"); }
    catch (err: any) { assert.equal(err.message, "Account not open"); }
    try { await havenod.getXmrTxs(); throw new Error("Should have thrown"); }
    catch (err: any) { assert.equal(err.message, "Account not open"); }
    try { await havenod.getBalances(); throw new Error("Should have thrown"); }
    catch (err: any) { assert.equal(err.message, "Account not open"); }
    try { await havenod.createCryptoPaymentAccount("My ETH account", TestConfig.cryptoAddresses[0].currencyCode, TestConfig.cryptoAddresses[0].address); throw new Error("Should have thrown"); }
    catch (err: any) { assert.equal(err.message, "Account not open"); }
  }
});

test("Can manage Monero daemon connections (CI)", async () => {
  let monerod3: moneroTs.MoneroDaemonRpc | undefined = undefined;
  let user3: HavenoClient|undefined;
  let err: any;
  try {

    // start user3
    user3 = await initHaveno();

    // disable auto switch for tests
    assert.equal(true, await user3.getAutoSwitch());
    await user3.setAutoSwitch(false);

    // test default connections
    const monerodUrl1 = "http://127.0.0.1:" + getNetworkStartPort() + "8081"; // TODO: (woodser): move to config
    let connections: UrlConnection[] = await user3.getMoneroConnections();
    testConnection(getConnection(connections, monerodUrl1)!, monerodUrl1, OnlineStatus.ONLINE, AuthenticationStatus.AUTHENTICATED, 1);

    // test default connection
    let connection: UrlConnection|undefined = await user3.getMoneroConnection();
    assert(await user3.isConnectedToMonero());
    testConnection(connection!, monerodUrl1, OnlineStatus.ONLINE, AuthenticationStatus.AUTHENTICATED, 1); // TODO: should be no authentication?

    // add a new connection
    const fooBarUrl = "http://foo.bar";
    await user3.addMoneroConnection(fooBarUrl);
    connections = await user3.getMoneroConnections();
    connection = getConnection(connections, fooBarUrl);
    testConnection(connection!, fooBarUrl, OnlineStatus.UNKNOWN, AuthenticationStatus.NO_AUTHENTICATION, 0);

    // set prioritized connection without credentials
    await user3.setMoneroConnection(new UrlConnection()
        .setUrl(TestConfig.monerod3.url)
        .setPriority(1));
    connection = await user3.getMoneroConnection();
    testConnection(connection!, TestConfig.monerod3.url, undefined, undefined, 1); // status may or may not be known due to periodic connection checking

    // connection is offline
    connection = await user3.checkMoneroConnection();
    assert(!await user3.isConnectedToMonero());
    testConnection(connection!, TestConfig.monerod3.url, OnlineStatus.OFFLINE, AuthenticationStatus.NO_AUTHENTICATION, 1);

    // start monerod3
    const cmd = [
      TestConfig.moneroBinsDir + "/monerod",
      "--no-igd",
      "--hide-my-port",
      "--data-dir",  TestConfig.moneroBinsDir + "/" + TestConfig.baseCurrencyNetwork.toLowerCase() + "/node3",
      "--p2p-bind-ip", "127.0.0.1",
      "--p2p-bind-port", TestConfig.monerod3.p2pBindPort,
      "--rpc-bind-port", TestConfig.monerod3.rpcBindPort,
      "--zmq-rpc-bind-port", TestConfig.monerod3.zmqRpcBindPort,
      "--log-level", "0",
      "--confirm-external-bind",
      "--rpc-access-control-origins", "http://localhost:8080",
      "--fixed-difficulty", "500",
      "--disable-rpc-ban"
    ];
    if (getBaseCurrencyNetwork() !== BaseCurrencyNetwork.XMR_MAINNET) cmd.push("--" + moneroTs.MoneroNetworkType.toString(TestConfig.networkType).toLowerCase());
    if (TestConfig.monerod3.username) cmd.push("--rpc-login", TestConfig.monerod3.username + ":" + TestConfig.monerod3.password);
    monerod3 = await moneroTs.connectToDaemonRpc(cmd);

    // connection is online and not authenticated
    connection = await user3.checkMoneroConnection();
    assert(!await user3.isConnectedToMonero());
    testConnection(connection!, TestConfig.monerod3.url, OnlineStatus.ONLINE, AuthenticationStatus.NOT_AUTHENTICATED, 1);

    // set connection credentials
    await user3.setMoneroConnection(new UrlConnection()
        .setUrl(TestConfig.monerod3.url)
        .setUsername(TestConfig.monerod3.username)
        .setPassword(TestConfig.monerod3.password)
        .setPriority(1));
    connection = await user3.getMoneroConnection();
    testConnection(connection!, TestConfig.monerod3.url, undefined, undefined, 1);

    // connection is online and authenticated
    connection = await user3.checkMoneroConnection();
    assert(await user3.isConnectedToMonero());
    testConnection(connection!, TestConfig.monerod3.url, OnlineStatus.ONLINE, AuthenticationStatus.AUTHENTICATED, 1);

    // change account password
    const newPassword = "newPassword";
    await user3.changePassword(TestConfig.defaultHavenod.accountPassword, newPassword);

    // restart user3
    const appName = user3.getAppName();
    await releaseHavenoProcess(user3);
    user3 = await initHaveno({appName: appName, accountPassword: newPassword});

    // connection is restored, online, and authenticated
    await user3.checkMoneroConnection();
    connection = await user3.getMoneroConnection();
    testConnection(connection!, TestConfig.monerod3.url, OnlineStatus.ONLINE, AuthenticationStatus.AUTHENTICATED, 1);

    // priority connections are polled
    await user3.checkMoneroConnections();
    connections = await user3.getMoneroConnections();
    testConnection(getConnection(connections, monerodUrl1)!, monerodUrl1, OnlineStatus.ONLINE, AuthenticationStatus.AUTHENTICATED, 1);

    // enable auto switch
    await user3.setAutoSwitch(true);
    assert.equal(true, await user3.getAutoSwitch());

    // stop monerod
    //await monerod3.stopProcess(); // TODO (monero-ts): monerod remains available after await monerod.stopProcess() for up to 40 seconds
    await moneroTs.GenUtils.killProcess(monerod3.getProcess(), "SIGKILL");

    // test auto switch after periodic connection check
    await wait(TestConfig.daemonPollPeriodMs * 2);
    await user3.checkMoneroConnection();
    connection = await user3.getMoneroConnection();
    testConnection(connection!, monerodUrl1, OnlineStatus.ONLINE, AuthenticationStatus.AUTHENTICATED, 1);

    // stop auto switch and checking connection periodically
    await user3.setAutoSwitch(false);
    assert.equal(false, await user3.getAutoSwitch());
    await user3.stopCheckingConnection();

    // remove current connection
    await user3.removeMoneroConnection(monerodUrl1);

    // check current connection
    connection = await user3.checkMoneroConnection();
    assert.equal(connection, undefined);

    // check all connections
    await user3.checkMoneroConnections();
    connections = await user3.getMoneroConnections();
    testConnection(getConnection(connections, fooBarUrl)!, fooBarUrl, OnlineStatus.OFFLINE, AuthenticationStatus.NO_AUTHENTICATION, 0);

    // set connection to previous url
    await user3.setMoneroConnection(fooBarUrl);
    connection = await user3.getMoneroConnection();
    testConnection(connection!, fooBarUrl, OnlineStatus.OFFLINE, AuthenticationStatus.NO_AUTHENTICATION, 0);

    // set connection to new url
    const fooBarUrl2 = "http://foo.bar.xyz";
    await user3.setMoneroConnection(fooBarUrl2);
    connections = await user3.getMoneroConnections();
    connection = getConnection(connections, fooBarUrl2);
    testConnection(connection!, fooBarUrl2, OnlineStatus.UNKNOWN, AuthenticationStatus.NO_AUTHENTICATION, 0);

    // reset connection
    await user3.setMoneroConnection();
    assert.equal(await user3.getMoneroConnection(), undefined);

    // test auto switch after start checking connection
    await user3.setAutoSwitch(false);
    await user3.startCheckingConnection(5000); // checks the connection
    await user3.setAutoSwitch(true);
    await user3.addMoneroConnection(new UrlConnection()
            .setUrl(TestConfig.monerod.url)
            .setUsername(TestConfig.monerod.username)
            .setPassword(TestConfig.monerod.password)
            .setPriority(2));
    await wait(10000);
    connection = await user3.getMoneroConnection();
    testConnection(connection!, TestConfig.monerod.url, OnlineStatus.ONLINE, AuthenticationStatus.AUTHENTICATED, 2);
  } catch (err2) {
    err = err2;
  }

  // stop processes
  if (user3) await releaseHavenoProcess(user3, true);
  if (monerod3) await monerod3.stopProcess();
  if (err) throw err;
});

// NOTE: To run full test, the following conditions must be met:
// - monerod1-local must be stopped
// - monerod2-local must be running
// - user1-daemon-local must be running and own its monerod process (so it can be stopped)
test("Can start and stop a local Monero node (CI)", async() => {

  // expect error stopping stopped local node
  try {
    await user1.stopMoneroNode();
    HavenoUtils.log(1, "Running local Monero node stopped");
    await user1.stopMoneroNode(); // stop 2nd time to force error
    throw new Error("should have thrown");
  } catch (err: any) {
    if (err.message !== "Local Monero node is not running" &&
        err.message !== "Cannot stop local Monero node because we don't own its process") {
      throw new Error("Unexpected error: " + err.message);
    }
  }

  if (await user1.isMoneroNodeOnline()) {
    HavenoUtils.log(0, "Warning: local Monero node is already running, skipping start and stop local Monero node tests");

    // expect error due to existing running node
    const newSettings = new XmrNodeSettings();
    try {
      await user1.startMoneroNode(newSettings);
      throw new Error("should have thrown");
    } catch (err: any) {
      if (err.message !== "Local Monero node already online") throw new Error("Unexpected error: " + err.message);
    }

  } else {

    // expect error when passing in bad arguments
    const badSettings = new XmrNodeSettings();
    badSettings.setStartupFlagsList(["--invalid-flag"]);
    try {
      await user1.startMoneroNode(badSettings);
      throw new Error("should have thrown");
    } catch (err: any) {
      if (!err.message.startsWith("Failed to start monerod:")) throw new Error("Unexpected error: ");
    }

    // expect successful start with custom settings
    const connectionsBefore = await user1.getMoneroConnections();
    const settings: XmrNodeSettings = new XmrNodeSettings();
    const dataDir = TestConfig.moneroBinsDir + "/" + TestConfig.baseCurrencyNetwork.toLowerCase() + "/node1";
    const logFile = dataDir + "/test.log";
    settings.setBlockchainPath(dataDir);
    settings.setStartupFlagsList(["--log-file", logFile, "--no-zmq"]);
    await user1.startMoneroNode(settings);
    assert(await user1.isMoneroNodeOnline());

    // expect settings are updated
    const settingsAfter = await user1.getMoneroNodeSettings();
    testMoneroNodeSettingsEqual(settings, settingsAfter!);

    // expect connection to local monero node to succeed
    let daemon = await moneroTs.connectToDaemonRpc(TestConfig.monerod.url, "superuser", "abctesting123");
    let height = await daemon.getHeight();
    assert(height > 0);

    // expect error due to existing running node
    const newSettings = new XmrNodeSettings();
    try {
      await user1.startMoneroNode(newSettings);
      throw new Error("should have thrown");
    } catch (err: any) {
      if (err.message !== "Local Monero node already online") throw new Error("Unexpected error: " + err.message);
    }

    // expect stopped node
    await user1.stopMoneroNode();
    assert(!(await user1.isMoneroNodeOnline()));
    try {
      daemon = await moneroTs.connectToDaemonRpc(TestConfig.monerod.url);
      height = await daemon.getHeight();
      console.log("GOT HEIGHT: " + height);
      throw new Error("should have thrown"); 
    } catch (err: any) {
      if (err.message.indexOf("connect ECONNREFUSED 127.0.0.1:28081") <= 0) throw new Error("Unexpected error: " + err.message);
    }

    // start local node again
    await user1.startMoneroNode(settings);
    assert(await user1.isMoneroNodeOnline());
  }
});

// test wallet balances, transactions, deposit addresses, create and relay txs
test("Has a Monero wallet (CI)", async () => {

  // get seed phrase
  const seed = await user1.getXmrSeed();
  await moneroTs.MoneroUtils.validateMnemonic(seed);

  // get primary address
  const primaryAddress = await user1.getXmrPrimaryAddress();
  await moneroTs.MoneroUtils.validateAddress(primaryAddress, TestConfig.networkType);

  // wait for user1 to have unlocked balance
  const tradeAmount = 250000000000n;
  await waitForAvailableBalance(tradeAmount * 2n, user1);

  // test balances
  const balancesBefore: XmrBalanceInfo = await user1.getBalances(); // TODO: rename to getXmrBalances() for consistency?
  expect(BigInt(balancesBefore.getAvailableBalance())).toBeGreaterThan(0n);
  expect(BigInt(balancesBefore.getBalance())).toBeGreaterThanOrEqual(BigInt(balancesBefore.getAvailableBalance()));

  // get transactions
  const txs: XmrTx[]= await user1.getXmrTxs();
  assert(txs.length > 0);
  for (const tx of txs) {
    testTx(tx, {isCreatedTx: false});
  }

  // get new subaddresses
  for (let i = 0; i < 0; i++) {
    const address = await user1.getXmrNewSubaddress();
    await moneroTs.MoneroUtils.validateAddress(address, TestConfig.networkType);
  }

  // create withdraw tx
  const destination = new XmrDestination().setAddress(await user1.getXmrNewSubaddress()).setAmount("100000000000");
  let tx: XmrTx|undefined = await user1.createXmrTx([destination]);
  testTx(tx, {isCreatedTx: true});

  // relay withdraw tx
  const txHash = await user1.relayXmrTx(tx.getMetadata());
  expect(txHash.length).toEqual(64);
  await wait(TestConfig.trade.walletSyncPeriodMs * 2); // wait for wallet to sync relayed tx

  // balances decreased
  const balancesAfter = await user1.getBalances();
  expect(BigInt(balancesAfter.getBalance())).toBeLessThan(BigInt(balancesBefore.getBalance()));
  expect(BigInt(balancesAfter.getAvailableBalance())).toBeLessThan(BigInt(balancesBefore.getAvailableBalance()));

  // get relayed tx
  tx = await user1.getXmrTx(txHash);
  testTx(tx!, {isCreatedTx: false});

  // relay invalid tx
  try {
    await user1.relayXmrTx("invalid tx metadata");
    throw new Error("Cannot relay invalid tx metadata");
  } catch (err: any) {
    if (err.message !== "Failed to parse hex.") throw new Error("Unexpected error: " + err.message);
  }
});

test("Can get balances (CI, sanity check)", async () => {
  const balances: XmrBalanceInfo = await user1.getBalances();
  expect(BigInt(balances.getAvailableBalance())).toBeGreaterThanOrEqual(0);
  expect(BigInt(balances.getPendingBalance())).toBeGreaterThanOrEqual(0);
  expect(BigInt(balances.getReservedOfferBalance())).toBeGreaterThanOrEqual(0);
  expect(BigInt(balances.getReservedTradeBalance())).toBeGreaterThanOrEqual(0);
});

test("Can send and receive push notifications (CI, sanity check)", async () => {

  // add notification listener
  const notifications: NotificationMessage[] = [];
  await user1.addNotificationListener(notification => {
    notifications.push(notification);
  });

  // send test notification
  for (let i = 0; i < 3; i++) {
    await user1._sendNotification(new NotificationMessage()
        .setTimestamp(Date.now())
        .setTitle("Test title " + i)
        .setMessage("Test message " + i));
  }

  // test notification
  await wait(1000);
  assert(notifications.length >= 3);
  for (let i = 0; i < 3; i++) {
    assert(notifications[i].getTimestamp() > 0);
    assert.equal(notifications[i].getTitle(), "Test title " + i);
    assert.equal(notifications[i].getMessage(), "Test message " + i);
  }
});

test("Can get asset codes with prices and their payment methods (CI, sanity check)", async() => {
  const assetCodes = await user1.getPricedAssetCodes();
  for (const assetCode of assetCodes) {
    const paymentMethods = await user1.getPaymentMethods(assetCode);
    expect(paymentMethods.length).toBeGreaterThanOrEqual(0);
  }
});

test("Can get market prices (CI, sanity check)", async () => {

  // get all market prices
  const prices: MarketPriceInfo[] = await user1.getPrices();
  expect(prices.length).toBeGreaterThan(1);
  for (const price of prices) {
    expect(price.getCurrencyCode().length).toBeGreaterThan(0);
    expect(price.getPrice()).toBeGreaterThanOrEqual(0);
  }

  // get market prices of primary assets
  for (const assetCode of TestConfig.assetCodes) {
    const price = await user1.getPrice(assetCode);
    expect(price).toBeGreaterThan(0);
  }

  // test that prices are reasonable
  const usd = await user1.getPrice("USD");
  expect(usd).toBeGreaterThan(50);
  expect(usd).toBeLessThan(5000);
  const ltc = await user1.getPrice("LTC");
  expect(ltc).toBeGreaterThan(0.0004);
  expect(ltc).toBeLessThan(40);
  const btc = await user1.getPrice("BTC");
  expect(btc).toBeGreaterThan(0.0004);
  expect(btc).toBeLessThan(0.4);

  // test invalid currency
  await expect(async () => { await user1.getPrice("INVALID_CURRENCY") })
    .rejects
    .toThrow('Currency not found: INVALID_CURRENCY');
});

test("Can get market depth (CI, sanity check)", async () => {
    const assetCode = "eth";

    // clear offers
    await clearOffers(user1, assetCode);
    await clearOffers(user2, assetCode);
    async function clearOffers(havenod: HavenoClient, assetCode: string) {
      for (const offer of await havenod.getMyOffers(assetCode)) {
        if (offer.getBaseCurrencyCode().toLowerCase() === assetCode.toLowerCase()) {
            await havenod.removeOffer(offer.getId());
        }
      }
    }

    // market depth has no data
    await wait(TestConfig.trade.maxTimePeerNoticeMs);
    let marketDepth = await user1.getMarketDepth(assetCode);
    expect(marketDepth.getBuyPricesList().length).toEqual(0);
    expect(marketDepth.getBuyDepthList().length).toEqual(0);
    expect(marketDepth.getSellPricesList().length).toEqual(0);
    expect(marketDepth.getSellDepthList().length).toEqual(0);

    // post offers to buy and sell
    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.BUY, offerAmount: 150000000000n, assetCode: assetCode, price: 17.0});
    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.BUY, offerAmount: 150000000000n, assetCode: assetCode, price: 17.2});
    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.BUY, offerAmount: 200000000000n, assetCode: assetCode, price: 17.3});
    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.BUY, offerAmount: 150000000000n, assetCode: assetCode, price: 17.3});
    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.SELL, offerAmount: 300000000000n, assetCode: assetCode, priceMargin: 0.00});
    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.SELL, offerAmount: 300000000000n, assetCode: assetCode, priceMargin: 0.02});
    await makeOffer({maker: {havenod: user1}, direction: OfferDirection.SELL, offerAmount: 400000000000n, assetCode: assetCode, priceMargin: 0.05});

    // get user2's market depth
    await wait(TestConfig.trade.maxTimePeerNoticeMs);
    marketDepth = await user1.getMarketDepth(assetCode);

    // each unique price has a depth
    expect(marketDepth.getBuyPricesList().length).toEqual(3);
    expect(marketDepth.getSellPricesList().length).toEqual(3);
    expect(marketDepth.getBuyPricesList().length).toEqual(marketDepth.getBuyDepthList().length);
    expect(marketDepth.getSellPricesList().length).toEqual(marketDepth.getSellDepthList().length);

    // test buy prices and depths
    const buyOffers = (await user1.getOffers(assetCode, OfferDirection.BUY)).concat(await user1.getMyOffers(assetCode, OfferDirection.BUY)).sort(function(a, b) { return parseFloat(a.getPrice()) - parseFloat(b.getPrice()) });
    expect(marketDepth.getBuyPricesList()[0]).toEqual(1 / parseFloat(buyOffers[0].getPrice())); // TODO: price when posting offer is reversed. this assumes crypto counter currency
    expect(marketDepth.getBuyPricesList()[1]).toEqual(1 / parseFloat(buyOffers[1].getPrice()));
    expect(marketDepth.getBuyPricesList()[2]).toEqual(1 / parseFloat(buyOffers[2].getPrice()));
    expect(marketDepth.getBuyDepthList()[0]).toEqual(0.15);
    expect(marketDepth.getBuyDepthList()[1]).toEqual(0.30);
    expect(marketDepth.getBuyDepthList()[2]).toEqual(0.65);

    // test sell prices and depths
    const sellOffers = (await user1.getOffers(assetCode, OfferDirection.SELL)).concat(await user1.getMyOffers(assetCode, OfferDirection.SELL)).sort(function(a, b) { return parseFloat(b.getPrice()) - parseFloat(a.getPrice()) });
    expect(marketDepth.getSellPricesList()[0]).toEqual(1 / parseFloat(sellOffers[0].getPrice()));
    expect(marketDepth.getSellPricesList()[1]).toEqual(1 / parseFloat(sellOffers[1].getPrice()));
    expect(marketDepth.getSellPricesList()[2]).toEqual(1 / parseFloat(sellOffers[2].getPrice()));
    expect(marketDepth.getSellDepthList()[0]).toEqual(0.3);
    expect(marketDepth.getSellDepthList()[1]).toEqual(0.6);
    expect(marketDepth.getSellDepthList()[2]).toEqual(1);

    // clear offers
    await clearOffers(user1, assetCode);
    await clearOffers(user2, assetCode);

    // test invalid currency
    await expect(async () => {await user1.getMarketDepth("INVALID_CURRENCY")})
        .rejects
        .toThrow('Currency not found: INVALID_CURRENCY');
});

test("Can register as an arbitrator (CI)", async () => {

  // test bad dispute agent type
  try {
    await arbitrator.registerDisputeAgent("unsupported type", getArbitratorPrivKey(0));
    throw new Error("should have thrown error registering bad type");
  } catch (err: any) {
    if (err.message !== "unknown dispute agent type 'unsupported type'") throw new Error("Unexpected error: " + err.message);
  }

  // test bad key
  try {
    await arbitrator.registerDisputeAgent("mediator", "bad key");
    throw new Error("should have thrown error registering bad key");
  } catch (err: any) {
    if (err.message !== "invalid registration key") throw new Error("Unexpected error: " + err.message);
  }

  // register arbitrator with good key
  await arbitrator.registerDisputeAgent("arbitrator", getArbitratorPrivKey(0));
});

test("Can get offers (CI)", async () => {
  for (const assetCode of TestConfig.assetCodes) {
    const offers: OfferInfo[] = await user1.getOffers(assetCode);
    for (const offer of offers)  testOffer(offer);
  }
});

test("Can get my offers (CI)", async () => {

  // get all offers
  const offers: OfferInfo[] = await user1.getMyOffers();
  for (const offer of offers) testOffer(offer);

  // get offers by asset code
  for (const assetCode of TestConfig.assetCodes) {
    const offers: OfferInfo[] = await user1.getMyOffers(assetCode);
    for (const offer of offers) {
      testOffer(offer);
      expect(assetCode).toEqual(isCrypto(assetCode) ? offer.getBaseCurrencyCode() : offer.getCounterCurrencyCode()); // crypto asset codes are base
    }
  }
});

test("Can get payment methods (CI)", async () => {
  const paymentMethods: PaymentMethod[] = await user1.getPaymentMethods();
  expect(paymentMethods.length).toBeGreaterThan(0);
  for (const paymentMethod of paymentMethods) {
    expect(paymentMethod.getId().length).toBeGreaterThan(0);
    expect(BigInt(paymentMethod.getMaxTradeLimit())).toBeGreaterThan(0n);
    expect(BigInt(paymentMethod.getMaxTradePeriod())).toBeGreaterThan(0n);
    expect(paymentMethod.getSupportedAssetCodesList().length).toBeGreaterThanOrEqual(0);
  }
});

test("Can get payment accounts (CI)", async () => {
  const paymentAccounts: PaymentAccount[] = await user1.getPaymentAccounts();
  for (const paymentAccount of paymentAccounts) {
    if (paymentAccount.getPaymentAccountPayload()!.getCryptoCurrencyAccountPayload()) { // TODO (woodser): test non-crypto
       testCryptoPaymentAccount(paymentAccount);
    }
  }
});

// TODO: FieldId represented as number
test("Can validate payment account forms (CI, sanity check)", async () => {

  // get payment methods
  const paymentMethods = await user1.getPaymentMethods();
  expect(paymentMethods.length).toEqual(TestConfig.paymentMethods.length);
  for (const paymentMethod of paymentMethods) {
    assert(moneroTs.GenUtils.arrayContains(TestConfig.paymentMethods, paymentMethod.getId()), "Payment method is not expected: " + paymentMethod.getId());
  }

  // test form for each payment method
  for (const paymentMethod of paymentMethods) {

    // generate form
    const accountForm = await user1.getPaymentAccountForm(paymentMethod.getId());

    // complete form, validating each field
    for (const field of accountForm.getFieldsList()) {

      // validate invalid form field
      try {
        const invalidInput = getInvalidFormInput(accountForm, field.getId());
        await user1.validateFormField(accountForm, field.getId(), invalidInput);
        throw new Error("Should have thrown error validating form field '" + field.getId() + "' with invalid value '" + invalidInput + "'");
      } catch (err: any) {
        if (err.message.indexOf("Not implemented") >= 0) throw err;
        if (err.message.indexOf("Should have thrown") >= 0) throw err;
      }

      // validate valid form field
      const validInput = getValidFormInput(accountForm, field.getId());
      await user1.validateFormField(accountForm, field.getId(), validInput);
      field.setValue(validInput);
    }

    // create payment account
    const paymentAccount = await user1.createPaymentAccount(accountForm);

    // payment account added
    let found = false;
    for (const userAccount of await user1.getPaymentAccounts()) {
      if (paymentAccount.getId() === userAccount.getId()) {
        found = true;
        break;
      }
    }
    assert(found, "Payment account not found after adding");

    // test payment account
    expect(paymentAccount.getPaymentMethod()!.getId()).toEqual(paymentMethod.getId());
    testPaymentAccount(paymentAccount, accountForm);

    // delete payment account
    // await user1.deletePaymentAccount(paymentAccount.getId()); // TODO: support deleting payment accounts over grpc
  }
});

test("Can create fiat payment accounts (CI)", async () => {

  // get payment account form
  const paymentMethodId = HavenoUtils.getPaymentMethodId(PaymentAccountForm.FormId.REVOLUT);
  const accountForm = await user1.getPaymentAccountForm(paymentMethodId);

  // edit form
  HavenoUtils.setFormValue(accountForm, PaymentAccountFormField.FieldId.ACCOUNT_NAME, "Revolut account " + moneroTs.GenUtils.getUUID());
  HavenoUtils.setFormValue(accountForm, PaymentAccountFormField.FieldId.USERNAME, "user123");
  HavenoUtils.setFormValue(accountForm, PaymentAccountFormField.FieldId.TRADE_CURRENCIES, "gbp,eur,usd");

  // create payment account
  const fiatAccount = await user1.createPaymentAccount(accountForm);
  expect(fiatAccount.getAccountName()).toEqual(HavenoUtils.getFormValue(accountForm, PaymentAccountFormField.FieldId.ACCOUNT_NAME));
  expect(fiatAccount.getSelectedTradeCurrency()!.getCode()).toEqual("USD");
  expect(fiatAccount.getTradeCurrenciesList().length).toBeGreaterThan(0);
  expect(fiatAccount.getPaymentAccountPayload()!.getPaymentMethodId()).toEqual(paymentMethodId);
  expect(fiatAccount.getPaymentAccountPayload()!.getRevolutAccountPayload()!.getUsername()).toEqual(HavenoUtils.getFormValue(accountForm, PaymentAccountFormField.FieldId.USERNAME));

  // payment account added
  let found = false;
  for (const paymentAccount of await user1.getPaymentAccounts()) {
    if (paymentAccount.getId() === fiatAccount.getId()) {
      found = true;
      break;
    }
  }
  assert(found, "Payment account not found after adding");

  // delete payment account
  await user1.deletePaymentAccount(fiatAccount.getId());

  // no longer has payment account
  try {
    await user1.getPaymentAccount(fiatAccount.getId());
    throw new Error("Should have thrown error getting deleted payment account");
  } catch (err: any) {
    if (err.message.indexOf("Should have thrown") >= 0) throw err;
  }
});

test("Can create crypto payment accounts (CI)", async () => {

  // test each crypto
  for (const testAccount of TestConfig.cryptoAddresses) {

    // create payment account
    const name = testAccount.currencyCode + " " + testAccount.address.substr(0, 8) + "... " + moneroTs.GenUtils.getUUID();
    const paymentAccount: PaymentAccount = await user1.createCryptoPaymentAccount(name, testAccount.currencyCode, testAccount.address);
    testCryptoPaymentAccount(paymentAccount);
    testCryptoPaymentAccountEquals(paymentAccount, testAccount, name);

    // fetch and test payment account
    let fetchedAccount: PaymentAccount|undefined;
    for (const account of await user1.getPaymentAccounts()) {
      if (paymentAccount.getId() === account.getId()) {
        fetchedAccount = account;
        break;
      }
    }
    if (!fetchedAccount) throw new Error("Payment account not found after being added");
    testCryptoPaymentAccount(paymentAccount);
    testCryptoPaymentAccountEquals(fetchedAccount, testAccount, name);

    // delete payment account
    await user1.deletePaymentAccount(paymentAccount.getId());

    // no longer has payment account
    try {
      await user1.getPaymentAccount(paymentAccount.getId());
      throw new Error("Should have thrown error getting deleted payment account");
    } catch (err: any) {
      if (err.message.indexOf("Should have thrown") >= 0) throw err;
    }
  }

  // test invalid currency code
  await expect(async () => { await user1.createCryptoPaymentAccount("My first account", "ABC", "123"); })
      .rejects
      .toThrow("crypto currency with code 'abc' not found");

  // test invalid address
  await expect(async () => { await user1.createCryptoPaymentAccount("My second account", "ETH", "123"); })
      .rejects
      .toThrow('123 is not a valid eth address');

  // test address duplicity
  let uid = "Unique account name " + moneroTs.GenUtils.getUUID();
  await user1.createCryptoPaymentAccount(uid, TestConfig.cryptoAddresses[0].currencyCode, TestConfig.cryptoAddresses[0].address)
  await expect(async () => { await user1.createCryptoPaymentAccount(uid, TestConfig.cryptoAddresses[0].currencyCode, TestConfig.cryptoAddresses[0].address); })
      .rejects
      .toThrow("Account '" + uid + "' is already taken");

  function testCryptoPaymentAccountEquals(paymentAccount: PaymentAccount, testAccount: any, name: string) {
    expect(paymentAccount.getAccountName()).toEqual(name);
    expect(paymentAccount.getPaymentAccountPayload()!.getCryptoCurrencyAccountPayload()!.getAddress()).toEqual(testAccount.address);
    expect(paymentAccount.getSelectedTradeCurrency()!.getCode()).toEqual(testAccount.currencyCode.toUpperCase());
  }
});

test("Can prepare for trading (CI)", async () => {
  await prepareForTrading(5, user1, user2);
});

test("Can post and remove an offer (CI, sanity check)", async () => {

  // wait for user1 to have unlocked balance to post offer
  await waitForAvailableBalance(250000000000n * 2n, user1);

  // get unlocked balance before reserving funds for offer
  const availableBalanceBefore = BigInt((await user1.getBalances()).getAvailableBalance());

  // post crypto offer
  let assetCode = "BCH";
  let price = 1 / 17;
  price = 1 / price; // TODO: price in crypto offer is inverted
  let offer: OfferInfo = await makeOffer({maker: {havenod: user1}, assetCode: assetCode, price: price});
  assert.equal(offer.getState(), "AVAILABLE");
  assert.equal(offer.getBaseCurrencyCode(), assetCode); // TODO: base and counter currencies inverted in crypto offer
  assert.equal(offer.getCounterCurrencyCode(), "XMR");
  assert.equal(parseFloat(offer.getPrice()), price);

  // has offer
  offer = await user1.getMyOffer(offer.getId());
  assert.equal(offer.getState(), "AVAILABLE");

  // peer sees offer
  await wait(TestConfig.trade.maxTimePeerNoticeMs);
  if (!getOffer(await user2.getOffers(assetCode, TestConfig.trade.direction), offer.getId())) throw new Error("Offer " + offer.getId() + " was not found in peer's offers after posted");

  // cancel offer
  await user1.removeOffer(offer.getId());

  // offer is removed from my offers
  if (getOffer(await user1.getMyOffers(assetCode, OfferDirection.BUY), offer.getId())) throw new Error("Offer " + offer.getId() + " was found in my offers after removal");

  // peer does not see offer
  await wait(TestConfig.trade.maxTimePeerNoticeMs);
  if (getOffer(await user2.getOffers(assetCode, TestConfig.trade.direction), offer.getId())) throw new Error("Offer " + offer.getId() + " was found in peer's offers after removed");

  // reserved balance released
  expect(BigInt((await user1.getBalances()).getAvailableBalance())).toEqual(availableBalanceBefore);

  // post fiat offer
  assetCode = "USD";
  price = 180.0;
  offer = await makeOffer({maker: {havenod: user1}, assetCode: assetCode, price: price});
  assert.equal(offer.getState(), "AVAILABLE");
  assert.equal(offer.getBaseCurrencyCode(), "XMR");
  assert.equal(offer.getCounterCurrencyCode(), "USD");
  assert.equal(parseFloat(offer.getPrice()), price);

  // has offer
  offer = await user1.getMyOffer(offer.getId());
  assert.equal(offer.getState(), "AVAILABLE");

  // peer sees offer
  await wait(TestConfig.trade.maxTimePeerNoticeMs);
  if (!getOffer(await user2.getOffers(assetCode, TestConfig.trade.direction), offer.getId())) throw new Error("Offer " + offer.getId() + " was not found in peer's offers after posted");

  // cancel offer
  await user1.removeOffer(offer.getId());

  // offer is removed from my offers
  if (getOffer(await user1.getMyOffers(assetCode, OfferDirection.BUY), offer.getId())) throw new Error("Offer " + offer.getId() + " was found in my offers after removal");

  // reserved balance released
  expect(BigInt((await user1.getBalances()).getAvailableBalance())).toEqual(availableBalanceBefore);

  // peer does not see offer
  await wait(TestConfig.trade.maxTimePeerNoticeMs);
  if (getOffer(await user2.getOffers(assetCode, TestConfig.trade.direction), offer.getId())) throw new Error("Offer " + offer.getId() + " was found in peer's offers after removed");
});

// TODO: provide number of confirmations in offer status
test("Can schedule offers with locked funds (CI)", async () => {
  let user3: HavenoClient|undefined;
  let err: any;
  try {

    // configure test
    const completeTrade = true;
    const resolveDispute = Math.random() < 0.5;

    // start user3
    user3 = await initHaveno();
    const user3Wallet = await moneroTs.connectToWalletRpc("http://127.0.0.1:" + user3.getWalletRpcPort(), TestConfig.defaultHavenod.walletUsername, TestConfig.defaultHavenod.accountPassword);

    // fund user3 with 2 outputs of 0.5 XMR
    const outputAmt = 500000000000n;
    await fundOutputs([user3Wallet], outputAmt, 2, false);

    // schedule offer
    const assetCode = "BCH";
    const direction = OfferDirection.BUY;
    const ctx = new TradeContext({maker: {havenod: user3}, assetCode: assetCode, direction: direction, awaitFundsToMakeOffer: false, reserveExactAmount: true});
    let offer: OfferInfo = await makeOffer(ctx);
    assert.equal(offer.getState(), "PENDING");

    // has offer
    offer = await user3.getMyOffer(offer.getId());
    assert.equal(offer.getState(), "PENDING");

    // balances unchanged
    expect(BigInt((await user3.getBalances()).getPendingBalance())).toEqual(outputAmt * 2n);
    expect(BigInt((await user3.getBalances()).getReservedOfferBalance())).toEqual(0n);

    // peer does not see offer because it's scheduled
    await wait(TestConfig.trade.maxTimePeerNoticeMs);
    if (getOffer(await user1.getOffers(assetCode, direction), offer.getId())) throw new Error("Offer " + offer.getId() + " was found in peer's offers before posted");

    // cancel offer
    await user3.removeOffer(offer.getId());
    if (getOffer(await user3.getOffers(assetCode, direction), offer.getId())) throw new Error("Offer " + offer.getId() + " was found after canceling offer");

    // balances unchanged
    expect(BigInt((await user3.getBalances()).getPendingBalance())).toEqual(outputAmt * 2n);
    expect(BigInt((await user3.getBalances()).getReservedOfferBalance())).toEqual(0n);

    // schedule offer
    offer = await makeOffer({maker: {havenod: user3}, assetCode: assetCode, direction: direction, awaitFundsToMakeOffer: false, reserveExactAmount: true});
    assert.equal(offer.getState(), "PENDING");

    // peer does not see offer because it's scheduled
    await wait(TestConfig.trade.maxTimePeerNoticeMs);
    if (getOffer(await user1.getOffers(assetCode, direction), offer.getId())) throw new Error("Offer " + offer.getId() + " was found in peer's offers before posted");

    // stop user3
    let user3Config = {appName: user3.getAppName()};
    await releaseHavenoProcess(user3);

    // mine 10 blocks
    await mineBlocks(10);

    // restart user3
    user3 = await initHaveno(user3Config);
    ctx.maker.havenod = user3;

    // awaiting split output
    await waitForAvailableBalance(outputAmt, user3);
    offer = await user3.getMyOffer(offer.getId());
    assert.equal(offer.getState(), "PENDING");

    // stop user3
    user3Config = {appName: user3.getAppName()};
    await releaseHavenoProcess(user3);

    // mine 10 blocks
    await mineBlocks(10);

    // restart user3
    user3 = await initHaveno(user3Config);
    ctx.maker.havenod = user3;

    // offer is available
    await waitForAvailableBalance(outputAmt + outputAmt / 2n, user3);
    await wait(TestConfig.trade.walletSyncPeriodMs);
    offer = await user3.getMyOffer(offer.getId());
    assert.equal(offer.getState(), "AVAILABLE");
    ctx.maker.splitOutputTxFee = BigInt(offer.getSplitOutputTxFee());

    // one output is reserved, remaining is unlocked
    const balances = await user3.getBalances();
    expect(BigInt((balances.getPendingBalance()))).toEqual(0n);
    expect(BigInt((balances.getAvailableBalance()))).toBeGreaterThan(outputAmt); // TODO: testScheduleOffer(reserveExactAmount) to test these
    expect(BigInt((balances.getReservedOfferBalance()))).toEqual(outputAmt * 2n - ctx.maker.splitOutputTxFee! - BigInt(balances.getAvailableBalance()));

    // peer sees offer
    await wait(TestConfig.trade.maxTimePeerNoticeMs);
    if (!getOffer(await user1.getOffers(assetCode, direction), offer.getId())) throw new Error("Offer " + offer.getId() + " was not found in peer's offers after posted");

    // complete trade or cancel offer depending on configuration
    if (completeTrade) {
      HavenoUtils.log(1, "Completing trade from scheduled offer, opening and resolving dispute: " + resolveDispute);
      await executeTrade(Object.assign(ctx, {buyerDisputeContext: resolveDispute ? DisputeContext.OPEN_AFTER_DEPOSITS_UNLOCK : DisputeContext.NONE}));
    } else {

      // cancel offer
      await user3.removeOffer(offer.getId());

      // offer is removed from my offers
      if (getOffer(await user3.getMyOffers(assetCode), offer.getId())) throw new Error("Offer " + offer.getId() + " was found in my offers after removal");

      // reserved balance becomes unlocked
      expect(BigInt((await user3.getBalances()).getAvailableBalance())).toEqual(outputAmt * 2n);
      expect(BigInt((await user3.getBalances()).getPendingBalance())).toEqual(0n);
      expect(BigInt((await user3.getBalances()).getReservedOfferBalance())).toEqual(0n);
    }
  } catch (err2) {
    err = err2;
  }

  // stop and delete instances
  if (user3) await releaseHavenoProcess(user3, true);
  if (err) throw err;
});

test("Can reserve exact amount needed for offer (CI)", async () => {
  let randomOfferAmount = 1.0 + (Math.random() * 1.0); // random amount between 1 and 2 xmr
  await executeTrade({
    price: 150,
    offerAmount: HavenoUtils.xmrToAtomicUnits(randomOfferAmount),
    offerMinAmount: HavenoUtils.xmrToAtomicUnits(.15),
    tradeAmount: HavenoUtils.xmrToAtomicUnits(.92),
    reserveExactAmount: true,
    testBalanceChangeEndToEnd: true
  });
});

test("Cannot post offer exceeding trade limit (CI, sanity check)", async () => {
  let assetCode = "USD";
  const account = await createPaymentAccount(user1, assetCode, "zelle");

  // test posting buy offer above limit
  try {
    await executeTrade({
      offerAmount: moneroTs.MoneroUtils.xmrToAtomicUnits(3.1),
      direction: OfferDirection.BUY,
      assetCode: assetCode,
      makerPaymentAccountId: account.getId(),
      takeOffer: false
    });
    throw new Error("Should have rejected posting offer above trade limit")
  } catch (err: any) {
    assert(err.message.indexOf("amount is larger than") === 0);
  }

  // test posting sell offer above limit
  try {
    await executeTrade({
      offerAmount: moneroTs.MoneroUtils.xmrToAtomicUnits(12.1),
      direction: OfferDirection.SELL,
      assetCode: assetCode,
      makerPaymentAccountId: account.getId(),
      takeOffer: false
    });
    throw new Error("Should have rejected posting offer above trade limit")
  } catch (err: any) {
    assert(err.message.indexOf("amount is larger than") === 0);
  }

  // test that sell limit is higher than buy limit
  let offerId = await executeTrade({
    offerAmount: 2100000000000n,
    direction: OfferDirection.SELL,
    assetCode: assetCode,
    makerPaymentAccountId: account.getId(),
    takeOffer: false
  });
  await user1.removeOffer(offerId);
});

test("Can complete a trade within a range", async () => {

  // create payment accounts
  let paymentMethodId = "cash_at_atm";
  let assetCode = "aud";
  let makerPaymentAccount = await createPaymentAccount(user1, assetCode, paymentMethodId); // TODO: support getPaymentAccount() which gets or creates
  let takerPaymentAccount = await createPaymentAccount(user2, assetCode, paymentMethodId);

  // get trade statistics before
  const tradeStatisticsPre = await arbitrator.getTradeStatistics();

  // execute trade
  const offerAmount = HavenoUtils.xmrToAtomicUnits(2);
  const offerMinAmount = HavenoUtils.xmrToAtomicUnits(.15);
  const tradeAmount = getRandomBigIntWithinRange(offerMinAmount, offerAmount);
  const ctx: Partial<TradeContext> = {
    price: 142.23,
    offerAmount: offerAmount,
    offerMinAmount: offerMinAmount,
    tradeAmount: tradeAmount,
    testPayoutUnlocked: true, // override to test unlock
    makerPaymentAccountId: makerPaymentAccount.getId(),
    takerPaymentAccountId: takerPaymentAccount.getId(),
    assetCode: assetCode,
    testBalanceChangeEndToEnd: true
  }
  await executeTrade(ctx);

  // test trade statistics after
  if (ctx.buyerSendsPayment && ctx.sellerReceivesPayment) {
    const tradeStatisticsPost = await arbitrator.getTradeStatistics();
    assert(tradeStatisticsPost.length - tradeStatisticsPre.length === 1);
  }
});

test("Can complete trades at the same time (CI, sanity check)", async () => {

  // create trade contexts with customized payment methods and random amounts
  const ctxs = getTradeContexts(TestConfig.assetCodes.length);
  for (let i = 0; i < ctxs.length; i++) {
    ctxs[i].assetCode = TestConfig.assetCodes[i]; // test each asset code
    ctxs[i].offerAmount = getRandomBigIntWithinPercent(TestConfig.trade.offerAmount!, 0.15);
    let paymentMethodId;
    if (ctxs[i].assetCode === "USD") paymentMethodId = "zelle";
    if (ctxs[i].assetCode === "EUR") paymentMethodId = "revolut";
    ctxs[i].makerPaymentAccountId = (await createPaymentAccount(ctxs[i].maker.havenod!, ctxs[i].assetCode!, paymentMethodId)).getId();
    ctxs[i].takerPaymentAccountId = (await createPaymentAccount(ctxs[i].taker.havenod!, ctxs[i].assetCode!, paymentMethodId)).getId();
  }

  // execute trades with capped concurrency for CI tests
  await executeTrades(ctxs);
});

test("Can complete all trade combinations (stress)", async () => {

  // generate trade context for each combination (buyer/seller, maker/taker, dispute(s), dispute winner)
  let ctxs: TradeContext[] = [];
  const MAKER_OPTS = [TradeRole.MAKER, TradeRole.TAKER];
  const DIRECTION_OPTS = [OfferDirection.BUY, OfferDirection.SELL];
  const BUYER_DISPUTE_OPTS = [DisputeContext.NONE, DisputeContext.OPEN_AFTER_DEPOSITS_UNLOCK, DisputeContext.OPEN_AFTER_PAYMENT_SENT];
  const SELLER_DISPUTE_OPTS = [DisputeContext.NONE, DisputeContext.OPEN_AFTER_DEPOSITS_UNLOCK, DisputeContext.OPEN_AFTER_PAYMENT_SENT];
  const DISPUTE_WINNER_OPTS = [DisputeResult.Winner.BUYER, DisputeResult.Winner.SELLER];
  for (let i = 0; i < MAKER_OPTS.length; i++) {
    for (let j = 0; j < DIRECTION_OPTS.length; j++) {
      for (let k = 0; k < BUYER_DISPUTE_OPTS.length; k++) {
        for (let l = 0; l < SELLER_DISPUTE_OPTS.length; l++) {
          for (let m = 0; m < DISPUTE_WINNER_OPTS.length; m++) {
            if (BUYER_DISPUTE_OPTS[k] !== DisputeContext.NONE && SELLER_DISPUTE_OPTS[l] !== DisputeContext.NONE) continue; // skip both opening a dispute
            const ctx: Partial<TradeContext> = {
              walletSyncPeriodMs: 8000, // increase for stress test
              maxTimePeerNoticeMs: 8000,
              maker: { havenod: MAKER_OPTS[i] === TradeRole.MAKER ? user1 : user2 },
              taker: { havenod: MAKER_OPTS[i] === TradeRole.MAKER ? user2 : user1 },
              direction: DIRECTION_OPTS[j],
              buyerDisputeContext: BUYER_DISPUTE_OPTS[k],
              sellerDisputeContext: SELLER_DISPUTE_OPTS[l],
              disputeWinner: DISPUTE_WINNER_OPTS[m],
              disputeSummary: "After much deliberation, " + (DISPUTE_WINNER_OPTS[m] === DisputeResult.Winner.BUYER ? "buyer" : "seller") + " is winner",
              offerAmount: getRandomBigIntWithinPercent(TestConfig.trade.offerAmount!, 0.15)
            };
            ctxs.push(Object.assign({}, new TradeContext(TestConfig.trade), ctx));
          }
        }
      }
    }
  }

  // execute trades
  const ctxIdx = undefined; // run single index for debugging
  if (ctxIdx !== undefined) ctxs = ctxs.slice(ctxIdx, ctxIdx + 1);
  HavenoUtils.log(0, "Executing " + ctxs.length + " trade configurations");
  await executeTrades(ctxs);
});

test("Can go offline while completing a trade (CI, sanity check)", async () => {
  let traders: HavenoClient[] = [];
  let ctx: TradeContext = new TradeContext(TestConfig.trade);
  let err: any;
  try {

    // start 2 trader processes
    HavenoUtils.log(1, "Starting trader processes");
    traders = await initHavenos(2);

    // fund traders
    HavenoUtils.log(1, "Funding traders");
    const tradeAmount = 250000000000n;
    await waitForAvailableBalance(tradeAmount * 2n, ...traders);

    // create trade config
    ctx.maker.havenod = traders[0];
    ctx.taker.havenod = traders[1];
    ctx.buyerOfflineAfterTake = true;
    ctx.sellerOfflineAfterTake = true;
    ctx.buyerOfflineAfterPaymentSent = true;

    // execute trade
    await executeTrade(ctx);
  } catch (e) {
    err = e;
  }

  // stop traders
  if (ctx.maker.havenod) await releaseHavenoProcess(ctx.maker.havenod, true);
  if (ctx.taker.havenod) await releaseHavenoProcess(ctx.taker.havenod, true);
  if (err) throw err;
});

test("Can resolve a dispute (CI)", async () => {

  // create payment accounts
  let paymentMethodId = "revolut";
  let assetCode = "usd";
  let makerPaymentAccount = await createPaymentAccount(user1, assetCode, paymentMethodId);
  let takerPaymentAccount = await createPaymentAccount(user2, assetCode, paymentMethodId);

  // execute trade
  await executeTrade({
    price: 142.23,
    offerAmount: HavenoUtils.xmrToAtomicUnits(2),
    offerMinAmount: HavenoUtils.xmrToAtomicUnits(.15),
    tradeAmount: HavenoUtils.xmrToAtomicUnits(1),
    testPayoutUnlocked: true, // override to test unlock
    makerPaymentAccountId: makerPaymentAccount.getId(),
    takerPaymentAccountId: takerPaymentAccount.getId(),
    assetCode: assetCode,
    buyerDisputeContext: DisputeContext.OPEN_AFTER_DEPOSITS_UNLOCK,
    disputeWinner: DisputeResult.Winner.SELLER,
    disputeWinnerAmount: HavenoUtils.xmrToAtomicUnits(.767),
    disputeReason: DisputeResult.Reason.OTHER,
    disputeSummary: "Payment not completed, so returning trade amount to seller.",
    testBalanceChangeEndToEnd: true
  });

  // TODO: test receiver = BUYER
});

test("Can resolve disputes (CI)", async () => {
  
  // execute all configs unless config index given
  let configIdx = undefined;
  let testBalancesSequentially = false; // runs each config sequentially to test balances before and after // TODO: this test takes much longer to run in sequence in order to test balances. use test weight config

  // create test configurations which stop before payment sent
  const ctxs = getTradeContexts(4);
  for (const config of ctxs) config.buyerSendsPayment = false;
  Object.assign(ctxs[3], {
    offerAmount: HavenoUtils.xmrToAtomicUnits(1),
    offerMinAmount: HavenoUtils.xmrToAtomicUnits(.15),
    tradeAmount: HavenoUtils.xmrToAtomicUnits(.578),
  });

  // initiate trades
  const tradeIds = await executeTrades(ctxs.slice(configIdx, configIdx === undefined ? undefined : configIdx + 1));

  // open disputes at same time but do not resolve
  const trade1 = await user1.getTrade(tradeIds[configIdx === undefined ? 1 : 0]);
  const trade2 = await user1.getTrade(tradeIds[configIdx === undefined ? 2 : 0]);
  Object.assign(ctxs[0], {
    resolveDispute: false,
    sellerDisputeContext: DisputeContext.OPEN_AFTER_DEPOSITS_UNLOCK,
    disputeWinner: DisputeResult.Winner.SELLER,
    disputeReason: DisputeResult.Reason.PEER_WAS_LATE,
    disputeSummary: "Seller is winner"
  });
  Object.assign(ctxs[1], {
    resolveDispute: false,
    buyerDisputeContext: DisputeContext.OPEN_AFTER_DEPOSITS_UNLOCK,
    disputeWinner: DisputeResult.Winner.BUYER,
    disputeReason: DisputeResult.Reason.SELLER_NOT_RESPONDING,
    disputeSummary: "Split trade amount",
    disputeWinnerAmount: BigInt(trade1.getAmount()) / 2n + BigInt(trade1.getBuyerSecurityDeposit())
  });
  Object.assign(ctxs[2], {
    resolveDispute: false,
    buyerDisputeContext: DisputeContext.OPEN_AFTER_DEPOSITS_UNLOCK,
    disputeWinner: DisputeResult.Winner.SELLER,
    disputeReason: DisputeResult.Reason.TRADE_ALREADY_SETTLED,
    disputeSummary: "Seller gets everything",
    disputeWinnerAmount: BigInt(trade2.getAmount()) + BigInt(trade2.getBuyerSecurityDeposit()) + BigInt(trade2.getSellerSecurityDeposit())
  });
  Object.assign(ctxs[3], {
    resolveDispute: false,
    buyerSendsPayment: true,
    sellerDisputeContext: DisputeContext.OPEN_AFTER_PAYMENT_SENT,
    disputeWinner: DisputeResult.Winner.BUYER,
    disputeReason: DisputeResult.Reason.TRADE_ALREADY_SETTLED,
    disputeSummary: "Buyer wins dispute after sending payment",
    disputeWinnerAmount: HavenoUtils.xmrToAtomicUnits(.1171),
  });
  HavenoUtils.log(1, "Opening disputes");
  await executeTrades(ctxs.slice(configIdx, configIdx === undefined ? undefined : configIdx + 1));

  // resolve disputes
  for (const ctx of ctxs) {
    ctx.resolveDispute = true;
    ctx.testPayoutUnlocked = false;
  }
  HavenoUtils.log(1, "Resolving disputes");
  await executeTrades(ctxs.slice(configIdx, configIdx === undefined ? undefined : configIdx + 1), {concurrentTrades: !testBalancesSequentially});
});

test("Can go offline while resolving a dispute (CI)", async () => {
  let traders: HavenoClient[] = [];
  let ctx: Partial<TradeContext> = {};
  let err: any;
  try {

    // start trader processes
    HavenoUtils.log(1, "Starting trader processes");
    traders = await initHavenos(2);

    // create trade config
    ctx = new TradeContext({
      maker: {havenod: traders[0]},
      taker: {havenod: traders[1]},
      buyerOfflineAfterTake: true,
      sellerOfflineAfterDisputeOpened: true,
      buyerOfflineAfterDisputeOpened: false,
      sellerDisputeContext: DisputeContext.OPEN_AFTER_DEPOSITS_UNLOCK,
      disputeWinner: DisputeResult.Winner.SELLER,
      disputeReason: DisputeResult.Reason.NO_REPLY,
      disputeSummary: "Seller wins dispute because buyer has not replied",
      testPayoutUnlocked: false
    });

    // fund traders
    const tradeAmount = 250000000000n;
    await waitForAvailableBalance(tradeAmount * 2n, ...traders);

    // execute trade
    await executeTrade(ctx);
  } catch (e) {
    err = e;
  }

  // stop and delete traders
  if (ctx.maker && ctx.maker.havenod) await releaseHavenoProcess(ctx.maker!.havenod!, true);
  if (ctx.taker && ctx.taker.havenod) await releaseHavenoProcess(ctx.taker!.havenod!, true); // closing this client after first induces HttpClientImpl.shutdown() to hang, so this tests timeout handling
  if (ctx.sellerAppName) deleteHavenoInstanceByAppName(ctx.sellerAppName!); // seller is offline
  if (err) throw err;
});

test("Cannot make or take offer with insufficient unlocked funds (CI, sanity check)", async () => {
  let user3: HavenoClient|undefined;
  let err: any;
  try {

    // start user3
    user3 = await initHaveno();

    // user3 creates payment account
    const paymentAccount = await createPaymentAccount(user3, TestConfig.trade.assetCode!);

    // user3 cannot make offer with insufficient funds
    try {
      await makeOffer({maker: {havenod: user3}, makerPaymentAccountId: paymentAccount.getId(), awaitFundsToMakeOffer: false});
      throw new Error("Should have failed making offer with insufficient funds")
    } catch (err: any) {
      if (!err.message.includes("not enough money")) throw err;
      const errTyped = err as HavenoError;
      assert.equal(errTyped.code, 2);
    }

    // user1 gets or posts offer
    const offers: OfferInfo[] = await user1.getMyOffers(TestConfig.trade.assetCode);
    let offer: OfferInfo;
    if (offers.length) offer = offers[0];
    else {
      const tradeAmount = 250000000000n;
      await waitForAvailableBalance(tradeAmount * 2n, user1);
      offer = await makeOffer({maker: {havenod: user1}, offerAmount: tradeAmount, awaitFundsToMakeOffer: false});
      assert.equal(offer.getState(), "AVAILABLE");
      await wait(TestConfig.trade.walletSyncPeriodMs * 2);
    }

    // user3 cannot take offer with insufficient funds
    try {
      await user3.takeOffer(offer.getId(), paymentAccount.getId());
      throw new Error("Should have failed taking offer with insufficient funds")
    } catch (err: any) {
      const errTyped = err as HavenoError;
      assert(errTyped.message.includes("not enough money"), "Unexpected error: " + errTyped.message);
      assert.equal(errTyped.code, 2);
    }

    // user3 does not have trade
    try {
      await user3.getTrade(offer.getId());
    } catch (err: any) {
      const errTyped = err as HavenoError;
      assert.equal(errTyped.code, 3);
      assert(errTyped.message.includes("trade with id '" + offer.getId() + "' not found"));
    }

    // remove offer if posted
    if (!offers.length) await user1.removeOffer(offer.getId());
  } catch (err2) {
    err = err2;
  }

  // stop user3
  if (user3) await releaseHavenoProcess(user3, true);
  if (err) throw err;
});

test("Invalidates offers when reserved funds are spent (CI)", async () => {
  let err;
  let tx;
  try {
    
    // wait for user1 to have unlocked balance for trade
    const tradeAmount = 250000000000n;
    await waitForAvailableBalance(tradeAmount * 2n, user1);

    // get frozen key images before posting offer
    const frozenKeyImagesBefore: any[] = [];
    for (const frozenOutput of await user1Wallet.getOutputs({isFrozen: true})) frozenKeyImagesBefore.push(frozenOutput.getKeyImage().getHex());

    // post offer
    await wait(1000);
    const assetCode = getRandomAssetCode();
    const offer: OfferInfo = await makeOffer({maker: {havenod: user1}, assetCode: assetCode, offerAmount: tradeAmount});

    // get key images reserved by offer
    const reservedKeyImages: any[] = [];
    const frozenKeyImagesAfter: any[] = [];
    for (const frozenOutput of await user1Wallet.getOutputs({isFrozen: true})) frozenKeyImagesAfter.push(frozenOutput.getKeyImage().getHex());
    for (const frozenKeyImageAfter of frozenKeyImagesAfter) {
      if (!frozenKeyImagesBefore.includes(frozenKeyImageAfter)) reservedKeyImages.push(frozenKeyImageAfter);
    }

    // offer is available to peers
    await wait(TestConfig.trade.walletSyncPeriodMs * 2);
    if (!getOffer(await user2.getOffers(assetCode, OfferDirection.BUY), offer.getId())) throw new Error("Offer " + offer.getId() + " was not found in peer's offers after posting");

    // spend one of offer's reserved outputs
    if (!reservedKeyImages.length) throw new Error("No reserved key images detected");
    await user1Wallet.thawOutput(reservedKeyImages[0]);
    tx = await user1Wallet.sweepOutput({keyImage: reservedKeyImages[0], address: await user1Wallet.getPrimaryAddress(), relay: false});
    await monerod.submitTxHex(tx.getFullHex()!, true);

    // mine block so spend is confirmed
    await mineBlocks(1);

    // offer is removed from peer offers
    await wait(20000);
    if (getOffer(await user2.getOffers(assetCode, OfferDirection.BUY), offer.getId())) throw new Error("Offer " + offer.getId() + " was found in peer's offers after reserved funds spent");

    // offer is removed from my offers
    if (getOffer(await user1.getMyOffers(assetCode, OfferDirection.BUY), offer.getId())) throw new Error("Offer " + offer.getId() + " was found in my offers after reserved funds spent");

    // offer is automatically cancelled
    try {
      await user1.removeOffer(offer.getId());
      throw new Error("cannot remove invalidated offer");
    } catch (err: any) {
      if (err.message === "cannot remove invalidated offer") throw new Error("Unexpected error: " + err.message);
    }
  } catch (err2) {
    err = err2;
  }

  // flush tx from pool
  if (tx) await monerod.flushTxPool(tx.getHash());
  if (err) throw err;
});

// TODO (woodser): test arbitrator state too
// TODO (woodser): test breaking protocol after depositing to multisig (e.g. don't send payment account payload by deleting it)
test("Can handle unexpected errors during trade initialization", async () => {
  let traders: HavenoClient[] = [];
  let err: any;
  try {

    // start and fund 3 trader processes
    HavenoUtils.log(1, "Starting trader processes");
    traders = await initHavenos(3);
    HavenoUtils.log(1, "Funding traders");
    const tradeAmount = 250000000000n;
    await waitForAvailableBalance(tradeAmount * 2n, traders[0], traders[1], traders[2]);

    // trader 0 posts offer
    HavenoUtils.log(1, "Posting offer");
    let offer = await makeOffer({maker: {havenod: traders[0]}, offerAmount: tradeAmount});
    offer = await traders[0].getMyOffer(offer.getId());
    assert.equal(offer.getState(), "AVAILABLE");

    // wait for offer to be seen
    await wait(TestConfig.trade.walletSyncPeriodMs * 2);

    // trader 1 spends trade funds after initializing trade
    let paymentAccount = await createCryptoPaymentAccount(traders[1]);
    wait(3000).then(async function() {
      try {
        const traderWallet = await moneroTs.connectToWalletRpc("http://localhost:" + traders[1].getWalletRpcPort(), TestConfig.defaultHavenod.walletUsername, TestConfig.defaultHavenod.accountPassword);
        for (const frozenOutput of await traderWallet.getOutputs({isFrozen: true})) await traderWallet.thawOutput(frozenOutput.getKeyImage().getHex());
        HavenoUtils.log(1, "Sweeping trade funds");
        await traderWallet.sweepUnlocked({address: await traderWallet.getPrimaryAddress(), relay: true});
      } catch (err: any) {
        console.log("Caught error sweeping funds!");
        console.log(err);
      }
    });

    // trader 1 tries to take offer
    try {
      HavenoUtils.log(1, "Trader 1 taking offer " + offer.getId());
      await traders[1].takeOffer(offer.getId(), paymentAccount.getId());
      throw new Error("Should have failed taking offer because taker trade funds spent")
    } catch (err: any) {
      assert(err.message.includes("not enough unlocked money"), "Unexpected error: " + err.message);
    }

    // TODO: test it's unavailable right after taking (taker will know before maker)

    // trader 0's offer remains available
    await wait(15000); // give time for trade initialization to fail and offer to become available
    offer = await traders[0].getMyOffer(offer.getId());
    if (offer.getState() !== "AVAILABLE") {
      HavenoUtils.log(1, "Offer is not yet available, waiting to become available after timeout..."); // TODO (woodser): fail trade on nack during initialization to save a bunch of time
      await wait(TestConfig.tradeStepTimeoutMs); // wait for offer to become available after timeout
      offer = await traders[0].getMyOffer(offer.getId());
      assert.equal(offer.getState(), "AVAILABLE");
    }

    // trader 0 spends trade funds after trader 2 takes offer
    wait(3000).then(async function() {
      try {
        const traderWallet = await moneroTs.connectToWalletRpc("http://localhost:" + traders[0].getWalletRpcPort(), TestConfig.defaultHavenod.walletUsername, TestConfig.defaultHavenod.accountPassword);
        for (const frozenOutput of await traderWallet.getOutputs({isFrozen: true})) await traderWallet.thawOutput(frozenOutput.getKeyImage().getHex());
        HavenoUtils.log(1, "Sweeping offer funds");
        await traderWallet.sweepUnlocked({address: await traderWallet.getPrimaryAddress(), relay: true});
      } catch (err: any) {
        console.log("Caught error sweeping funds!");
        console.log(err);
      }
    });

    // trader 2 tries to take offer
    paymentAccount = await createCryptoPaymentAccount(traders[2]);
    try {
      HavenoUtils.log(1, "Trader 2 taking offer")
      await traders[2].takeOffer(offer.getId(), paymentAccount.getId());
      throw new Error("Should have failed taking offer because maker trade funds spent")
    } catch (err: any) {

      // determine if error is expected
      let expected = false;
      const expectedErrMsgs = ["not enough unlocked money", "timeout reached. protocol did not complete", "trade is already taken"];
      for (const expectedErrMsg of expectedErrMsgs) {
        if (err.message.indexOf(expectedErrMsg) >= 0) {
          expected = true;
          break;
        }
      }
      if (!expected) throw err;
    }

    // trader 2's balance is unreserved
    const trader2Balances = await traders[2].getBalances();
    expect(BigInt(trader2Balances.getReservedTradeBalance())).toEqual(0n);
    expect(BigInt(trader2Balances.getAvailableBalance())).toBeGreaterThan(0n);
  } catch (err2) {
    err = err2;
  }

  // stop traders
  for (const trader of traders) await releaseHavenoProcess(trader, true);
  if (err) throw err;
});

// TODO: test opening and resolving dispute as arbitrator and traders go offline
test("Selects arbitrators which are online, registered, and least used", async () => {

  // complete 2 trades using main arbitrator so it's most used
  // TODO: these trades are not registered with seednode until it's restarted
  HavenoUtils.log(1, "Preparing for trades");
  await prepareForTrading(4, user1, user2);
  HavenoUtils.log(1, "Completing trades with main arbitrator");
  await executeTrades(getTradeContexts(2), {testPayoutConfirmed: false});

  // start and register arbitrator2
  let arbitrator2 = await initHaveno();
  HavenoUtils.log(1, "Registering arbitrator2");
  await arbitrator2.registerDisputeAgent("arbitrator", getArbitratorPrivKey(1)); // TODO: re-registering with same address corrupts messages (Cannot decrypt) because existing pub key; overwrite? or throw when registration fails because dispute map can't be updated
  await wait(TestConfig.trade.walletSyncPeriodMs * 2);

  // get internal api addresses
  const arbitrator1ApiUrl = "localhost:" + TestConfig.ports.get(getPort(arbitrator.getUrl()))![1]; // TODO: havenod.getApiUrl()?
  const arbitrator2ApiUrl = "localhost:" + TestConfig.ports.get(getPort(arbitrator2.getUrl()))![1];

  let err = undefined;
  try {

    // post offers signed by each arbitrator randomly
    HavenoUtils.log(1, "Posting offers signed by both arbitrators randomly");
    let offer1: OfferInfo | undefined;
    let offer2: OfferInfo | undefined;
    while (true) {
      const offer = await makeOffer({maker: {havenod: user1}});
      if (offer.getArbitratorSigner() === arbitrator1ApiUrl && !offer1) offer1 = offer;
      else if (offer.getArbitratorSigner() === arbitrator2ApiUrl && !offer2) offer2 = offer;
      else await user1.removeOffer(offer.getId());
      if (offer1 && offer2) break;
    }
    await wait(TestConfig.trade.walletSyncPeriodMs * 2);

    // complete a trade which uses arbitrator2 since it's least used
    HavenoUtils.log(1, "Completing trade using arbitrator2");
    await executeTrade({maker: {havenod: user1}, taker: {havenod: user2}, arbitrator: {havenod: arbitrator2}, offerId: offer1.getId(), makerPaymentAccountId: offer1.getPaymentAccountId(), testPayoutConfirmed: false});
    let trade = await user1.getTrade(offer1.getId());
    assert.equal(trade.getArbitratorNodeAddress(), arbitrator2ApiUrl);

    // arbitrator2 goes offline without unregistering
    HavenoUtils.log(1, "Arbitrator2 going offline");
    const arbitrator2AppName = arbitrator2.getAppName()
    await releaseHavenoProcess(arbitrator2);

    // post offer which uses main arbitrator since arbitrator2 is offline
    HavenoUtils.log(1, "Posting offer which uses main arbitrator since arbitrator2 is offline");
    let offer = await makeOffer({maker: {havenod: user1}});
    assert.equal(offer.getArbitratorSigner(), arbitrator1ApiUrl);
    await user1.removeOffer(offer.getId());

    // complete a trade which uses main arbitrator since arbitrator2 is offline
    HavenoUtils.log(1, "Completing trade using main arbitrator since arbitrator2 is offline");
    await executeTrade({maker: {havenod: user1}, taker: {havenod: user2}, offerId: offer2.getId(), makerPaymentAccountId: offer2.getPaymentAccountId(), testPayoutConfirmed: false});
    trade = await user1.getTrade(offer2.getId());
    assert.equal(trade.getArbitratorNodeAddress(), arbitrator1ApiUrl);

    // start and unregister arbitrator2
    HavenoUtils.log(1, "Starting and unregistering arbitrator2");
    arbitrator2 = await initHaveno({appName: arbitrator2AppName});
    await arbitrator2.unregisterDisputeAgent("arbitrator");
    await wait(TestConfig.trade.walletSyncPeriodMs * 2);

    // cannot take offers signed by unregistered arbitrator
    HavenoUtils.log(1, "Taking offer signed by unregistered arbitrator");
    try {
    await executeTrade({maker: {havenod: user1}, taker: {havenod: user2}, offerId: offer2.getId()});
      throw new Error("Should have failed taking offer signed by unregistered arbitrator");
    } catch (e2: any) {
      assert (e2.message.indexOf("not found") > 0);
    }

    // TODO: offer is removed and unreserved or re-signed, ideally keeping the same id

    // post offer which uses main arbitrator since arbitrator2 is unregistered
    offer = await makeOffer({maker: {havenod: user1}});
    assert.equal(offer.getArbitratorSigner(), arbitrator1ApiUrl);
    await wait(TestConfig.trade.walletSyncPeriodMs * 2);

    // complete a trade which uses main arbitrator since arbitrator2 is unregistered
    HavenoUtils.log(1, "Completing trade with main arbitrator since arbitrator2 is unregistered");
    await executeTrade({maker: {havenod: user1}, taker: {havenod: user2}, offerId: offer.getId(), makerPaymentAccountId: offer.getPaymentAccountId(), testPayoutConfirmed: false});
    HavenoUtils.log(1, "Done completing trade with main arbitrator since arbitrator2 is unregistered");
    trade = await user2.getTrade(offer.getId());
    HavenoUtils.log(1, "Done getting trade");
    assert.equal(trade.getArbitratorNodeAddress(), arbitrator1ApiUrl);

    // release arbitrator2
    HavenoUtils.log(1, "Done getting trade");
    await releaseHavenoProcess(arbitrator2, true);
  } catch (e) {
    err = e;
  }

  // cleanup if error
  if (err) {
    try { await arbitrator2.unregisterDisputeAgent("arbitrator"); }
    catch (err) { /*ignore*/ }
    await releaseHavenoProcess(arbitrator2, true);
    throw err;
  }
});

test("Can get trade statistics", async () => {
  const tradeStatisticsArbitrator = await arbitrator.getTradeStatistics();
  const tradeStatisticsUser1 = await user1.getTradeStatistics();
  const tradeStatisticsUser2 = await user2.getTradeStatistics();
  HavenoUtils.log(0, "Trade statistics size (arb/u1/u2): " + tradeStatisticsArbitrator.length + "/" + tradeStatisticsUser1.length + "/" + tradeStatisticsUser2.length);
  assert(tradeStatisticsArbitrator.length === tradeStatisticsUser1.length && tradeStatisticsUser1.length === tradeStatisticsUser2.length);
});

// ----------------------------- TEST HELPERS ---------------------------------

function getTradeContexts(numConfigs: number): TradeContext[] {
    const configs: TradeContext[] = [];
    for (let i = 0; i < numConfigs; i++) configs.push(new TradeContext(TestConfig.trade));
    return configs;
}

async function executeTrades(ctxs: Partial<TradeContext>[], executionCtx?: Partial<TradeContext>): Promise<string[]> {

  // assign default execution context
  if (!executionCtx) executionCtx = {};
  if (executionCtx.concurrentTrades === undefined) executionCtx.concurrentTrades = ctxs.length > 1;
  Object.assign(executionCtx, new TradeContext(TestConfig.trade), Object.assign({}, executionCtx));

  // start mining if executing trades concurrently
  let miningStarted = executionCtx.concurrentTrades && await startMining();

  // execute trades
  let offerIds: string[] = [];
  let err = undefined
  try {

    // assign default configs
    for (let i = 0; i < ctxs.length; i++) Object.assign(ctxs[i], new TradeContext(TestConfig.trade), Object.assign({index: i}, ctxs[i]));

    // wait for traders to have unlocked balance for trades
    let tradeAmount: bigint|undefined = undefined;
    const outputCounts = new Map<any, number>();
    for (const ctx of ctxs) {
      if (!tradeAmount || tradeAmount < ctx.offerAmount!) tradeAmount = ctx.offerAmount; // use max amount
      if (ctx.awaitFundsToMakeOffer && ctx.makeOffer && !ctx.offerId) {
        const wallet = await getWallet(ctx.maker!.havenod!);
        if (outputCounts.has(wallet)) outputCounts.set(wallet, outputCounts.get(wallet)! + 1);
        else outputCounts.set(wallet, 1);
      }
      if (ctx.awaitFundsToTakeOffer && ctx.takeOffer && !ctx.isOfferTaken) {
        const wallet = await getWallet(ctx.taker!.havenod!);
        if (outputCounts.has(wallet)) outputCounts.set(wallet, outputCounts.get(wallet)! + 1);
        else outputCounts.set(wallet, 1);
      }
    }
    const fundWalletPromises: Promise<void>[] = [];
    for (const wallet of outputCounts.keys()) {
      if (outputCounts.get(wallet)! > 0) {
        fundWalletPromises.push(fundOutputs([wallet], tradeAmount! * 2n, outputCounts.get(wallet)));
      }
    }
    await Promise.all(fundWalletPromises);

    // execute trades in thread pool unless serial
    if (executionCtx.concurrentTrades) {
      const tradePromises: Promise<string>[] = [];
      const pool = new moneroTs.ThreadPool(executionCtx.maxConcurrency!);
      for (let i = 0; i < ctxs.length; i++) ctxs[i] = TradeContext.init(Object.assign(ctxs[i], {concurrentTrades: executionCtx!.concurrentTrades})); // inititalize full trade contexts to avoid copy
      for (const ctx of ctxs) tradePromises.push(pool.submit(() => executeTrade(ctx)));
      try {
        offerIds = await Promise.all(tradePromises);
      } catch (e2) {
        if (executionCtx.stopOnFailure) for (const ctx of ctxs) ctx.isStopped = true; // stop trades on failure
        try {
          await Promise.allSettled(tradePromises); // wait for other trades to complete
        } catch (e3: any) {
          HavenoUtils.log(0, "Error awaiting other trades to stop after error: " + e3.message);
          HavenoUtils.log(0, e3.stack);
        }
        throw e2;
      }
    } else {
      for (const ctx of ctxs) {
        offerIds.push(await executeTrade(Object.assign(ctx, {concurrentTrades: executionCtx.concurrentTrades})));
      }
    }
  } catch (e) {
    err = e;
  }

  // stop mining if started, throw error or return offer ids
  if (miningStarted) await stopMining();
  if (err) throw err;
  return offerIds;
}

// TODO (woodser): test grpc notifications
async function executeTrade(ctxP: Partial<TradeContext>): Promise<string> {
  let ctx = TradeContext.init(ctxP);
  try {

    // fund maker and taker
    if (ctx.isStopped) return ctx.offerId!;
    const makingOffer = ctx.makeOffer && !ctx.offerId;
    const clientsToFund: HavenoClient[] = [];
    if (!ctx.concurrentTrades) { // already funded
      if (ctx.awaitFundsToMakeOffer && makingOffer && !ctx.offerId) clientsToFund.push(ctx.maker.havenod!);
      if (ctx.awaitFundsToTakeOffer && ctx.takeOffer && !ctx.isOfferTaken) clientsToFund.push(ctx.taker.havenod!);
      await waitForAvailableBalance(ctx.offerAmount! * 2n, ...clientsToFund);
    }

    // make offer if configured
    if (ctx.isStopped) return ctx.offerId!;
    if (makingOffer) {
      ctx.offer = await makeOffer(ctx);
      expect(ctx.offer.getState()).toEqual(ctx.reserveExactAmount ? "PENDING" : "AVAILABLE");
      ctx.offerId = ctx.offer.getId();
      await wait(ctx.maxTimePeerNoticeMs);
    } else {
      ctx.offer = getOffer(await ctx.maker.havenod!.getMyOffers(ctx.assetCode!, ctx.direction), ctx.offerId!);
      if (!ctx.offer) {
        try {
          const trade = await ctx.maker.havenod!.getTrade(ctx.offerId!);
          ctx.offer = trade.getOffer();
        } catch (err) { /* ignore */ }
      }
    }

    // TODO (woodser): test error message taking offer before posted

    // wait for split output tx to unlock
    if (ctx.isStopped) return ctx.offerId!;
    if (ctx.reserveExactAmount) {
      const splitOutputTxId = ctx.offer?.getSplitOutputTxHash();
      HavenoUtils.log(1, "Waiting for split output tx " + splitOutputTxId + " to unlock");
      if (splitOutputTxId) {
        await mineToUnlock(splitOutputTxId);
        await wait(TestConfig.trade.walletSyncPeriodMs + TestConfig.trade.maxTimePeerNoticeMs);
      }
    }

    // take offer or get existing trade
    if (ctx.isStopped) return ctx.offerId!;
    let trade: TradeInfo|undefined = undefined;
    if (ctx.isOfferTaken) trade = await ctx.taker.havenod!.getTrade(ctx.offerId!);
    else {
      if (!ctx.takeOffer) return ctx.offerId!;
      trade = await takeOffer(ctx);
      ctx.isOfferTaken = true;
    }

    // test trader chat
    if (ctx.isStopped) return ctx.offerId!;
    if (ctx.testTraderChat) await testTradeChat(ctx);

    // get expected payment account payloads
    if (ctx.isStopped) return ctx.offerId!;
    let expectedBuyerPaymentAccountPayload = (await ctx.getBuyer().havenod?.getPaymentAccount(ctx.maker.havenod == ctx.getBuyer().havenod ? ctx.makerPaymentAccountId! : ctx.takerPaymentAccountId!))?.getPaymentAccountPayload();
    let expectedSellerPaymentAccountPayload = (await ctx.getSeller().havenod?.getPaymentAccount(ctx.maker.havenod == ctx.getBuyer().havenod ? ctx.takerPaymentAccountId! : ctx.makerPaymentAccountId!))?.getPaymentAccountPayload();

    // seller does not have buyer's payment account payload until payment sent
    if (ctx.isStopped) return ctx.offerId!;
    let fetchedTrade = await ctx.getSeller().havenod!.getTrade(ctx.offerId!);
    let contract = fetchedTrade.getContract()!;
    let buyerPaymentAccountPayload = contract.getIsBuyerMakerAndSellerTaker() ? contract.getMakerPaymentAccountPayload() : contract.getTakerPaymentAccountPayload();
    if (ctx.isPaymentSent) expect(buyerPaymentAccountPayload).toEqual(expectedBuyerPaymentAccountPayload);
    else expect(buyerPaymentAccountPayload).toBeUndefined();

    // record context before payout
    if (ctx.isStopped) return ctx.offerId!;
    if (!ctx.isCompleted) {
      if (ctx.maker.havenod) ctx.maker.balancesBeforePayout = await ctx.maker.havenod!.getBalances();
      if (ctx.taker.havenod) ctx.taker.balancesBeforePayout = await ctx.taker.havenod!.getBalances();
    }

    // shut down buyer and seller if configured
    if (ctx.isStopped) return ctx.offerId!;
    ctx.usedPorts = [getPort(ctx.getBuyer().havenod!.getUrl()), getPort(ctx.getSeller().havenod!.getUrl())];
    const promises: Promise<void>[] = [];
    ctx.buyerAppName = ctx.getBuyer().havenod!.getAppName();
    if (ctx.buyerOfflineAfterTake) {
      HavenoUtils.log(0, "Buyer going offline");
      promises.push(releaseHavenoProcess(ctx.getBuyer().havenod!));
      if (ctx.isBuyerMaker()) ctx.maker.havenod = undefined;
      else ctx.taker.havenod = undefined;
    }
    ctx.sellerAppName = ctx.getSeller().havenod!.getAppName();
    if (ctx.sellerOfflineAfterTake) {
      HavenoUtils.log(0, "Seller going offline");
      promises.push(releaseHavenoProcess(ctx.getSeller().havenod!));
      if (ctx.isBuyerMaker()) ctx.taker.havenod = undefined;
      else ctx.maker.havenod = undefined;
    }
    await Promise.all(promises);

    // wait for deposit txs to unlock
    if (ctx.isStopped) return ctx.offerId!;
    await waitForUnlockedTxs(trade.getMakerDepositTxId(), trade.getTakerDepositTxId());

    // buyer comes online if offline and used
    if (ctx.isStopped) return ctx.offerId!;
    if (ctx.buyerOfflineAfterTake && ((ctx.buyerSendsPayment && !ctx.isPaymentSent && ctx.sellerDisputeContext !== DisputeContext.OPEN_AFTER_DEPOSITS_UNLOCK) || (ctx.buyerDisputeContext === DisputeContext.OPEN_AFTER_DEPOSITS_UNLOCK && !ctx.buyerOpenedDispute))) {
      HavenoUtils.log(0, "Buyer coming online");
      const buyer = await initHaveno({appName: ctx.buyerAppName, excludePorts: ctx.usedPorts}); // change buyer's node address
      if (ctx.isBuyerMaker()) ctx.maker.havenod = buyer;
      else ctx.taker.havenod = buyer;
      ctx.usedPorts.push(getPort(buyer.getUrl()));
    }

    // wait for traders to observe
    if (ctx.isStopped) return ctx.offerId!;
    await wait(TestConfig.maxWalletStartupMs + ctx.walletSyncPeriodMs * 2);

    // test buyer trade state if online
    if (ctx.isStopped) return ctx.offerId!;
    const expectedState = ctx.isPaymentSent ? "PAYMENT_SENT" : "DEPOSITS_UNLOCKED" // TODO: test COMPLETED, PAYMENT_RECEIVED states?
    if (ctx.getBuyer().havenod) {
      expect((await ctx.getBuyer().havenod!.getTrade(ctx.offer!.getId())).getPhase()).toEqual(expectedState);
      fetchedTrade = await ctx.getBuyer().havenod!.getTrade(ctx.offerId!);
      expect(fetchedTrade.getIsDepositsUnlocked()).toBe(true);
      expect(fetchedTrade.getPhase()).toEqual(expectedState);
    }

    // test seller trade state if online
    if (ctx.isStopped) return ctx.offerId!;
    if (ctx.getSeller().havenod) {
      fetchedTrade = await ctx.getSeller().havenod!.getTrade(trade.getTradeId());
      expect(fetchedTrade.getIsDepositsUnlocked()).toBe(true);
      expect(fetchedTrade.getPhase()).toEqual(expectedState);
    }

    // buyer has seller's payment account payload after first confirmation
    if (ctx.isStopped) return ctx.offerId!;
    let sellerPaymentAccountPayload: PaymentAccountPayload | undefined;
    let form;
    let expectedForm;
    if (ctx.getBuyer().havenod) {
      fetchedTrade = await ctx.getBuyer().havenod!.getTrade(ctx.offerId!);
      contract = fetchedTrade.getContract()!;
      sellerPaymentAccountPayload = contract.getIsBuyerMakerAndSellerTaker() ? contract.getTakerPaymentAccountPayload() : contract.getMakerPaymentAccountPayload();
      expect(sellerPaymentAccountPayload).toEqual(expectedSellerPaymentAccountPayload);
      form = await ctx.getBuyer().havenod!.getPaymentAccountPayloadForm(sellerPaymentAccountPayload!);
      expectedForm = await ctx.getBuyer().havenod!.getPaymentAccountPayloadForm(expectedSellerPaymentAccountPayload!);
      expect(HavenoUtils.formToString(form)).toEqual(HavenoUtils.formToString(expectedForm));
    }

    // buyer notified to send payment TODO

    // open dispute(s) if configured
    if (ctx.isStopped) return ctx.offerId!;
    if (ctx.buyerDisputeContext === DisputeContext.OPEN_AFTER_DEPOSITS_UNLOCK && !ctx.buyerOpenedDispute) {
      await ctx.getBuyer().havenod!.openDispute(ctx.offerId!);
      ctx.buyerOpenedDispute = true;
      ctx.disputeOpener = SaleRole.BUYER;
    }
    if (ctx.isStopped) return ctx.offerId!;
    if (ctx.sellerDisputeContext === DisputeContext.OPEN_AFTER_DEPOSITS_UNLOCK && !ctx.sellerOpenedDispute) {
      await ctx.getSeller().havenod!.openDispute(ctx.offerId!);
      ctx.sellerOpenedDispute = true;
      if (!ctx.disputeOpener) ctx.disputeOpener = SaleRole.SELLER;
    }

    // handle opened dispute
    if (ctx.isStopped) return ctx.offerId!;
    if (ctx.disputeOpener) {

      // test open dispute
      await testOpenDispute(ctx);

      // resolve dispute if configured
      if (ctx.resolveDispute) await resolveDispute(ctx);

      // return offer id
      return ctx.offerId!;
    }

    // buyer confirms payment is sent
    if (ctx.isStopped) return ctx.offerId!;
    if (!ctx.buyerSendsPayment) return ctx.offer!.getId();
    else if (!ctx.isPaymentSent) {
      HavenoUtils.log(1, "Buyer confirming payment sent");
      await ctx.getBuyer().havenod!.confirmPaymentSent(trade.getTradeId());
      ctx.isPaymentSent = true;
      fetchedTrade = await ctx.getBuyer().havenod!.getTrade(trade.getTradeId());
      expect(fetchedTrade.getPhase()).toEqual("PAYMENT_SENT");
    }

    // buyer goes offline if configured
    if (ctx.isStopped) return ctx.offerId!;
    if (ctx.buyerOfflineAfterPaymentSent) {
      HavenoUtils.log(0, "Buyer going offline");
      await releaseHavenoProcess(ctx.getBuyer().havenod!);
      if (ctx.isBuyerMaker()) ctx.maker.havenod = undefined;
      else ctx.taker.havenod = undefined;
    }

    // seller comes online if offline
    if (ctx.isStopped) return ctx.offerId!;
    if (!ctx.getSeller().havenod) {
      HavenoUtils.log(0, "Seller coming online");
      const seller = await initHaveno({appName: ctx.sellerAppName, excludePorts: ctx.usedPorts});
      if (ctx.isBuyerMaker()) ctx.taker.havenod = seller;
      else ctx.maker.havenod = seller;
      ctx.usedPorts.push(getPort(ctx.getSeller().havenod!.getUrl()))
    }

    // seller notified payment is sent
    if (ctx.isStopped) return ctx.offerId!;
    await wait(ctx.maxTimePeerNoticeMs + TestConfig.maxWalletStartupMs); // TODO: test notification
    if (ctx.sellerOfflineAfterTake) await wait(ctx.walletSyncPeriodMs); // wait to process mailbox messages
    fetchedTrade = await ctx.getSeller().havenod!.getTrade(trade.getTradeId());
    expect(fetchedTrade.getPhase()).toEqual("PAYMENT_SENT");
    expect(fetchedTrade.getPayoutState()).toEqual("PAYOUT_UNPUBLISHED");

    // seller has buyer's payment account payload after payment sent
    if (ctx.isStopped) return ctx.offerId!;
    fetchedTrade = await ctx.getSeller().havenod!.getTrade(ctx.offerId!);
    contract = fetchedTrade.getContract()!;
    buyerPaymentAccountPayload = contract.getIsBuyerMakerAndSellerTaker() ? contract.getMakerPaymentAccountPayload() : contract.getTakerPaymentAccountPayload();
    expect(buyerPaymentAccountPayload).toEqual(expectedBuyerPaymentAccountPayload);
    form = await ctx.getSeller().havenod!.getPaymentAccountPayloadForm(sellerPaymentAccountPayload!);
    expectedForm = await ctx.getSeller().havenod!.getPaymentAccountPayloadForm(expectedSellerPaymentAccountPayload!);
    expect(HavenoUtils.formToString(form)).toEqual(HavenoUtils.formToString(expectedForm));

    // open dispute(s) if configured
    if (ctx.isStopped) return ctx.offerId!;
    if (ctx.buyerDisputeContext === DisputeContext.OPEN_AFTER_PAYMENT_SENT && !ctx.buyerOpenedDispute) {
      await ctx.getBuyer().havenod!.openDispute(ctx.offerId!);
      ctx.buyerOpenedDispute = true;
      if (!ctx.disputeOpener) ctx.disputeOpener = SaleRole.BUYER;
    }
    if (ctx.isStopped) return ctx.offerId!;
    if (ctx.sellerDisputeContext === DisputeContext.OPEN_AFTER_PAYMENT_SENT && !ctx.sellerOpenedDispute) {
      await ctx.getSeller().havenod!.openDispute(ctx.offerId!);
      ctx.sellerOpenedDispute = true;
      if (!ctx.disputeOpener) ctx.disputeOpener = SaleRole.SELLER;
    }
    if (ctx.isStopped) return ctx.offerId!;
    if (ctx.disputeOpener) await testOpenDispute(ctx);

    // if dispute opened, resolve dispute if configured and return
    if (ctx.isStopped) return ctx.offerId!;
    if (ctx.disputeOpener) {
      if (ctx.resolveDispute) await resolveDispute(ctx);
      return ctx.offerId!;
    }

    // seller confirms payment is received
    if (ctx.isStopped) return ctx.offerId!;
    if (!ctx.sellerReceivesPayment) return ctx.offer!.getId();
    else if (!ctx.isPaymentReceived) {
      HavenoUtils.log(1, "Seller confirming payment received");
      await ctx.getSeller().havenod!.confirmPaymentReceived(trade.getTradeId());
      ctx.isPaymentReceived = true;
      fetchedTrade = await ctx.getSeller().havenod!.getTrade(trade.getTradeId());
      expect(fetchedTrade.getPhase()).toEqual("PAYMENT_RECEIVED");
      await wait(ctx.walletSyncPeriodMs * 2); // buyer or arbitrator will sign and publish payout tx
      await testTradeState(await ctx.getSeller().havenod!.getTrade(trade.getTradeId()), {phase: "PAYMENT_RECEIVED", payoutState: ["PAYOUT_PUBLISHED", "PAYOUT_CONFIRMED", "PAYOUT_UNLOCKED"], isCompleted: false, isPayoutPublished: true});
    }

    // payout tx is published by buyer (priority) or arbitrator
    if (ctx.isStopped) return ctx.offerId!;
    await wait(ctx.walletSyncPeriodMs);
    await testTradeState(await ctx.getSeller().havenod!.getTrade(trade.getTradeId()), {phase: "PAYMENT_RECEIVED", payoutState: ["PAYOUT_PUBLISHED", "PAYOUT_CONFIRMED", "PAYOUT_UNLOCKED"], isCompleted: false, isPayoutPublished: true});
    await testTradeState(await ctx.arbitrator.havenod!.getTrade(trade.getTradeId()), {phase: "PAYMENT_RECEIVED", payoutState: ["PAYOUT_PUBLISHED", "PAYOUT_CONFIRMED", "PAYOUT_UNLOCKED"], isCompleted: true, isPayoutPublished: true}); // arbitrator trade auto completes

    // buyer comes online if offline
    if (ctx.isStopped) return ctx.offerId!;
    if (ctx.buyerOfflineAfterPaymentSent) {
      HavenoUtils.log(0, "Buyer coming online");
      const buyer = await initHaveno({appName: ctx.buyerAppName, excludePorts: ctx.usedPorts});
      if (ctx.isBuyerMaker()) ctx.maker.havenod = buyer;
      else ctx.taker.havenod = buyer;
      ctx.usedPorts.push(getPort(buyer.getUrl()));
      HavenoUtils.log(1, "Done starting buyer");
      await wait(TestConfig.maxWalletStartupMs + ctx.walletSyncPeriodMs);
    }
    if (ctx.isStopped) return ctx.offerId!;
    await testTradeState(await ctx.getBuyer().havenod!.getTrade(trade.getTradeId()), {phase: "PAYMENT_RECEIVED", payoutState: ["PAYOUT_PUBLISHED", "PAYOUT_CONFIRMED", "PAYOUT_UNLOCKED"], isCompleted: false, isPayoutPublished: true});

    // test trade completion
    if (ctx.isStopped) return ctx.offerId!;
    await ctx.getBuyer().havenod!.completeTrade(trade.getTradeId());
    await testTradeState(await ctx.getBuyer().havenod!.getTrade(trade.getTradeId()), {phase: "PAYMENT_RECEIVED", payoutState: ["PAYOUT_PUBLISHED", "PAYOUT_CONFIRMED", "PAYOUT_UNLOCKED"], isCompleted: true, isPayoutPublished: true});
    await ctx.getSeller().havenod!.completeTrade(trade.getTradeId());
    await testTradeState(await ctx.getSeller().havenod!.getTrade(trade.getTradeId()), {phase: "PAYMENT_RECEIVED", payoutState: ["PAYOUT_PUBLISHED", "PAYOUT_CONFIRMED", "PAYOUT_UNLOCKED"], isCompleted: true, isPayoutPublished: true});

    // record balances on completion
    if (ctx.isStopped) return ctx.offerId!;
    if (!ctx.maker.balancesAfterPayout) {
      ctx.maker.balancesAfterPayout = await ctx.maker.havenod?.getBalances();
      ctx.taker.balancesAfterPayout = await ctx.taker.havenod?.getBalances();

      // record payout tx id
      ctx.payoutTxId = (await ctx.getSeller().havenod!.getTrade(ctx.offerId!)).getPayoutTxId();
      if (!ctx.payoutTxId) ctx.payoutTxId = (await ctx.arbitrator.havenod!.getTrade(ctx.offerId!)).getPayoutTxId(); // TODO: arbitrator will sign and publish payout tx id if buyer is offline; detect payout tx id on 0 conf
      if (!ctx.payoutTxId) ctx.payoutTxId = (await ctx.getBuyer().havenod!.getTrade(ctx.offerId!)).getPayoutTxId(); // TODO: arbitrator does not have payout tx id until first confirmation because they defer publishing
    }

    // test balances after payout tx unless other trades can interfere
    if (ctx.isStopped) return ctx.offerId!;
    if (!ctx.concurrentTrades) await testAmountsAfterComplete(ctx);

    // test payout unlock
    if (ctx.isStopped) return ctx.offerId!;
    await testTradePayoutUnlock(ctx);
    if (ctx.offer!.getId() !== ctx.offerId) throw new Error("Expected offer ids to match");
    return ctx.offer!.getId();
  } catch (err: any) {
    HavenoUtils.log(0, "Error executing trade " + ctx!.offerId + (ctx!.index === undefined ? "" : " at index " + ctx!.index) + ": " + err.message);
    HavenoUtils.log(0, await ctx.toSummary());
    throw err;
  }
}

async function testTradePayoutUnlock(ctxP: Partial<TradeContext>) {
  let ctx = TradeContext.init(ctxP);

  // test after payout confirmed
  if (!ctx.testPayoutConfirmed) return;
  const height = await monerod.getHeight();
  const payoutTxId = (await ctx.arbitrator.havenod!.getTrade(ctx.offerId!)).getPayoutTxId();
  let trade = await ctx.arbitrator.havenod!.getTrade(ctx.offerId!);
  if (trade.getPayoutState() !== "PAYOUT_CONFIRMED") await mineToHeight(height + 1);
  await wait(TestConfig.maxWalletStartupMs + ctx.walletSyncPeriodMs * 2);
  const disputeState = ctx.isPaymentReceived ? "NO_DISPUTE" : "DISPUTE_CLOSED";
  if (ctx.getBuyer().havenod) await testTradeState(await ctx.getBuyer().havenod!.getTrade(ctx.offerId!), {phase: ctx.getPhase(), disputeState: disputeState, payoutState: ["PAYOUT_CONFIRMED", "PAYOUT_UNLOCKED"]});
  if (ctx.getSeller().havenod) await testTradeState(await ctx.getSeller().havenod!.getTrade(ctx.offerId!), {phase: ctx.getPhase(), disputeState: disputeState, payoutState: ["PAYOUT_CONFIRMED", "PAYOUT_UNLOCKED"]});
  await testTradeState(await ctx.arbitrator.havenod!.getTrade(ctx.offerId!), {phase: ctx.getPhase(), payoutState: ["PAYOUT_CONFIRMED", "PAYOUT_UNLOCKED"]});
  let payoutTx = ctx.getBuyer().havenod ? await ctx.getBuyer().havenod?.getXmrTx(payoutTxId) : await ctx.getSeller().havenod?.getXmrTx(payoutTxId);
  expect(payoutTx?.getIsConfirmed());

  // test after payout unlocked
  if (!ctx.testPayoutUnlocked) return;
  trade = await ctx.arbitrator.havenod!.getTrade(ctx.offerId!);
  if (trade.getPayoutState() !== "PAYOUT_UNLOCKED") await mineToHeight(height + 10);
  await wait(TestConfig.maxWalletStartupMs + ctx.walletSyncPeriodMs * 2);
  if (await ctx.getBuyer().havenod) await testTradeState(await ctx.getBuyer().havenod!.getTrade(ctx.offerId!), {phase: ctx.getPhase(), disputeState: disputeState, payoutState: ["PAYOUT_UNLOCKED"]});
  if (await ctx.getSeller().havenod) await testTradeState(await ctx.getSeller().havenod!.getTrade(ctx.offerId!), {phase: ctx.getPhase(), disputeState: disputeState, payoutState: ["PAYOUT_UNLOCKED"]});
  await testTradeState(await ctx.arbitrator.havenod!.getTrade(ctx.offerId!), {phase: ctx.getPhase(), disputeState: disputeState, payoutState: ["PAYOUT_UNLOCKED"]});
  payoutTx = ctx.getBuyer().havenod ? await ctx.getBuyer().havenod?.getXmrTx(payoutTxId) : await ctx.getSeller().havenod?.getXmrTx(payoutTxId);
  expect(!payoutTx?.getIsLocked());
}

async function testTradeState(trade: TradeInfo, ctx: Partial<TradeContext>) {
  assert.equal(trade.getPhase(), ctx.phase, "expected trade phase to be " + ctx.phase + " but was " + trade.getPhase() + " for trade " + trade.getTradeId());
  assert(moneroTs.GenUtils.arrayContains(ctx.payoutState, trade.getPayoutState()), "expected one of payout state " + ctx.payoutState + " but was " + trade.getPayoutState() + " for trade " + trade.getTradeId());
  if (ctx.disputeState) expect(trade.getDisputeState()).toEqual(ctx.disputeState);
  if (ctx.isCompleted !== undefined) expect(trade.getIsCompleted()).toEqual(ctx.isCompleted);
  if (ctx.isPayoutPublished !== undefined) expect(trade.getIsPayoutPublished()).toEqual(ctx.isPayoutPublished);
  if (ctx.isPayoutConfirmed !== undefined) expect(trade.getIsPayoutConfirmed()).toEqual(ctx.isPayoutConfirmed);
  if (ctx.isPayoutConfirmed) expect(trade.getIsPayoutPublished()).toEqual(true);
  if (ctx.isPayoutUnlocked !== undefined) expect(trade.getIsPayoutUnlocked()).toEqual(ctx.isPayoutUnlocked);
  if (ctx.isPayoutUnlocked) {
    expect(trade.getIsPayoutConfirmed()).toEqual(true);
    expect(trade.getIsPayoutPublished()).toEqual(true);
  }
}

async function makeOffer(ctxP?: Partial<TradeContext>): Promise<OfferInfo> {
  let ctx = TradeContext.init(ctxP);

  // wait for unlocked balance
  if (!ctx.concurrentTrades && ctx.awaitFundsToMakeOffer) await waitForAvailableBalance(ctx.offerAmount! * 2n, ctx.maker.havenod);

  // create payment account if not given // TODO: re-use existing payment account
  if (!ctx.makerPaymentAccountId) ctx.makerPaymentAccountId = (await createPaymentAccount(ctx.maker.havenod!, ctx.assetCode!)).getId();

  // get unlocked balance before reserving offer
  let unlockedBalanceBefore = BigInt((await ctx.maker.havenod!.getBalances()).getAvailableBalance());
  if (ctx.awaitFundsToMakeOffer && unlockedBalanceBefore === 0n) {
    HavenoUtils.log(0, "WARNING: unlocked balance before posting offer is 0, waiting...");
    await wait(5000);
    unlockedBalanceBefore = BigInt((await ctx.maker.havenod!.getBalances()).getAvailableBalance());
    if (unlockedBalanceBefore === 0n) throw new Error("Unlocked balance before posting offer was 0, even after waiting");
  }

  // initialize balances before offer, once
  if (!ctx.maker.balancesBeforeOffer) {
    ctx.maker.balancesBeforeOffer = await ctx.maker.havenod?.getBalances();
    ctx.taker.balancesBeforeOffer = await ctx.taker.havenod?.getBalances();
  }

  // post offer
  const offer: OfferInfo = await ctx.maker.havenod!.postOffer(
        ctx.direction!,
        ctx.offerAmount!,
        ctx.assetCode!,
        ctx.makerPaymentAccountId!,
        ctx.securityDepositPct!,
        ctx.price,
        ctx.priceMargin,
        ctx.triggerPrice,
        ctx.offerMinAmount,
        ctx.reserveExactAmount);
  testOffer(offer, ctx);

  // offer is included in my offers only
  if (!getOffer(await ctx.maker.havenod!.getMyOffers(ctx.assetCode!, ctx.direction), offer.getId())) {
    console.warn("Offer is not included in my offers after posting, waiting up to 10 seconds");
    await wait(10000); // TODO: remove this wait time
    if (!getOffer(await ctx.maker.havenod!.getMyOffers(ctx.assetCode!, ctx.direction), offer.getId())) throw new Error("Offer " + offer.getId() + " was not found in my offers");
  }
  if (getOffer(await ctx.maker.havenod!.getOffers(ctx.assetCode!, ctx.direction), offer.getId())) throw new Error("My offer " + offer.getId() + " should not appear in available offers");

  // collect context
  ctx.maker.splitOutputTxFee = BigInt(offer.getSplitOutputTxFee());
  ctx.taker.splitOutputTxFee = 0n;

  // market-priced offer amounts are unadjusted, fixed-priced offer amounts are adjusted (e.g. cash at atm is $10 increments)
  // TODO: adjustments should be based on currency and payment method, not fixed-price
  if (!ctx.offerMinAmount) ctx.offerMinAmount = ctx.offerAmount;
  if (offer.getUseMarketBasedPrice()) {
    expect(BigInt(offer.getAmount())).toEqual(ctx.offerAmount!);
    expect(BigInt(offer.getMinAmount())).toEqual(ctx.offerMinAmount!);
  } else {
    expect(Math.abs(HavenoUtils.percentageDiff(ctx.offerAmount!, BigInt(offer.getAmount())))).toBeLessThan(TestConfig.maxAdjustmentPct);
    expect(Math.abs(HavenoUtils.percentageDiff(ctx.offerMinAmount!, BigInt(offer.getMinAmount())))).toBeLessThan(TestConfig.maxAdjustmentPct);
  }

  // unlocked balance has decreased
  let unlockedBalanceAfter = BigInt((await ctx.maker.havenod!.getBalances()).getAvailableBalance());
  if (offer.getState() === "PENDING") {
    if (!ctx.reserveExactAmount && unlockedBalanceAfter !== unlockedBalanceBefore) throw new Error("Unlocked balance should not change for scheduled offer " + offer.getId());
  } else if (offer.getState() === "AVAILABLE") {
    if (unlockedBalanceAfter === unlockedBalanceBefore) {
      console.warn("Unlocked balance did not change after posting offer, waiting a sync period");
      await wait(ctx.walletSyncPeriodMs);
      unlockedBalanceAfter = BigInt((await ctx.maker.havenod!.getBalances()).getAvailableBalance());
      if (unlockedBalanceAfter === unlockedBalanceBefore) throw new Error("Unlocked balance did not change after posting offer " + offer.getId() + ", before=" + unlockedBalanceBefore + ", after=" + unlockedBalanceAfter);
    }
  } else {
    throw new Error("Unexpected offer state after posting: " + offer.getState());
  }

  return offer;
}

async function takeOffer(ctxP: Partial<TradeContext>): Promise<TradeInfo> {
  let ctx = TradeContext.init(ctxP);

  // assign default config
  Object.assign(ctx,  new TradeContext(TestConfig.trade), Object.assign({}, ctx));

  // taker sees offer
  if (!ctx.offerId) throw new Error("Must provide offer id");
  const takerOffer = getOffer(await ctx.taker.havenod!.getOffers(ctx.assetCode!, ctx.direction), ctx.offerId);
  if (!takerOffer) throw new Error("Offer " + ctx.offerId + " was not found in taker's offers");
  expect(takerOffer.getState()).toEqual("UNKNOWN"); // TODO: offer state should be known

  // wait for unlocked balance
  if (ctx.awaitFundsToTakeOffer) await waitForAvailableBalance(ctx.offerAmount! * 2n, ctx.taker.havenod);

  // create payment account if not given // TODO: re-use existing payment account
  if (!ctx.takerPaymentAccountId) ctx.takerPaymentAccountId = (await createPaymentAccount(ctx.taker.havenod!, ctx.assetCode!)).getId();

  // register to receive notifications
  const makerNotifications: NotificationMessage[] = [];
  const takerNotifications: NotificationMessage[] = [];
  await ctx.maker.havenod!.addNotificationListener(notification => { makerNotifications.push(notification); });
  await ctx.taker.havenod!.addNotificationListener(notification => { takerNotifications.push(notification); });

  // record balances before offer taken, once
  if (ctx.taker.balancesBeforeTake === undefined) {
    ctx.maker.balancesBeforeTake = await ctx.maker.havenod?.getBalances();
    ctx.taker.balancesBeforeTake = await ctx.taker.havenod?.getBalances();
  }

  // take offer
  const takerBalancesBefore: XmrBalanceInfo = await ctx.taker.havenod!.getBalances();
  const startTime = Date.now();
  HavenoUtils.log(1, "Taking offer " + ctx.offerId);
  const trade = await ctx.taker.havenod!.takeOffer(ctx.offerId, ctx.takerPaymentAccountId!, ctx.tradeAmount);
  HavenoUtils.log(1, "Done taking offer " + ctx.offerId + " in " + (Date.now() - startTime) + " ms");

  // maker is notified that offer is taken
  await wait(ctx.maxTimePeerNoticeMs);
  const tradeNotifications = getNotifications(makerNotifications, NotificationMessage.NotificationType.TRADE_UPDATE, trade.getTradeId());
  expect(tradeNotifications.length).toBe(1);
  assert(moneroTs.GenUtils.arrayContains(["DEPOSITS_PUBLISHED", "DEPOSITS_CONFIRMED", "DEPOSITS_UNLOCKED"], tradeNotifications[0].getTrade()!.getPhase()), "Unexpected trade phase: " + tradeNotifications[0].getTrade()!.getPhase());
  expect(tradeNotifications[0].getTitle()).toEqual("Offer Taken");
  expect(tradeNotifications[0].getMessage()).toEqual("Your offer " + ctx.offerId + " has been accepted");

  // set context after offer taken, once
  if (ctx.getBuyer().balancesAfterTake === undefined) {

    // wait to observe deposit txs
    ctx.arbitrator.trade = await ctx.arbitrator.havenod!.getTrade(ctx.offerId!);
    ctx.maker.depositTx = await monerod.getTx(ctx.arbitrator.trade!.getMakerDepositTxId());
    ctx.taker.depositTx = await monerod.getTx(ctx.arbitrator.trade!.getTakerDepositTxId());
    if (!ctx.maker.depositTx || !ctx.taker.depositTx) {
        if (!ctx.maker.depositTx) HavenoUtils.log(0, "Maker deposit tx not found with id " + ctx.arbitrator.trade!.getMakerDepositTxId() + ", waiting...");
        if (!ctx.taker.depositTx) HavenoUtils.log(0, "Taker deposit tx not found with id " + ctx.arbitrator.trade!.getTakerDepositTxId() + ", waiting...");
        await wait(ctx.walletSyncPeriodMs);
        ctx.maker.depositTx = await monerod.getTx(ctx.arbitrator.trade!.getMakerDepositTxId());
        ctx.taker.depositTx = await monerod.getTx(ctx.arbitrator.trade!.getTakerDepositTxId());
        if (!ctx.maker.depositTx) throw new Error("Maker deposit tx not found with id " + ctx.arbitrator.trade!.getMakerDepositTxId());
        if (!ctx.taker.depositTx) throw new Error("Taker deposit tx not found with id " + ctx.arbitrator.trade!.getTakerDepositTxId());
    }

    // record context
    ctx.tradeAmount = BigInt(trade.getAmount()); // re-assign trade amount which could be adjusted
    ctx.maker.trade = await ctx.maker.havenod!.getTrade(ctx.offerId!);
    ctx.taker.trade = await ctx.taker.havenod!.getTrade(ctx.offerId!);
    ctx.maker.balancesAfterTake = await ctx.maker.havenod!.getBalances();
    ctx.taker.balancesAfterTake = await ctx.taker.havenod!.getBalances();
    ctx.maker.depositTxFee = BigInt(ctx.maker.depositTx!.getFee());
    ctx.taker.depositTxFee = BigInt(ctx.taker.depositTx!.getFee());
    ctx.maker.tradeFee = BigInt(trade.getMakerFee());
    ctx.taker.tradeFee = BigInt(trade.getTakerFee());
    ctx.getBuyer().securityDepositActual = BigInt(trade.getBuyerSecurityDeposit()!);
    ctx.getSeller().securityDepositActual = BigInt(trade.getSellerSecurityDeposit()!);
  }

  // test trade model
  await testTrade(trade, ctx);

  // test buyer and seller balances after offer taken
  if (!ctx.concurrentTrades) {
    ctx.arbitrator!.trade = await ctx.arbitrator.havenod!.getTrade(ctx.offerId!);

    // test buyer balances after offer taken
    const buyerBalanceDiff = BigInt(ctx.getBuyer().balancesAfterTake!.getBalance()) - BigInt(ctx.getBuyer().balancesBeforeTake!.getBalance());
    const buyerBalanceDiffReservedTrade = BigInt(ctx.getBuyer().balancesAfterTake!.getReservedTradeBalance()) - BigInt(ctx.getBuyer().balancesBeforeTake!.getReservedTradeBalance());
    const buyerBalanceDiffReservedOffer = BigInt(ctx.getBuyer().balancesAfterTake!.getReservedOfferBalance()) - BigInt(ctx.getBuyer().balancesBeforeTake!.getReservedOfferBalance());
    expect(buyerBalanceDiffReservedTrade).toEqual(BigInt(trade.getBuyerSecurityDeposit()!));
    expect(buyerBalanceDiff).toEqual(-1n * buyerBalanceDiffReservedOffer - buyerBalanceDiffReservedTrade - ctx.getBuyer().depositTxFee! - ctx.getBuyer().tradeFee!);

    // test seller balances after offer taken
    const sellerBalanceDiff = BigInt(ctx.getSeller().balancesAfterTake!.getBalance()) - BigInt(ctx.getSeller().balancesBeforeTake!.getBalance());
    const sellerBalanceDiffReservedTrade = BigInt(ctx.getSeller().balancesAfterTake!.getReservedTradeBalance()) - BigInt(ctx.getSeller().balancesBeforeTake!.getReservedTradeBalance());
    expect(sellerBalanceDiffReservedTrade).toEqual(BigInt(trade.getAmount()) + BigInt(trade.getSellerSecurityDeposit()!));
    expect(sellerBalanceDiff).toEqual(0n - ctx.getSeller().depositTxFee! - ctx.getSeller().tradeFee! - ctx.getSeller().securityDepositActual! - ctx.tradeAmount!);

    // test maker balances after offer taken
    const makerBalanceDiffReservedOffer = BigInt(ctx.getMaker().balancesAfterTake!.getReservedOfferBalance()) - BigInt(ctx.getMaker().balancesBeforeTake!.getReservedOfferBalance());
    expect(makerBalanceDiffReservedOffer).toBeLessThan(0n); // TODO: more precise?

    // test taker balances after offer taken
    const takerBalanceDiffReservedOffer = BigInt(ctx.getTaker().balancesAfterTake!.getReservedOfferBalance()) - BigInt(ctx.getTaker().balancesBeforeTake!.getReservedOfferBalance());
    expect(takerBalanceDiffReservedOffer).toEqual(0n);
  }

  // test getting trade for all parties
  await testGetTrade(ctx);

  // market-priced offer amounts are unadjusted, fixed-priced offer amounts are adjusted (e.g. cash at atm is $10 increments)
  // TODO: adjustments are based on payment method, not fixed-price
  if (trade.getOffer()!.getUseMarketBasedPrice()) {
    assert.equal(ctx.tradeAmount, BigInt(trade.getAmount()));
  } else {
    expect(Math.abs(HavenoUtils.percentageDiff(ctx.tradeAmount!, BigInt(trade.getAmount())))).toBeLessThan(TestConfig.maxAdjustmentPct);
  }

  // maker is notified of balance change

  // taker is notified of balance change

  return trade;
}

async function testTrade(trade: TradeInfo, ctx: TradeContext, havenod?: HavenoClient): Promise<void> {
  expect(BigInt(trade.getAmount())).toEqual(ctx!.tradeAmount);

  // test security deposit = max(.1, trade amount * security deposit pct)
  const expectedSecurityDeposit = HavenoUtils.max(HavenoUtils.xmrToAtomicUnits(.1), HavenoUtils.multiply(ctx.tradeAmount!, ctx.securityDepositPct!));
  expect(BigInt(trade.getBuyerSecurityDeposit())).toEqual(expectedSecurityDeposit - ctx.getBuyer().depositTxFee!);
  expect(BigInt(trade.getSellerSecurityDeposit())).toEqual(expectedSecurityDeposit - ctx.getSeller().depositTxFee!);

  // test phase
  if (!ctx.isPaymentSent) {
    assert(moneroTs.GenUtils.arrayContains(["DEPOSITS_PUBLISHED", "DEPOSITS_CONFIRMED", "DEPOSITS_UNLOCKED"], trade.getPhase()), "Unexpected trade phase: " + trade.getPhase());
  }

  // test role
  const role = trade.getRole();
  assert(role.length > 0); // TODO: test role string based on context


  // TODO: test more fields
}

async function testGetTrade(ctx: TradeContext, havenod?: HavenoClient): Promise<void> {
  if (havenod) {
    const trade = await havenod.getTrade(ctx.offerId!);
    await testTrade(trade, ctx);
    const trades = await havenod.getTrades();
    const foundTrade = trades.find((trade) => trade.getTradeId() === ctx.offerId);
    assert(foundTrade);
    await testTrade(foundTrade, ctx, havenod);
  } else {
    await testGetTrade(ctx, ctx.maker.havenod);
    await testGetTrade(ctx, ctx.taker.havenod);
    await testGetTrade(ctx, ctx.arbitrator.havenod);
  }
}

async function testOpenDispute(ctxP: Partial<TradeContext>) {
  let ctx = TradeContext.init(ctxP);

  // TODO: test open dispute when buyer or seller offline
  if (!ctx.getBuyer().havenod || !ctx.getSeller().havenod) {
    HavenoUtils.log(0, "WARNING: skipping test open dispute tests because a trader is offline"); // TODO: update tests for offline trader
    return;
  }

  // test dispute state
  const openerDispute = await ctx.getDisputeOpener()!.havenod!.getDispute(ctx.offerId!);
  expect(openerDispute.getTradeId()).toEqual(ctx.offerId);
  expect(openerDispute.getIsOpener()).toBe(true);
  expect(openerDispute.getDisputeOpenerIsBuyer()).toBe(ctx.getDisputeOpener()!.havenod === ctx.getBuyer().havenod);

  // get non-existing dispute should fail
  try {
    await ctx.getDisputeOpener()!.havenod!.getDispute("invalid");
    throw new Error("get dispute with invalid id should fail");
  } catch (err: any) {
    assert.equal(err.message, "dispute for trade id 'invalid' not found");
  }

  // peer sees the dispute
  await wait(ctx.maxTimePeerNoticeMs + TestConfig.maxWalletStartupMs);
  const peerDispute = await ctx.getDisputePeer()!.havenod!.getDispute(ctx.offerId!);
  expect(peerDispute.getTradeId()).toEqual(ctx.offerId);
  expect(peerDispute.getIsOpener()).toBe(false || ctx.buyerDisputeContext === ctx.sellerDisputeContext); // TODO: both peers think they're the opener if disputes opened at same time since not waiting for ack

  // arbitrator sees both disputes
  const disputes = await ctx.arbitrator.havenod!.getDisputes();
  expect(disputes.length).toBeGreaterThanOrEqual(2);
  const arbDisputePeer = disputes.find(d => d.getId() === peerDispute.getId());
  assert(arbDisputePeer);
  const arbDisputeOpener = disputes.find(d => d.getId() === openerDispute.getId());
  assert(arbDisputeOpener);

  // arbitrator has seller's payment account info
  let sellerPaymentAccountPayload = arbDisputeOpener.getContract()!.getIsBuyerMakerAndSellerTaker() ? arbDisputeOpener.getTakerPaymentAccountPayload() : arbDisputeOpener.getMakerPaymentAccountPayload();
  let expectedSellerPaymentAccountPayload = (await ctx.getSeller().havenod?.getPaymentAccount(sellerPaymentAccountPayload?.getId()!))?.getPaymentAccountPayload();
  expect(sellerPaymentAccountPayload).toEqual(expectedSellerPaymentAccountPayload);
  expect(await ctx.arbitrator.havenod?.getPaymentAccountPayloadForm(sellerPaymentAccountPayload!)).toEqual(await ctx.arbitrator.havenod?.getPaymentAccountPayloadForm(expectedSellerPaymentAccountPayload!));
  sellerPaymentAccountPayload = arbDisputePeer.getContract()!.getIsBuyerMakerAndSellerTaker() ? arbDisputePeer.getTakerPaymentAccountPayload() : arbDisputeOpener.getMakerPaymentAccountPayload();
  expect(sellerPaymentAccountPayload).toEqual(expectedSellerPaymentAccountPayload);
  expect(await ctx.arbitrator.havenod?.getPaymentAccountPayloadForm(sellerPaymentAccountPayload!)).toEqual(await ctx.arbitrator.havenod?.getPaymentAccountPayloadForm(expectedSellerPaymentAccountPayload!));

  // arbitrator has buyer's payment account info unless opener is seller and payment not sent
  let buyerPaymentAccountPayload = arbDisputeOpener.getContract()!.getIsBuyerMakerAndSellerTaker() ? arbDisputeOpener.getMakerPaymentAccountPayload() : arbDisputeOpener.getTakerPaymentAccountPayload();
  if (ctx.getDisputeOpener()!.havenod === ctx.getSeller().havenod && !ctx.isPaymentSent) expect(buyerPaymentAccountPayload).toBeUndefined();
  else {
    let expectedBuyerPaymentAccountPayload = (await ctx.getBuyer().havenod?.getPaymentAccount(buyerPaymentAccountPayload?.getId()!))?.getPaymentAccountPayload();
    expect(buyerPaymentAccountPayload).toEqual(expectedBuyerPaymentAccountPayload);
    expect(await ctx.arbitrator.havenod?.getPaymentAccountPayloadForm(buyerPaymentAccountPayload!)).toEqual(await ctx.arbitrator.havenod?.getPaymentAccountPayloadForm(expectedBuyerPaymentAccountPayload!));
  }
  buyerPaymentAccountPayload = arbDisputePeer.getContract()!.getIsBuyerMakerAndSellerTaker() ? arbDisputePeer.getMakerPaymentAccountPayload() : arbDisputePeer.getTakerPaymentAccountPayload();
  if (ctx.getDisputeOpener()!.havenod === ctx.getSeller().havenod && !ctx.isPaymentSent) expect(buyerPaymentAccountPayload).toBeUndefined();
  else {
    let expectedBuyerPaymentAccountPayload = (await ctx.getBuyer().havenod?.getPaymentAccount(buyerPaymentAccountPayload?.getId()!))?.getPaymentAccountPayload();
    expect(buyerPaymentAccountPayload).toEqual(expectedBuyerPaymentAccountPayload);
    expect(await ctx.arbitrator.havenod?.getPaymentAccountPayloadForm(buyerPaymentAccountPayload!)).toEqual(await ctx.arbitrator.havenod?.getPaymentAccountPayloadForm(expectedBuyerPaymentAccountPayload!));
  }

  // register to receive notifications
  const disputeOpenerNotifications: NotificationMessage[] = [];
  const disputePeerNotifications: NotificationMessage[] = [];
  const arbitratorNotifications: NotificationMessage[] = [];
  await ctx.getDisputeOpener()!.havenod!.addNotificationListener(notification => { HavenoUtils.log(3, "Dispute opener received notification " + notification.getType() + " " + (notification.getChatMessage() ? notification.getChatMessage()?.getMessage() : "")); disputeOpenerNotifications.push(notification); });
  await ctx.getDisputePeer()!.havenod!.addNotificationListener(notification => { HavenoUtils.log(3, "Dispute peer received notification " + notification.getType() + " " + (notification.getChatMessage() ? notification.getChatMessage()?.getMessage() : "")); disputePeerNotifications.push(notification); });
  await arbitrator.addNotificationListener(notification => { HavenoUtils.log(3, "Arbitrator received notification " + notification.getType() + " " + (notification.getChatMessage() ? notification.getChatMessage()?.getMessage() : "")); arbitratorNotifications.push(notification); });

  // test chat messages
  if (ctx.testChatMessages) {

    // arbitrator sends chat messages to traders
    HavenoUtils.log(1, "Arbitrator sending chat messages to traders. tradeId=" + ctx.offerId + ", disputeId=" + openerDispute.getId());
    await ctx.arbitrator.havenod!.sendDisputeChatMessage(arbDisputeOpener!.getId(), "Arbitrator chat message to dispute opener", []);
    await ctx.arbitrator.havenod!.sendDisputeChatMessage(arbDisputePeer!.getId(), "Arbitrator chat message to dispute peer", []);

    // traders reply to arbitrator chat messages
    await wait(ctx.maxTimePeerNoticeMs); // wait for arbitrator's message to arrive
    const attachment = new Attachment();
    const bytes = new Uint8Array(Buffer.from("Proof dispute opener was scammed", "utf8"));
    attachment.setBytes(bytes);
    attachment.setFileName("proof.txt");
    const attachment2 = new Attachment();
    const bytes2 = new Uint8Array(Buffer.from("picture bytes", "utf8"));
    attachment2.setBytes(bytes2);
    attachment2.setFileName("proof.png");
    HavenoUtils.log(2, "Dispute opener sending chat message to arbitrator. tradeId=" + ctx.offerId + ", disputeId=" + openerDispute.getId());
    await ctx.getDisputeOpener()!.havenod!.sendDisputeChatMessage(openerDispute.getId(), "Dispute opener chat message", [attachment, attachment2]);
    await wait(ctx.maxTimePeerNoticeMs); // wait for user2's message to arrive
    HavenoUtils.log(2, "Dispute peer sending chat message to arbitrator. tradeId=" + ctx.offerId + ", disputeId=" + peerDispute.getId());
    await ctx.getDisputePeer()!.havenod!.sendDisputeChatMessage(peerDispute.getId(), "Dispute peer chat message", []);

    // test trader chat messages
    await wait(ctx.maxTimePeerNoticeMs);
    let dispute = await ctx.getDisputeOpener()!.havenod!.getDispute(ctx.offerId!);
    let messages = dispute.getChatMessageList();
    expect(messages.length).toBeGreaterThanOrEqual(3); // last messages are chat, first messages are system message and possibly DisputeOpenedMessage acks
    try {
      expect(messages[messages.length - 2].getMessage()).toEqual("Arbitrator chat message to dispute opener");
      expect(messages[messages.length - 1].getMessage()).toEqual("Dispute opener chat message");
    } catch (err) {
      console.log("Dispute peer chat messages length: " + messages.length);
      console.log("Dispute peer chat messages : " + JSON.stringify(messages));
      throw err;
    }

    let attachments = messages[messages.length - 1].getAttachmentsList();
    expect(attachments.length).toEqual(2);
    expect(attachments[0].getFileName()).toEqual("proof.txt");
    expect(attachments[0].getBytes()).toEqual(bytes);
    expect(attachments[1].getFileName()).toEqual("proof.png");
    expect(attachments[1].getBytes()).toEqual(bytes2);
    dispute = await ctx.getDisputePeer()!.havenod!.getDispute(ctx.offerId!);
    messages = dispute.getChatMessageList();
    expect(messages.length).toBeGreaterThanOrEqual(3);
    try {
      expect(messages[messages.length - 2].getMessage()).toEqual("Arbitrator chat message to dispute peer");
      expect(messages[messages.length - 1].getMessage()).toEqual("Dispute peer chat message");
    } catch (err) {
      console.log("Dispute peer chat messages length: " + messages.length);
      console.log("Dispute peer chat messages : " + JSON.stringify(messages));
      throw err;
    }

    // test notifications of chat messages
    let chatNotifications = getNotifications(disputeOpenerNotifications, NotificationMessage.NotificationType.CHAT_MESSAGE, ctx.offerId);
    expect(chatNotifications.length).toBe(1);
    expect(chatNotifications[0].getChatMessage()?.getMessage()).toEqual("Arbitrator chat message to dispute opener");
    chatNotifications = getNotifications(disputePeerNotifications, NotificationMessage.NotificationType.CHAT_MESSAGE, ctx.offerId);
    expect(chatNotifications.length).toBe(1);
    expect(chatNotifications[0].getChatMessage()?.getMessage()).toEqual("Arbitrator chat message to dispute peer");

    // arbitrator has 2 chat messages, one with attachments
    chatNotifications = getNotifications(arbitratorNotifications, NotificationMessage.NotificationType.CHAT_MESSAGE, ctx.offerId);
    expect(chatNotifications.length).toBe(2);
    expect(chatNotifications[0].getChatMessage()?.getMessage()).toEqual("Dispute opener chat message");
    assert(chatNotifications[0].getChatMessage()?.getAttachmentsList());
    attachments = chatNotifications[0].getChatMessage()?.getAttachmentsList()!;
    expect(attachments[0].getFileName()).toEqual("proof.txt");
    expect(attachments[0].getBytes()).toEqual(bytes);
    expect(attachments[1].getFileName()).toEqual("proof.png");
    expect(attachments[1].getBytes()).toEqual(bytes2);
    expect(chatNotifications[1].getChatMessage()?.getMessage()).toEqual("Dispute peer chat message");
  }
}

async function resolveDispute(ctxP: Partial<TradeContext>) {
  let ctx = TradeContext.init(ctxP);

  // stop buyer or seller depending on configuration
  const promises: Promise<void>[] = [];
  if (ctx.getBuyer().havenod && ctx.buyerOfflineAfterDisputeOpened) {
    promises.push(releaseHavenoProcess(ctx.getBuyer().havenod!)); // stop buyer
    if (ctx.isBuyerMaker()) ctx.maker.havenod = undefined;
    else ctx.taker.havenod = undefined;
  }
  if (ctx.getSeller().havenod && ctx.sellerOfflineAfterDisputeOpened) {
    promises.push(releaseHavenoProcess(ctx.getSeller().havenod!)); // stop seller
    if (ctx.isBuyerMaker()) ctx.taker.havenod = undefined;
    else ctx.maker.havenod = undefined;
  }
  await Promise.all(promises);

  // award too much to winner (majority receiver)
  let trade = await arbitrator.getTrade(ctx.offerId!)
  const tradeAmount: bigint = BigInt(trade!.getAmount());
  let customWinnerAmount = tradeAmount + BigInt(trade.getBuyerSecurityDeposit()) + BigInt(trade.getSellerSecurityDeposit() + 1n); // mining fee is subtracted from security deposits
  try {
    await arbitrator.resolveDispute(ctx.offerId!, ctx.disputeWinner!, ctx.disputeReason!, "Winner gets too much", customWinnerAmount);
    throw new Error("Should have failed resolving dispute with too much winner payout");
  } catch (err: any) {
    assert.equal(err.message, "Winner payout is more than the trade wallet's balance");
  }

  // award too little to loser (minority receiver)
  let makerDepositTx = await monerod.getTx(trade.getMakerDepositTxId());
  let takerDepositTx = await monerod.getTx(trade.getTakerDepositTxId());
  customWinnerAmount = tradeAmount + BigInt(trade.getBuyerSecurityDeposit()) + BigInt(trade.getSellerSecurityDeposit()) - 10000n;
  try {
    await arbitrator.resolveDispute(ctx.offerId!, ctx.disputeWinner!, ctx.disputeReason!, "Loser gets too little", customWinnerAmount);
    throw new Error("Should have failed resolving dispute with insufficient loser payout");
  } catch (err: any) {
    assert.equal(err.message, "Loser payout is too small to cover the mining fee");
  }

  // resolve dispute according to configuration
  HavenoUtils.log(1, "Resolving dispute for trade " + ctx.offerId);
  const startTime = Date.now();
  await arbitrator.resolveDispute(ctx.offerId!, ctx.disputeWinner!, ctx.disputeReason!, ctx.disputeSummary!, ctx.disputeWinnerAmount);
  HavenoUtils.log(1, "Done resolving dispute (" + (Date.now() - startTime) + ")");

  // start buyer or seller depending on configuration
  if (!ctx.getBuyer().havenod && ctx.buyerOfflineAfterDisputeOpened === false) {
    // TODO: wait additional time before starting to avoid 503? need to wait after shut down?
    const buyer = await initHaveno({appName: ctx.buyerAppName, excludePorts: ctx.usedPorts}); // start buyer
    if (ctx.isBuyerMaker()) ctx.maker.havenod = buyer;
    else ctx.taker.havenod = buyer;
    ctx.usedPorts!.push(getPort(buyer.getUrl()));
  }
  if (!ctx.getSeller().havenod && ctx.sellerOfflineAfterDisputeOpened === false) {
    const seller = await initHaveno({appName: ctx.sellerAppName, excludePorts: ctx.usedPorts}); // start seller
    if (ctx.isBuyerMaker()) ctx.taker.havenod = seller;
    else ctx.maker.havenod = seller;
    ctx.usedPorts!.push(getPort(ctx.getSeller().havenod!.getUrl()))
  }

  // test resolved dispute
  await wait(TestConfig.maxWalletStartupMs + ctx.walletSyncPeriodMs * 2);
  if (ctx.getDisputeOpener()!.havenod) {
    const dispute = await ctx.getDisputeOpener()!.havenod!.getDispute(ctx.offerId!);
    assert(dispute.getIsClosed(), "Dispute is not closed for opener, trade " + ctx.offerId);
  }
  if (ctx.getDisputePeer()!.havenod) {
    const dispute = await ctx.getDisputePeer()!.havenod!.getDispute(ctx.offerId!);
    assert(dispute.getIsClosed(), "Dispute is not closed for opener's peer, trade " + ctx.offerId);
  }

  // test trade state
  if (ctx.getBuyer().havenod) await testTradeState(await ctx.getBuyer().havenod!.getTrade(ctx.offerId!), {phase: ctx.getPhase(), payoutState: ["PAYOUT_PUBLISHED", "PAYOUT_CONFIRMED", "PAYOUT_UNLOCKED"], disputeState: "DISPUTE_CLOSED", isCompleted: true, isPayoutPublished: true});
  if (ctx.getSeller().havenod) await testTradeState(await ctx.getSeller().havenod!.getTrade(ctx.offerId!), {phase: ctx.getPhase(), payoutState: ["PAYOUT_PUBLISHED", "PAYOUT_CONFIRMED", "PAYOUT_UNLOCKED"], disputeState: "DISPUTE_CLOSED", isCompleted: true, isPayoutPublished: true});
  await testTradeState(await ctx.arbitrator.havenod!.getTrade(ctx.offerId!), {phase: ctx.getPhase(), payoutState: ["PAYOUT_PUBLISHED", "PAYOUT_CONFIRMED", "PAYOUT_UNLOCKED"], disputeState: "DISPUTE_CLOSED", isCompleted: true, isPayoutPublished: true});

  // signing peer has payout tx id on 0 conf (peers must wait for confirmation to see outgoing tx)
  const winnerd = ctx.disputeWinner === DisputeResult.Winner.BUYER ? ctx.getBuyer().havenod : ctx.getSeller().havenod;
  const loserd = ctx.disputeWinner === DisputeResult.Winner.BUYER ? ctx.getSeller().havenod : ctx.getBuyer().havenod;
  const signerd = winnerd ? winnerd : loserd;
  ctx.payoutTxId = (await signerd!.getTrade(ctx.offerId!)).getPayoutTxId();

  // record balances on completion
  if (!ctx.maker.balancesAfterPayout) {
    ctx.maker.balancesAfterPayout = await ctx.maker.havenod?.getBalances();
    ctx.taker.balancesAfterPayout = await ctx.taker.havenod?.getBalances();
  }

  // test balances after payout tx unless concurrent trades
  if (!ctx.concurrentTrades) await testAmountsAfterComplete(ctx);

  // test payout unlock
  await testTradePayoutUnlock(ctx);
}

async function testAmountsAfterComplete(tradeCtx: TradeContext) {

  // get payout tx
  if (!tradeCtx.payoutTxId) throw new Error("Missing payout tx id");
  const payoutTx = await monerod.getTx(tradeCtx.payoutTxId);
  const payoutTxFee = BigInt(payoutTx!.getFee());

  // get expected payouts for normal trade
  const isDisputedTrade = tradeCtx.getDisputeOpener() !== undefined;
  if (!isDisputedTrade) {
    tradeCtx.getBuyer().payoutTxFee = payoutTxFee / 2n;
    tradeCtx.getBuyer().payoutAmount = tradeCtx.getBuyer().securityDepositActual! + tradeCtx.tradeAmount! - tradeCtx.getBuyer().payoutTxFee!;
    tradeCtx.getSeller().payoutTxFee = payoutTxFee / 2n;
    tradeCtx.getSeller().payoutAmount = tradeCtx.getSeller().securityDepositActual! - tradeCtx.getSeller().payoutTxFee!;
  } else {

    // get expected payouts for disputed trade
    const winnerGetsAll = tradeCtx.disputeWinnerAmount === tradeCtx.maker.securityDepositActual! + tradeCtx.taker.securityDepositActual! + tradeCtx.tradeAmount!;
    if (tradeCtx.disputeWinnerAmount) {
      tradeCtx.getDisputeWinner()!.payoutTxFee = winnerGetsAll ? payoutTxFee : 0n;
      tradeCtx.getDisputeWinner()!.payoutAmount = tradeCtx.disputeWinnerAmount - tradeCtx.getDisputeWinner()!.payoutTxFee!;
      tradeCtx.getDisputeLoser()!.payoutTxFee = winnerGetsAll ? 0n : payoutTxFee;
      tradeCtx.getDisputeLoser()!.payoutAmount = tradeCtx.maker.securityDepositActual! + tradeCtx.taker.securityDepositActual! + tradeCtx.tradeAmount! - tradeCtx.disputeWinnerAmount - tradeCtx.getDisputeLoser()!.payoutTxFee!;
    } else {
      tradeCtx.getDisputeWinner()!.payoutTxFee = payoutTxFee / 2n;
      tradeCtx.getDisputeWinner()!.payoutAmount = tradeCtx.tradeAmount! + tradeCtx.getDisputeWinner()!.securityDepositActual! - tradeCtx.getDisputeWinner()!.payoutTxFee!;
      tradeCtx.getDisputeLoser()!.payoutTxFee = payoutTxFee / 2n;
      tradeCtx.getDisputeLoser()!.payoutAmount = tradeCtx.getDisputeLoser()!.securityDepositActual! - tradeCtx.getDisputeLoser()!.payoutTxFee!;
    }
  }

  // TODO: payout tx is unknown to offline non-signer until confirmed
  if (isDisputedTrade || tradeCtx.isOfflineFlow()) {
    await mineToHeight(await monerod.getHeight() + 1);
    await wait(TestConfig.maxWalletStartupMs + tradeCtx.walletSyncPeriodMs * 2);
  }

  // test trade payouts
  if (tradeCtx.maker.havenod) await testPeerAmountsAfterComplete(tradeCtx, tradeCtx.getMaker());
  if (tradeCtx.taker.havenod) await testPeerAmountsAfterComplete(tradeCtx, tradeCtx.getTaker());
}

async function testPeerAmountsAfterComplete(tradeCtx: TradeContext, peerCtx: PeerContext) {

  // get trade
  const trade = await peerCtx.havenod!.getTrade(tradeCtx.offerId!);

  // test trade amounts
  const isBuyer = tradeCtx.getBuyer() === peerCtx;
  if (isBuyer) expect(BigInt(trade.getBuyerDepositTxFee())).toEqual(tradeCtx.getBuyer().depositTxFee); // TODO: get and test peer's security deposit tx fee?
  else expect(BigInt(trade.getSellerDepositTxFee())).toEqual(tradeCtx.getSeller().depositTxFee);
  expect(BigInt(trade.getBuyerPayoutTxFee())).toEqual(tradeCtx.getBuyer().payoutTxFee);
  expect(BigInt(trade.getSellerPayoutTxFee())).toEqual(tradeCtx.getSeller().payoutTxFee);
  expect(BigInt(trade.getBuyerPayoutAmount())).toEqual(tradeCtx.getBuyer().payoutAmount);
  expect(BigInt(trade.getSellerPayoutAmount())).toEqual(tradeCtx.getSeller().payoutAmount);

  // test balance change after payout tx
  const differenceAfterPayout = BigInt(peerCtx.balancesAfterPayout?.getBalance()!) - BigInt(peerCtx.balancesBeforePayout?.getBalance()!);
  expect(differenceAfterPayout).toEqual(peerCtx.payoutAmount);

  // test balance change since before offer
  if (tradeCtx.testBalanceChangeEndToEnd) {

    // calculate expected balance from before offer
    const sendTradeAmount = tradeCtx.getBuyer() === peerCtx ? 0n : BigInt(trade.getAmount());
    const expectedBalanceAfterComplete = BigInt(peerCtx.balancesBeforeOffer?.getBalance()!) - peerCtx.splitOutputTxFee! - peerCtx.tradeFee! - sendTradeAmount - peerCtx.depositTxFee! - peerCtx.securityDepositActual! + peerCtx.payoutAmount!;

    // log the math
    HavenoUtils.log(1, "Testing end-to-end balance change:");
    HavenoUtils.log(1, "Expected balance after = balance before - split output tx fee if maker and exact amount reserved - trade fee - trade amount if seller - deposit tx fee - security deposit received + (trade amount if seller + security deposit received - (payout tx fee / 2))");
    HavenoUtils.log(1, expectedBalanceAfterComplete + " = " + BigInt(peerCtx.balancesBeforeOffer?.getBalance()!) + " - " + peerCtx.splitOutputTxFee + " - " + peerCtx.tradeFee! + " - " + sendTradeAmount + " - " + peerCtx.depositTxFee + " - " + peerCtx.securityDepositActual + " + " + peerCtx.payoutAmount);

    // test the expected balance
    expect(BigInt(peerCtx.balancesAfterPayout?.getBalance()!)).toEqual(expectedBalanceAfterComplete);
  }
}

async function testTradeChat(ctxP: Partial<TradeContext>) {
  const ctx = TradeContext.init(ctxP);
  HavenoUtils.log(1, "Testing trade chat");

  // invalid trade should throw error
  try {
    await user1.getChatMessages("invalid");
    throw new Error("get chat messages with invalid id should fail");
  } catch (err: any) {
    assert.equal(err.message, "trade with id 'invalid' not found");
  }

  // trade chat should be in initial state
  let messages = await user1.getChatMessages(ctx.offerId!);
  assert(messages.length === 0);
  messages = await user2.getChatMessages(ctx.offerId!);
  assert(messages.length === 0);

  // add notification handlers and send some messages
  const user1Notifications: NotificationMessage[] = [];
  const user2Notifications: NotificationMessage[] = [];
  await user1.addNotificationListener(notification => { user1Notifications.push(notification); });
  await user2.addNotificationListener(notification => { user2Notifications.push(notification); });

  // send simple conversation and verify the list of messages
  const user1Msg = "Hi I'm user1";
  await user1.sendChatMessage(ctx.offerId!, user1Msg);
  await wait(ctx.maxTimePeerNoticeMs);
  messages = await user2.getChatMessages(ctx.offerId!);
  expect(messages.length).toEqual(2);
  expect(messages[0].getIsSystemMessage()).toEqual(true); // first message is system
  expect(messages[1].getMessage()).toEqual(user1Msg);

  const user2Msg = "Hello I'm user2";
  await user2.sendChatMessage(ctx.offerId!, user2Msg);
  await wait(ctx.maxTimePeerNoticeMs);
  messages = await user1.getChatMessages(ctx.offerId!);
  expect(messages.length).toEqual(3);
  expect(messages[0].getIsSystemMessage()).toEqual(true);
  expect(messages[1].getMessage()).toEqual(user1Msg);
  expect(messages[2].getMessage()).toEqual(user2Msg);

  // verify notifications
  let chatNotifications = getNotifications(user1Notifications, NotificationMessage.NotificationType.CHAT_MESSAGE);
  expect(chatNotifications.length).toBe(1);
  expect(chatNotifications[0].getChatMessage()?.getMessage()).toEqual(user2Msg);
  chatNotifications = getNotifications(user2Notifications, NotificationMessage.NotificationType.CHAT_MESSAGE);
  expect(chatNotifications.length).toBe(1);
  expect(chatNotifications[0].getChatMessage()?.getMessage()).toEqual(user1Msg);

  // additional msgs
  const msgs = ["", "  ", "<script>alert('test');</script>", "さようなら"];
  for(const msg of msgs) {
    await user1.sendChatMessage(ctx.offerId!, msg);
    await wait(1000); // the async operation can result in out of order messages
  }
  await wait(ctx.maxTimePeerNoticeMs);
  messages = await user2.getChatMessages(ctx.offerId!);
  let offset = 3; // 3 existing messages
  expect(messages.length).toEqual(offset + msgs.length);
  expect(messages[0].getIsSystemMessage()).toEqual(true);
  expect(messages[1].getMessage()).toEqual(user1Msg);
  expect(messages[2].getMessage()).toEqual(user2Msg);
  for (let i = 0; i < msgs.length; i++) {
    expect(messages[i + offset].getMessage()).toEqual(msgs[i]);
  }

  chatNotifications = getNotifications(user2Notifications, NotificationMessage.NotificationType.CHAT_MESSAGE);
  offset = 1; // 1 existing notification
  expect(chatNotifications.length).toBe(offset + msgs.length);
  expect(chatNotifications[0].getChatMessage()?.getMessage()).toEqual(user1Msg);
  for (let i = 0; i < msgs.length; i++) {
    expect(chatNotifications[i + offset].getChatMessage()?.getMessage()).toEqual(msgs[i]);
  }
}

// ---------------------------- OTHER HELPERS ---------------------------------

function getPort(url: string): string {
  return new URL(url).port;
}

function getBaseCurrencyNetwork(): BaseCurrencyNetwork {
  const str = getBaseCurrencyNetworkStr();
  if (str === "XMR_MAINNET") return BaseCurrencyNetwork.XMR_MAINNET;
  else if (str === "XMR_STAGENET") return BaseCurrencyNetwork.XMR_STAGENET;
  else if (str === "XMR_LOCAL") return BaseCurrencyNetwork.XMR_LOCAL;
  else throw new Error("Unhandled base currency network: " + str);
  function getBaseCurrencyNetworkStr() {
    for (const arg of process.argv) {
      if (arg.indexOf("--baseCurrencyNetwork") === 0) {
        return arg.substring(arg.indexOf("=") + 1);
      }
    }
    throw new Error("Must provide base currency network, e.g.: `npm run test -- --baseCurrencyNetwork=XMR_LOCAL -t \"my test\"`");
  }
}

function getNetworkStartPort() {
  switch (getBaseCurrencyNetwork()) {
      case BaseCurrencyNetwork.XMR_MAINNET: return 1;
      case BaseCurrencyNetwork.XMR_LOCAL: return 2;
      case BaseCurrencyNetwork.XMR_STAGENET: return 3;
      default: throw new Error("Unhandled base currency network: " + getBaseCurrencyNetwork());
  }
}

function getArbitratorPrivKey(index: number) {
  const privKey = TestConfig.arbitratorPrivKeys[getBaseCurrencyNetwork()][index];
  if (!privKey) throw new Error("No arbitrator private key at index " + index);
  return privKey;
}

async function initHavenos(numDaemons: number, config?: any) {
  const havenodPromises: Promise<HavenoClient>[] = [];
  for (let i = 0; i < numDaemons; i++) havenodPromises.push(initHaveno(config));
  return Promise.all(havenodPromises);
}

async function initHaveno(ctx?: HavenodContext): Promise<HavenoClient> {
  if (!ctx) ctx = {};
  Object.assign(ctx, TestConfig.defaultHavenod, Object.assign({}, ctx));
  if (!ctx.appName) ctx.appName = "haveno-" + TestConfig.baseCurrencyNetwork + "_instance_" + moneroTs.GenUtils.getUUID();

  // connect to existing server or start new process
  let havenod: HavenoClient;
  try {

    // try to connect to existing server
    if (!ctx.port) throw new Error("Cannot connect without port");
    havenod = new HavenoClient("http://localhost:" + ctx.port, ctx.apiPassword!);
    await havenod.getVersion();
  } catch (err: any) {

    // get port for haveno process
    if (!ctx.port) {
      for (const httpPort of Array.from(TestConfig.ports.keys())) {
        if (httpPort === "8079" || httpPort === "8080" || httpPort === "8081") continue; // reserved for arbitrator, user1, and user2
        if (!moneroTs.GenUtils.arrayContains(HAVENO_PROCESS_PORTS, httpPort) && (!ctx.excludePorts || !moneroTs.GenUtils.arrayContains(ctx.excludePorts, httpPort))) {
          HAVENO_PROCESS_PORTS.push(httpPort);
          ctx.port = httpPort;
          break;
        }
      }
    }
    if (!ctx.port) throw new Error("No unused test ports available");

    // start haveno process using configured ports if available
    const cmd: string[] = [
      "./haveno-daemon",
      "--baseCurrencyNetwork", TestConfig.baseCurrencyNetwork,
      "--useLocalhostForP2P", TestConfig.baseCurrencyNetwork === BaseCurrencyNetwork.XMR_MAINNET ? "false" : "true", // TODO: disable for stagenet too
      "--useDevPrivilegeKeys", TestConfig.baseCurrencyNetwork === BaseCurrencyNetwork.XMR_LOCAL ? "true" : "false",
      "--nodePort", TestConfig.ports.get(ctx.port)![1],
      "--appName", ctx.appName,
      "--apiPassword", "apitest",
      "--apiPort", TestConfig.ports.get(ctx.port)![0],
      "--walletRpcBindPort", ctx.walletUrl ? getPort(ctx.walletUrl) : "" + await getAvailablePort(), // use configured port if given
      "--passwordRequired", (ctx.accountPasswordRequired ? "true" : "false"),
      "--logLevel", ctx.logLevel!
    ];
    havenod = await HavenoClient.startProcess(TestConfig.haveno.path, cmd, "http://localhost:" + ctx.port, ctx.logProcessOutput!);
    HAVENO_PROCESSES.push(havenod);

    // wait to process network notifications
    await wait(3000);
  }

  // open account if configured
  if (ctx.autoLogin) {
    try {
      await initHavenoAccount(havenod, ctx.accountPassword!);
    } catch (err) {
      await releaseHavenoProcess(havenod);
      throw err;
    }
  }
  return havenod;

  async function getAvailablePort(): Promise<number> {
    return new Promise(function(resolve) {
      const srv = net.createServer();
      srv.listen(0, function() {
        const port = (srv.address() as net.AddressInfo).port;
        srv.close(function() {
          resolve(port);
        });
      });
    });
  }
}

/**
 * Release a Haveno process for reuse and try to shutdown.
 */
async function releaseHavenoProcess(havenod: HavenoClient, deleteAppDir?: boolean) {
  moneroTs.GenUtils.remove(HAVENO_PROCESSES, havenod);
  moneroTs.GenUtils.remove(HAVENO_PROCESS_PORTS, getPort(havenod.getUrl()));
  try {
    await havenod.shutdownServer();
  } catch (err: any) {
    assert(err.message.indexOf(OFFLINE_ERR_MSG) >= 0, "Unexpected error shutting down server: " + err.message);
  }
  if (deleteAppDir) deleteHavenoInstance(havenod);
}

/**
 * Delete a Haveno instance from disk.
 */
function deleteHavenoInstance(havenod: HavenoClient) {
    if (!havenod.getAppName()) throw new Error("Cannot delete Haveno instance owned by different process")
    deleteHavenoInstanceByAppName(havenod.getAppName()!);
}

function deleteHavenoInstanceByAppName(appName: string) {
  const userDataDir = process.env.APPDATA || (process.platform === 'darwin' ? process.env.HOME + '/Library/Application Support' : process.env.HOME + "/.local/share");
  const appPath = path.normalize(userDataDir + "/" + appName);
  fs.rmSync(appPath, { recursive: true, force: true });
}

/**
 * Create or open an account with the given daemon and password.
 */
async function initHavenoAccount(havenod: HavenoClient, password: string) {
  if (await havenod.isAccountOpen()) return;
  if (await havenod.accountExists()) return havenod.openAccount(password);
  await havenod.createAccount(password);
  return;
}

/**
 * Open or create funding wallet.
 */
async function initFundingWallet() {

  // init client connected to monero-wallet-rpc
  fundingWallet = await moneroTs.connectToWalletRpc(TestConfig.fundingWallet.url, TestConfig.fundingWallet.username, TestConfig.fundingWallet.password);

  // check if wallet is open
  let walletIsOpen = false
  try {
    await fundingWallet.getPrimaryAddress();
    walletIsOpen = true;
  } catch (err: any) {
    // do nothing
  }

  // open wallet if necessary
  if (!walletIsOpen) {

    // attempt to open funding wallet
    try {
      await fundingWallet.openWallet({path: TestConfig.fundingWallet.defaultPath, password: TestConfig.fundingWallet.walletPassword});
    } catch (err: any) {
      if (!(err instanceof moneroTs.MoneroRpcError)) throw err;

      // -1 returned when wallet does not exist or fails to open e.g. it's already open by another application
      if (err.getCode() === -1) {

        // create wallet
        await fundingWallet.createWallet({
            path: TestConfig.fundingWallet.defaultPath,
            password: TestConfig.fundingWallet.walletPassword,
            seed: TestConfig.fundingWallet.seed,
            restoreHeight: TestConfig.fundingWallet.restoreHeight
        });
      } else {
        throw err;
      }
    }
  }
}

async function prepareForTrading(numTrades: number, ...havenods: HavenoClient[]) {

  // create payment account for each payment method
  for (const havenod of havenods) {
    for (const paymentMethod of await havenod.getPaymentMethods()) {
      if (await hasPaymentAccount({trader: havenod, paymentMethod: paymentMethod.getId()})) continue; // skip if exists
      const accountForm = await user1.getPaymentAccountForm(paymentMethod.getId());
      for (const field of accountForm.getFieldsList()) field.setValue(getValidFormInput(accountForm, field.getId())); // set all form fields
      await havenod.createPaymentAccount(accountForm);
    }
  }

  // create payment account for each asset code
  for (const havenod of havenods) {
    for (const assetCode of TestConfig.assetCodes.concat(TestConfig.fixedPriceAssetCodes)) {
      if (await hasPaymentAccount({trader: havenod, assetCode: assetCode})) continue; // skip if exists
      await createPaymentAccount(havenod, assetCode);
    }
  }

  // fund wallets
  const tradeAmount = 500000000000n;
  const wallets: moneroTs.MoneroWallet[] = [];
  for (const havenod of havenods) wallets.push(await getWallet(havenod));
  await fundOutputs(wallets, tradeAmount * 2n, numTrades);
}

async function getWallet(havenod: HavenoClient) {
  if (!HAVENO_WALLETS.has(havenod)) {
    let wallet: any;
    if (havenod === user1) wallet = user1Wallet;
    else if (havenod === user2) wallet = user2Wallet;
    else wallet = await moneroTs.connectToWalletRpc("http://127.0.0.1:" + havenod.getWalletRpcPort(), TestConfig.defaultHavenod.walletUsername, TestConfig.defaultHavenod.accountPassword);
    HAVENO_WALLETS.set(havenod, wallet);
  }
  return HAVENO_WALLETS.get(havenod);
}

async function startMining(): Promise<boolean> {
  try {
    const numThreads = getBaseCurrencyNetwork() === BaseCurrencyNetwork.XMR_LOCAL ? 1 : Math.max(1, Math.floor(os.cpus().length * TestConfig.maxCpuPct));
    await monerod.startMining(await fundingWallet.getPrimaryAddress(), numThreads);
    HavenoUtils.log(2, "Mining started");
    return true;
  } catch (err: any) {
    if (err.message !== "Already mining") throw err;
    HavenoUtils.log(2, ("Already mining"));
    return false;
  }
}

async function stopMining() {
  await monerod.stopMining();
  HavenoUtils.log(2, "Mining stopped");
}

async function mineBlocks(numBlocks: number) {
  await mineToHeight(await monerod.getHeight() + numBlocks);
}

async function mineToHeight(height: number) {
  if (await monerod.getHeight() >= height) return;
  const miningStarted = await startMining();
  while (await monerod.getHeight() < height) {
    await moneroTs.GenUtils.waitFor(TestConfig.trade.walletSyncPeriodMs);
  }
  if (miningStarted) await stopMining();
}

async function mineToUnlock(txHash: string) {
  let tx = await monerod.getTx(txHash);
  if (tx && tx.getNumConfirmations() >= 10) return; // TODO: tx.getIsLocked()
  const miningStarted = await startMining();
  while (!tx || tx.getNumConfirmations() < 10) {
    await moneroTs.GenUtils.waitFor(TestConfig.trade.walletSyncPeriodMs);
    tx = await monerod.getTx(txHash);
  }
  if (miningStarted) await stopMining();
}

/**
 * Wait for unlocked balance in wallet or Haveno daemon.
 */
async function waitForAvailableBalance(amount: bigint, ...wallets: any[]) {

  // wrap common wallet functionality for tests
  class WalletWrapper {

    _wallet: moneroTs.MoneroWallet;

    constructor(wallet: any) {
      this._wallet = wallet;
    }

    async getAvailableBalance(): Promise<bigint> {
      if (this._wallet instanceof HavenoClient) return BigInt((await this._wallet.getBalances()).getAvailableBalance());
      else return await this._wallet.getUnlockedBalance();
    }

    async getPendingBalance(): Promise<bigint> {
      if (this._wallet instanceof HavenoClient) return BigInt((await this._wallet.getBalances()).getPendingBalance());
      else return await this._wallet.getBalance() - await this.getAvailableBalance();
    }

    async getDepositAddress(): Promise<string> {
      if (this._wallet instanceof HavenoClient) return await this._wallet.getXmrNewSubaddress();
      else return (await this._wallet.createSubaddress(0)).getAddress();
    }
  }

  // wrap wallets
  for (let i = 0; i < wallets.length; i++) wallets[i] = new WalletWrapper(wallets[i]);

  // fund wallets with insufficient balance
  let miningNeeded = false;
  const fundConfig: moneroTs.MoneroTxConfig = new moneroTs.MoneroTxConfig({accountIndex: 0, relay: true});
  for (const wallet of wallets) {
    const availableBalance = await wallet.getAvailableBalance();
    if (availableBalance < amount) miningNeeded = true;
    const depositNeeded: bigint = amount - availableBalance - await wallet.getPendingBalance();
    if (depositNeeded > 0n && wallet._wallet !== fundingWallet) {
      for (let i = 0; i < 5; i++) {
        fundConfig.addDestination(await wallet.getDepositAddress(), depositNeeded * 2n); // make several deposits
      }
    }
  }
  if (fundConfig.getDestinations()) {
    await waitForAvailableBalance(TestConfig.fundingWallet.minimumFunding, fundingWallet); // TODO (woodser): wait for enough to cover tx amount + fee
    try { await fundingWallet.createTx(fundConfig); }
    catch (err: any) { throw new Error("Error funding wallets: " + err.message); }
  }

  // done if all wallets have sufficient unlocked balance
  if (!miningNeeded) return;

  // wait for funds to unlock
  const miningStarted = await startMining();
  HavenoUtils.log(1, "Mining for unlocked balance of " + amount);
  const promises: Promise<void>[] = [];
  for (const wallet of wallets) {
    if (wallet._wallet === fundingWallet) {
      const subaddress = await fundingWallet.createSubaddress(0);
      HavenoUtils.log(0, "Mining to funding wallet. Alternatively, deposit to: " + subaddress.getAddress());
    }
    // eslint-disable-next-line no-async-promise-executor
    promises.push(new Promise(async (resolve) => {
      const taskLooper: any = new moneroTs.TaskLooper(async function() {
        if (await wallet.getAvailableBalance() >= amount) {
          taskLooper.stop();
          resolve();
        }
      });
      taskLooper.start(5000);
    }));
  }
  await Promise.all(promises);
  if (miningStarted) await stopMining();
  HavenoUtils.log(0, "Funds unlocked, done mining");
}

async function waitForUnlockedTxs(...txHashes: string[]) {
  if (txHashes.length === 0) return;
  HavenoUtils.log(1, "Mining to unlock txs");
  const miningStarted = await startMining();
  const promises: Promise<void>[] = [];
  for (const txHash of txHashes) {
    // eslint-disable-next-line no-async-promise-executor
    promises.push(new Promise(async (resolve) => {
      const taskLooper = new moneroTs.TaskLooper(async function() {
        const tx = await monerod.getTx(txHash);
        if (!tx) HavenoUtils.log(1, "WARNING: tx hash " + txHash + " not found");
        else if (tx.getIsConfirmed() && tx.getBlock().getHeight() <= await monerod.getHeight() - 10) {
          taskLooper.stop();
          resolve();
        }
      });
      taskLooper.start(5000);
    }));
  }
  await Promise.all(promises);
  HavenoUtils.log(1, "Done waiting for txs to unlock");
  if (miningStarted) await stopMining();
}

/**
 * Indicates if the given wallets have unspent outputs.
 *
 * @param {MoneroWallet[]} wallets - wallets to check
 * @param {BigInt} amt - amount to check
 * @param {number?} numOutputs - number of outputs of the given amount (default 1)
 * @param {boolean?} isLocked - specifies if the outputs must be locked or unlocked (default either)
 */
async function hasUnspentOutputs(wallets: any[], amt: BigInt, numOutputs?: number, isLocked?: boolean): Promise<boolean> {
  if (numOutputs === undefined) numOutputs = 1;
  for (const wallet of wallets) {
    const unspentOutputs = await wallet.getOutputs({isSpent: false, isFrozen: false, minAmount: amt, txQuery: {isLocked: isLocked}});
    if (unspentOutputs.length < numOutputs) return false;
  }
  return true;
}

/**
 * Fund the given wallets.
 *
 * @param {MoneroWallet} wallets - monerojs wallets
 * @param {BigInt} amt - the amount to fund
 * @param {number} [numOutputs] - the number of outputs of the given amount (default 1)
 * @param {boolean} [waitForUnlock] - wait for outputs to unlock (default false)
 */
async function fundOutputs(wallets: moneroTs.MoneroWallet[], amt: bigint, numOutputs?: number, waitForUnlock?: boolean): Promise<void> {
  if (numOutputs === undefined) numOutputs = 1;
  if (waitForUnlock === undefined) waitForUnlock = true;

  // collect destinations
  const destinations: moneroTs.MoneroDestination[] = [];
  for (const wallet of wallets) {
    if (await hasUnspentOutputs([wallet], amt, numOutputs, undefined)) continue;
    for (let i = 0; i < numOutputs; i++) {
      destinations.push(new moneroTs.MoneroDestination((await wallet.createSubaddress(0)).getAddress(), amt));
    }
  }
  if (!destinations.length) return;

  // fund destinations
  let txConfig = new moneroTs.MoneroTxConfig().setAccountIndex(0).setRelay(true);
  const txHashes: string[] = [];
  let sendAmt = 0n;
  for (let i = 0; i < destinations.length; i++) {
    txConfig.addDestination(destinations[i], undefined); // TODO: remove once converted to MoneroTxConfig.ts
    sendAmt = sendAmt + destinations[i].getAmount();
    if (i === destinations.length - 1 || (i > 0 && i % 15 === 0)) {
      await waitForAvailableBalance(sendAmt, fundingWallet);
      const txs = await fundingWallet.createTxs(txConfig);
      for (const tx of txs) txHashes.push(tx.getHash());
      txConfig = new moneroTs.MoneroTxConfig().setAccountIndex(0).setRelay(true);
      sendAmt = 0n;
    }
  }

  // if not waiting to unlock, wait to observe txs and return
  if (txHashes.length && !waitForUnlock) {
    await wait(TestConfig.trade.walletSyncPeriodMs);
    return;
  }

  // mine until outputs unlocked
  let miningStarted = false;
  let miningAttempted = false;
  while (!await hasUnspentOutputs(wallets, amt, numOutputs, false)) {
    if (waitForUnlock && !miningAttempted) {
      HavenoUtils.log(1, "Mining to fund outputs");
      miningStarted = await startMining();
      miningAttempted = true;
    }
    await wait(TestConfig.trade.walletSyncPeriodMs);
  }
  if (miningStarted) await stopMining();
}

// eslint-disable-next-line @typescript-eslint/no-unused-vars
function getBalancesStr(balances: XmrBalanceInfo): string {
    return "Balance: " + balances.getBalance() + ",\n" +
           "Available balance: " + balances.getAvailableBalance() + ",\n" +
           "Pending balance: " + balances.getPendingBalance() + ",\n" +
           "Reserved in offers: " + balances.getReservedOfferBalance() + ",\n" +
           "Locked in trade: " + balances.getReservedTradeBalance();
}

async function wait(durationMs: number) {
  return new Promise(function(resolve) { setTimeout(resolve, durationMs); });
}

function getNotifications(notifications: NotificationMessage[], notificationType: NotificationMessage.NotificationType, tradeId?: string) {
  const filteredNotifications: NotificationMessage[] = [];
  for (const notification of notifications) {
    if (notification.getType() !== notificationType) continue;
    if (tradeId) {
      let found = false;
      if (notification.getTrade() && notification.getTrade()!.getTradeId() === tradeId) found = true;
      if (notification.getChatMessage() && notification.getChatMessage()!.getTradeId() === tradeId) found = true;
      if (!found) continue;
    }
    filteredNotifications.push(notification);
  }
  return filteredNotifications;
}

function getConnection(connections: UrlConnection[], url: string): UrlConnection|undefined {
  for (const connection of connections) if (connection.getUrl() === url) return connection;
  return undefined;
}

function testConnection(connection: UrlConnection, url?: string, onlineStatus?: OnlineStatus, authenticationStatus?: AuthenticationStatus, priority?: number) {
  if (url) assert.equal(connection.getUrl(), url);
  assert.equal(connection.getPassword(), ""); // TODO (woodser): undefined instead of ""?
  assert.equal(connection.getUsername(), "");
  if (onlineStatus !== undefined) assert.equal(connection.getOnlineStatus(), onlineStatus);
  if (authenticationStatus !== undefined) assert.equal(connection.getAuthenticationStatus(), authenticationStatus);
  if (priority !== undefined) assert.equal(connection.getPriority(), priority);
}

function testTx(tx: XmrTx, ctx: TxContext) {
  assert(tx.getHash());
  expect(BigInt(tx.getFee())).toBeLessThan(TestConfig.maxFee);
  if (tx.getIsConfirmed()) {
    assert(tx.getTimestamp() > 1000);
    assert(tx.getHeight() > 0);
  } else {
    assert.equal(tx.getHeight(), 0);
  }
  assert(tx.getOutgoingTransfer() || tx.getIncomingTransfersList().length); // TODO (woodser): test transfers
  for (const incomingTransfer of tx.getIncomingTransfersList()) testTransfer(incomingTransfer, ctx);
  if (tx.getOutgoingTransfer()) testTransfer(tx.getOutgoingTransfer()!, ctx);
  if (ctx.isCreatedTx) testCreatedTx(tx);
}

function testCreatedTx(tx: XmrTx) {
   assert.equal(tx.getTimestamp(), 0);
   assert.equal(tx.getIsConfirmed(), false);
   assert.equal(tx.getIsLocked(), true);
   assert(tx.getMetadata() && tx.getMetadata().length > 0);
}

function testTransfer(transfer: XmrIncomingTransfer | XmrOutgoingTransfer, ctx: TxContext) {
  expect(BigInt(transfer.getAmount())).toBeGreaterThanOrEqual(0n);
  assert(transfer.getAccountIndex() >= 0);
  if (transfer instanceof XmrIncomingTransfer) testIncomingTransfer(transfer);
  else testOutgoingTransfer(transfer, ctx);
}

function testIncomingTransfer(transfer: XmrIncomingTransfer) {
  assert(transfer.getAddress());
  assert(transfer.getSubaddressIndex() >= 0);
  assert(transfer.getNumSuggestedConfirmations() > 0);
}

function testOutgoingTransfer(transfer: XmrOutgoingTransfer, ctx: TxContext) {
  if (!ctx.isCreatedTx) assert(transfer.getSubaddressIndicesList().length > 0);
  for (const subaddressIdx of transfer.getSubaddressIndicesList()) assert(subaddressIdx >= 0);

  // test destinations sum to outgoing amount
  if (transfer.getDestinationsList().length > 0) {
    let sum = 0n;
    for (const destination of transfer.getDestinationsList()) {
      testDestination(destination);
      expect(BigInt(destination.getAmount())).toBeGreaterThan(0n);
      sum += BigInt(destination.getAmount());
    }
    assert.equal(sum, BigInt(transfer.getAmount()));
  }
}

function testDestination(destination: XmrDestination) {
  assert(destination.getAddress());
  expect(BigInt(destination.getAmount())).toBeGreaterThan(0n);
}

function getRandomBigIntWithinPercent(base: bigint, percent: number): bigint {
  return getRandomBigIntWithinRange(base - multiply(base, percent), base + multiply(base, percent));
}

function multiply(amount: bigint, multiplier: number): bigint {
  return BigInt(Math.round(Number(amount) * multiplier));
}

function getRandomBigIntWithinRange(min: bigint, max: bigint): bigint {
  return BigInt(Math.floor(Math.random() * (Number(max) - Number(min))) + Number(min));
}

function getRandomAssetCode() {
  return TestConfig.assetCodes[moneroTs.GenUtils.getRandomInt(0, TestConfig.assetCodes.length - 1)];
}

async function hasPaymentAccount(config: { trader: HavenoClient; assetCode?: string; paymentMethod?: string }): Promise<boolean> {
  for (const paymentAccount of await config.trader.getPaymentAccounts()) {
    if (config.assetCode?.toUpperCase() === paymentAccount.getSelectedTradeCurrency()!.getCode()) return true;
    if (config.paymentMethod?.toUpperCase() === paymentAccount.getPaymentMethod()!.getId()) return true;
  }
  return false;
}

function isCrypto(assetCode: string) {
  return getCryptoAddress(assetCode) !== undefined;
}

function getCryptoAddress(currencyCode: string): string|undefined {
  for (const cryptoAddress of TestConfig.cryptoAddresses) {
    if (cryptoAddress.currencyCode === currencyCode.toUpperCase()) return cryptoAddress.address;
  }
}

async function createPaymentAccount(trader: HavenoClient, assetCodes: string, paymentMethodId?: string | PaymentAccountForm.FormId) {
  if (!paymentMethodId) paymentMethodId = isCrypto(assetCodes!) ? PaymentAccountForm.FormId.BLOCK_CHAINS : PaymentAccountForm.FormId.PAY_BY_MAIL;
  const accountForm = await trader.getPaymentAccountForm(paymentMethodId);
  for (const field of accountForm.getFieldsList()) field.setValue(getValidFormInput(accountForm, field.getId()));
  if (HavenoUtils.hasFormField(accountForm, PaymentAccountFormField.FieldId.TRADE_CURRENCIES)) HavenoUtils.setFormValue(accountForm, PaymentAccountFormField.FieldId.TRADE_CURRENCIES, assetCodes);
  return await trader.createPaymentAccount(accountForm);
}

async function createCryptoPaymentAccount(trader: HavenoClient, currencyCode = "eth"): Promise<PaymentAccount> {
  for (const cryptoAddress of TestConfig.cryptoAddresses) {
    if (cryptoAddress.currencyCode.toLowerCase() !== currencyCode.toLowerCase()) continue;
    return trader.createCryptoPaymentAccount(
      cryptoAddress.currencyCode + " " +  cryptoAddress.address.substr(0, 8) + "... " + moneroTs.GenUtils.getUUID(),
      cryptoAddress.currencyCode,
      cryptoAddress.address);
  }
  throw new Error("No test config for crypto: " + currencyCode);
}

function getOffer(offers: OfferInfo[], id: string): OfferInfo|undefined {
  return offers.find(offer => offer.getId() === id);
}

function testCryptoPaymentAccount(acct: PaymentAccount) {
  expect(acct.getId().length).toBeGreaterThan(0);
  expect(acct.getAccountName().length).toBeGreaterThan(0);
  expect(acct.getPaymentAccountPayload()!.getCryptoCurrencyAccountPayload()!.getAddress().length).toBeGreaterThan(0);
  expect(acct.getSelectedTradeCurrency()!.getCode().length).toBeGreaterThan(0);
  expect(acct.getTradeCurrenciesList().length).toEqual(1);
  const tradeCurrency = acct.getTradeCurrenciesList()[0];
  expect(tradeCurrency.getName().length).toBeGreaterThan(0);
  expect(tradeCurrency.getCode()).toEqual(acct.getSelectedTradeCurrency()!.getCode());
}

function testCryptoPaymentAccountsEqual(acct1: PaymentAccount, acct2: PaymentAccount) {
  expect(acct1.getId()).toEqual(acct2.getId());
  expect(acct1.getAccountName()).toEqual(acct2.getAccountName());
  expect(acct1.getSelectedTradeCurrency()!.getCode()).toEqual(acct2.getSelectedTradeCurrency()!.getCode());
  expect(acct1.getPaymentAccountPayload()!.getCryptoCurrencyAccountPayload()!.getAddress()).toEqual(acct2.getPaymentAccountPayload()!.getCryptoCurrencyAccountPayload()!.getAddress());
}

function testOffer(offer: OfferInfo, ctx?: Partial<TradeContext>) {
  expect(offer.getId().length).toBeGreaterThan(0);
  if (ctx) {
    expect(offer.getBuyerSecurityDepositPct()).toEqual(ctx?.securityDepositPct);
    expect(offer.getSellerSecurityDepositPct()).toEqual(ctx?.securityDepositPct);
    expect(offer.getUseMarketBasedPrice()).toEqual(!ctx?.price);
    expect(offer.getMarketPriceMarginPct()).toEqual(ctx?.priceMargin ? ctx?.priceMargin : 0);

    // TODO: test rest of offer
  }
}

function testMoneroNodeSettingsEqual(settingsBefore: XmrNodeSettings, settingsAfter: XmrNodeSettings) {
    expect(settingsAfter.getBlockchainPath()).toEqual(settingsBefore.getBlockchainPath());
    expect(settingsAfter.getBootstrapUrl()).toEqual(settingsBefore.getBootstrapUrl());
    expect(settingsAfter.getStartupFlagsList()).toEqual(settingsBefore.getStartupFlagsList());
}

function getFormField(form: PaymentAccountForm, fieldId: PaymentAccountFormField.FieldId): PaymentAccountFormField {
    for (const field of form.getFieldsList()) {
      if (field.getId() == fieldId) return field;
    }
    throw new Error("Form field not found: " + fieldId);
}

function getValidFormInput(form: PaymentAccountForm, fieldId: PaymentAccountFormField.FieldId): string {
  const field = getFormField(form, fieldId);
  switch (fieldId) {
    case PaymentAccountFormField.FieldId.ACCEPTED_COUNTRY_CODES:
      if (form.getId() === PaymentAccountForm.FormId.SEPA || form.getId() === PaymentAccountForm.FormId.SEPA_INSTANT) return "BE," + field.getSupportedSepaEuroCountriesList().map(country => country.getCode()).join(',');
      return field.getSupportedCountriesList().map(country => country.getCode()).join(',');
    case PaymentAccountFormField.FieldId.ACCOUNT_ID:
      return "jdoe@no.com";
    case PaymentAccountFormField.FieldId.ACCOUNT_NAME:
      return "Form_" + form.getId() + " " + moneroTs.GenUtils.getUUID(); // TODO: rename to form.getPaymentMethodId()
    case PaymentAccountFormField.FieldId.ACCOUNT_NR:
      return "12345678";
    case PaymentAccountFormField.FieldId.ACCOUNT_OWNER:
      return "John Doe";
    case PaymentAccountFormField.FieldId.ACCOUNT_TYPE:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.ANSWER:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.BANK_ACCOUNT_NAME:
      return "John Doe";
    case PaymentAccountFormField.FieldId.BANK_ACCOUNT_NUMBER:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.BANK_ACCOUNT_TYPE:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.BANK_ADDRESS:
      return "456 example st";
    case PaymentAccountFormField.FieldId.BANK_BRANCH:
      return "Bank branch XYZ";
    case PaymentAccountFormField.FieldId.BANK_BRANCH_CODE:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.BANK_BRANCH_NAME:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.BANK_ID:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.BANK_NAME:
      return "Bank XYZ";
    case PaymentAccountFormField.FieldId.BANK_SWIFT_CODE:
      return "12345678901"; // TODO: use real swift code
    case PaymentAccountFormField.FieldId.BENEFICIARY_ACCOUNT_NR:
      return "1234567890";
    case PaymentAccountFormField.FieldId.BENEFICIARY_ADDRESS:
      return "123 example st";
    case PaymentAccountFormField.FieldId.BENEFICIARY_CITY:
      return "Acme";
    case PaymentAccountFormField.FieldId.BENEFICIARY_NAME:
      return "Jane Doe";
    case PaymentAccountFormField.FieldId.BENEFICIARY_PHONE:
      return "123-456-7890";
    case PaymentAccountFormField.FieldId.BIC:
      return "ATLNFRPP";
    case PaymentAccountFormField.FieldId.BRANCH_ID:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.CITY:
      return "Atlanta";
    case PaymentAccountFormField.FieldId.CONTACT:
      return "Email please";
    case PaymentAccountFormField.FieldId.COUNTRY:
    case PaymentAccountFormField.FieldId.BANK_COUNTRY_CODE:
    case PaymentAccountFormField.FieldId.INTERMEDIARY_COUNTRY_CODE:
      return field.getSupportedCountriesList().length ? field.getSupportedCountriesList()[0]!.getCode() : "FR";
    case PaymentAccountFormField.FieldId.EMAIL:
      return "jdoe@no.com";
    case PaymentAccountFormField.FieldId.EMAIL_OR_MOBILE_NR:
      return "876-512-7813";
    case PaymentAccountFormField.FieldId.EMAIL_OR_MOBILE_NR_OR_USERNAME:
      return "john.doe"
    case PaymentAccountFormField.FieldId.EMAIL_OR_MOBILE_NR_OR_CASHTAG:
      return "john.doe"
    case PaymentAccountFormField.FieldId.EXTRA_INFO:
      return "Please and thanks";
    case PaymentAccountFormField.FieldId.HOLDER_ADDRESS:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.HOLDER_EMAIL:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.HOLDER_NAME:
      return "user1 Doe";
    case PaymentAccountFormField.FieldId.HOLDER_TAX_ID:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.IBAN:
      return "FR1420041010050500013M02606";
    case PaymentAccountFormField.FieldId.IFSC:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.INTERMEDIARY_ADDRESS:
      return "123 intermediary example st";
    case PaymentAccountFormField.FieldId.INTERMEDIARY_BRANCH:
      return "Intermediary bank branch XYZ";
    case PaymentAccountFormField.FieldId.INTERMEDIARY_NAME:
      return "Intermediary bank XYZ";
    case PaymentAccountFormField.FieldId.INTERMEDIARY_SWIFT_CODE:
      return "10987654321"; // TODO: use real swift code
    case PaymentAccountFormField.FieldId.MOBILE_NR:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.NATIONAL_ACCOUNT_ID:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.PAYID:
      return "john.doe@example.com";
    case PaymentAccountFormField.FieldId.PIX_KEY:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.POSTAL_ADDRESS:
      return "123 street";
    case PaymentAccountFormField.FieldId.PROMPT_PAY_ID:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.QUESTION:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.REQUIREMENTS:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.SALT:
      return "";
    case PaymentAccountFormField.FieldId.SORT_CODE:
      return "123456";
    case PaymentAccountFormField.FieldId.SPECIAL_INSTRUCTIONS:
      return "asap plz";
    case PaymentAccountFormField.FieldId.STATE:
      const country = HavenoUtils.getFormValue(form, PaymentAccountFormField.FieldId.COUNTRY);
      return moneroTs.GenUtils.arrayContains(field.getRequiredForCountriesList(), country) ? "My state" : "";
    case PaymentAccountFormField.FieldId.TRADE_CURRENCIES:
      if (field.getComponent() === PaymentAccountFormField.Component.SELECT_ONE) {
        if (form.getId() === PaymentAccountForm.FormId.F2F) return "XAU";
        if (form.getId() === PaymentAccountForm.FormId.PAY_BY_MAIL) return "XGB";
        return field.getSupportedCurrenciesList()[0]!.getCode(); // TODO: randomly select?
      }
      else return field.getSupportedCurrenciesList().map(currency => currency.getCode()).join(',');
    case PaymentAccountFormField.FieldId.USERNAME:
      return "user123";
    case PaymentAccountFormField.FieldId.ADDRESS:
      const currencyCode = HavenoUtils.getFormValue(form, PaymentAccountFormField.FieldId.TRADE_CURRENCIES);
      for (let cryptoAddress of TestConfig.cryptoAddresses) {
        if (cryptoAddress.currencyCode.toLowerCase() === currencyCode.toLowerCase()) return cryptoAddress.address;
      }
      throw new Error("Unsupported blockchain currency code: " + currencyCode);
    default:
      throw new Error("Unhandled form field: " + fieldId);
  }
}

// TODO: improve invalid inputs
function getInvalidFormInput(form: PaymentAccountForm, fieldId: PaymentAccountFormField.FieldId): string {
  const field = getFormField(form, fieldId);
  switch (fieldId) {
    case PaymentAccountFormField.FieldId.ACCEPTED_COUNTRY_CODES:
      return "US,XX";
    case PaymentAccountFormField.FieldId.ACCOUNT_ID:
      return "";
    case PaymentAccountFormField.FieldId.ACCOUNT_NAME:
      return "";
    case PaymentAccountFormField.FieldId.ACCOUNT_NR:
      return "123457A";
    case PaymentAccountFormField.FieldId.ACCOUNT_OWNER:
      return "J";
    case PaymentAccountFormField.FieldId.ACCOUNT_TYPE:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.ANSWER:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.BANK_ACCOUNT_NAME:
      return "F";
    case PaymentAccountFormField.FieldId.BANK_ACCOUNT_NUMBER:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.BANK_ACCOUNT_TYPE:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.BANK_ADDRESS:
      return "";
    case PaymentAccountFormField.FieldId.BANK_BRANCH:
      return "A";
    case PaymentAccountFormField.FieldId.BANK_BRANCH_CODE:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.BANK_BRANCH_NAME:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.BANK_CODE:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.BANK_COUNTRY_CODE:
      return "A";
    case PaymentAccountFormField.FieldId.BANK_ID:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.BANK_NAME:
      return "A";
    case PaymentAccountFormField.FieldId.BANK_SWIFT_CODE:
      return "A";
    case PaymentAccountFormField.FieldId.BENEFICIARY_ACCOUNT_NR:
      return "1";
    case PaymentAccountFormField.FieldId.BENEFICIARY_ADDRESS:
      return "";
    case PaymentAccountFormField.FieldId.BENEFICIARY_CITY:
      return "A";
    case PaymentAccountFormField.FieldId.BENEFICIARY_NAME:
      return "A";
    case PaymentAccountFormField.FieldId.BENEFICIARY_PHONE:
      return "1";
    case PaymentAccountFormField.FieldId.BIC:
      return "123";
    case PaymentAccountFormField.FieldId.BRANCH_ID:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.CITY:
      return "A";
    case PaymentAccountFormField.FieldId.CONTACT:
      return "";
    case PaymentAccountFormField.FieldId.COUNTRY:
      return "abc"
    case PaymentAccountFormField.FieldId.EMAIL:
      return "@no.com";
    case PaymentAccountFormField.FieldId.EMAIL_OR_MOBILE_NR:
      return ""; // TODO: validate phone numbers, e.g. 876
    case PaymentAccountFormField.FieldId.EMAIL_OR_MOBILE_NR_OR_USERNAME:
      return "A"
    case PaymentAccountFormField.FieldId.EMAIL_OR_MOBILE_NR_OR_CASHTAG:
      return "A"
    case PaymentAccountFormField.FieldId.EXTRA_INFO:
      throw new Error("Extra info has no invalid input");
    case PaymentAccountFormField.FieldId.HOLDER_ADDRESS:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.HOLDER_EMAIL:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.HOLDER_NAME:
      return "A";
    case PaymentAccountFormField.FieldId.HOLDER_TAX_ID:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.IBAN:
      return "abc";
    case PaymentAccountFormField.FieldId.IFSC:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.INTERMEDIARY_ADDRESS:
      return "";
    case PaymentAccountFormField.FieldId.INTERMEDIARY_BRANCH:
      return "A";
    case PaymentAccountFormField.FieldId.INTERMEDIARY_COUNTRY_CODE:
      return "A";
    case PaymentAccountFormField.FieldId.INTERMEDIARY_NAME:
      return "A";
    case PaymentAccountFormField.FieldId.INTERMEDIARY_SWIFT_CODE:
      return "A";
    case PaymentAccountFormField.FieldId.MOBILE_NR:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.NATIONAL_ACCOUNT_ID:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.PAYID:
      return "A";
    case PaymentAccountFormField.FieldId.PIX_KEY:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.POSTAL_ADDRESS:
      return "";
    case PaymentAccountFormField.FieldId.PROMPT_PAY_ID:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.QUESTION:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.REQUIREMENTS:
      throw new Error("Not implemented");
    case PaymentAccountFormField.FieldId.SALT:
      return "abc";
    case PaymentAccountFormField.FieldId.SORT_CODE:
      return "12345A";
    case PaymentAccountFormField.FieldId.SPECIAL_INSTRUCTIONS:
      throw new Error("Special instructions have no invalid input");
    case PaymentAccountFormField.FieldId.STATE: {
      const country = HavenoUtils.getFormValue(form, PaymentAccountFormField.FieldId.COUNTRY);
      return moneroTs.GenUtils.arrayContains(field.getRequiredForCountriesList(), country) ? "" : "My state";
    }
    case PaymentAccountFormField.FieldId.TRADE_CURRENCIES:
      return "abc,def";
    case PaymentAccountFormField.FieldId.USERNAME:
      return "A";
    case PaymentAccountFormField.FieldId.ADDRESS:
      return "A123";
    default:
      throw new Error("Unhandled form field: " + fieldId);
  }
}

function testPaymentAccount(account: PaymentAccount, form: PaymentAccountForm) {
    if (account.getPaymentAccountPayload()?.getCryptoCurrencyAccountPayload()) testCryptoPaymentAccount(account); // TODO: test non-crypto
    expect(account.getAccountName()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.ACCOUNT_NAME).getValue()); // TODO: using number as payment method, account payload's account name = username
    const isCountryBased = account.getPaymentAccountPayload()!.getCountryBasedPaymentAccountPayload() !== undefined;
    if (isCountryBased) expect(account.getPaymentAccountPayload()!.getCountryBasedPaymentAccountPayload()!.getCountryCode()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.COUNTRY).getValue());
    switch (form.getId()) {
      case PaymentAccountForm.FormId.BLOCK_CHAINS:
        expect(account.getPaymentAccountPayload()!.getCryptoCurrencyAccountPayload()!.getAddress()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.ADDRESS).getValue());
        expect(account.getTradeCurrenciesList().map(currency => currency.getCode()).join(",")).toEqual(getFormField(form, PaymentAccountFormField.FieldId.TRADE_CURRENCIES).getValue());
        break;
      case PaymentAccountForm.FormId.REVOLUT:
        expect(account.getPaymentAccountPayload()!.getRevolutAccountPayload()!.getUsername()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.USERNAME).getValue());
        expect(account.getTradeCurrenciesList().map(currency => currency.getCode()).join(",")).toEqual(getFormField(form, PaymentAccountFormField.FieldId.TRADE_CURRENCIES).getValue());
        break;
      case PaymentAccountForm.FormId.SEPA:
        expect(account.getPaymentAccountPayload()!.getCountryBasedPaymentAccountPayload()!.getSepaAccountPayload()!.getHolderName()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.HOLDER_NAME).getValue());
        //expect(account.getPaymentAccountPayload()!.getCountryBasedPaymentAccountPayload()!.getSepaAccountPayload().getEmail()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.EMAIL).getValue()); // TODO: if this is deprecated, remove from sepa model
        expect(account.getPaymentAccountPayload()!.getCountryBasedPaymentAccountPayload()!.getSepaAccountPayload()!.getIban()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.IBAN).getValue());
        expect(account.getPaymentAccountPayload()!.getCountryBasedPaymentAccountPayload()!.getSepaAccountPayload()!.getBic()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.BIC).getValue());
        expect(account.getPaymentAccountPayload()!.getCountryBasedPaymentAccountPayload()!.getAcceptedCountryCodesList().join(",")).toEqual(getFormField(form, PaymentAccountFormField.FieldId.ACCEPTED_COUNTRY_CODES).getValue());
        break;
      case PaymentAccountForm.FormId.SEPA_INSTANT:
        expect(account.getPaymentAccountPayload()!.getCountryBasedPaymentAccountPayload()!.getSepaInstantAccountPayload()!.getHolderName()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.HOLDER_NAME).getValue());
        expect(account.getPaymentAccountPayload()!.getCountryBasedPaymentAccountPayload()!.getSepaInstantAccountPayload()!.getIban()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.IBAN).getValue());
        expect(account.getPaymentAccountPayload()!.getCountryBasedPaymentAccountPayload()!.getSepaInstantAccountPayload()!.getBic()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.BIC).getValue());
        expect(account.getPaymentAccountPayload()!.getCountryBasedPaymentAccountPayload()!.getAcceptedCountryCodesList().join(",")).toEqual(getFormField(form, PaymentAccountFormField.FieldId.ACCEPTED_COUNTRY_CODES).getValue());
        break;
      case PaymentAccountForm.FormId.TRANSFERWISE:
        expect(account.getPaymentAccountPayload()!.getTransferwiseAccountPayload()!.getEmail()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.EMAIL).getValue());
        break;
      case PaymentAccountForm.FormId.ZELLE:
        expect(account.getPaymentAccountPayload()!.getZelleAccountPayload()!.getHolderName()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.HOLDER_NAME).getValue());
        expect(account.getPaymentAccountPayload()!.getZelleAccountPayload()!.getEmailOrMobileNr()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.EMAIL_OR_MOBILE_NR).getValue());
        expect(account.getTradeCurrenciesList().length).toEqual(1);
        expect(account.getTradeCurrenciesList()[0].getCode()).toEqual("USD");
        break;
      case PaymentAccountForm.FormId.SWIFT:
        expect(account.getPaymentAccountPayload()!.getSwiftAccountPayload()!.getBankSwiftCode()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.BANK_SWIFT_CODE).getValue());
        expect(account.getPaymentAccountPayload()!.getSwiftAccountPayload()!.getBankCountryCode()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.BANK_COUNTRY_CODE).getValue());
        expect(account.getPaymentAccountPayload()!.getSwiftAccountPayload()!.getBankName()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.BANK_NAME).getValue());
        expect(account.getPaymentAccountPayload()!.getSwiftAccountPayload()!.getBankBranch()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.BANK_BRANCH).getValue());
        expect(account.getPaymentAccountPayload()!.getSwiftAccountPayload()!.getBankAddress()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.BANK_ADDRESS).getValue());
        expect(account.getPaymentAccountPayload()!.getSwiftAccountPayload()!.getIntermediarySwiftCode()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.INTERMEDIARY_SWIFT_CODE).getValue());
        expect(account.getPaymentAccountPayload()!.getSwiftAccountPayload()!.getIntermediaryCountryCode()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.INTERMEDIARY_COUNTRY_CODE).getValue());
        expect(account.getPaymentAccountPayload()!.getSwiftAccountPayload()!.getIntermediaryName()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.INTERMEDIARY_NAME).getValue());
        expect(account.getPaymentAccountPayload()!.getSwiftAccountPayload()!.getIntermediaryBranch()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.INTERMEDIARY_BRANCH).getValue());
        expect(account.getPaymentAccountPayload()!.getSwiftAccountPayload()!.getIntermediaryAddress()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.INTERMEDIARY_ADDRESS).getValue());
        expect(account.getPaymentAccountPayload()!.getSwiftAccountPayload()!.getBeneficiaryName()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.BENEFICIARY_NAME).getValue());
        expect(account.getPaymentAccountPayload()!.getSwiftAccountPayload()!.getBeneficiaryAccountNr()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.BENEFICIARY_ACCOUNT_NR).getValue());
        expect(account.getPaymentAccountPayload()!.getSwiftAccountPayload()!.getBeneficiaryAddress()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.BENEFICIARY_ADDRESS).getValue());
        expect(account.getPaymentAccountPayload()!.getSwiftAccountPayload()!.getBeneficiaryCity()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.BENEFICIARY_CITY).getValue());
        expect(account.getPaymentAccountPayload()!.getSwiftAccountPayload()!.getBeneficiaryPhone()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.BENEFICIARY_PHONE).getValue());
        expect(account.getPaymentAccountPayload()!.getSwiftAccountPayload()!.getSpecialInstructions()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.SPECIAL_INSTRUCTIONS).getValue());
        break;
      case PaymentAccountForm.FormId.F2F:
        expect(account.getPaymentAccountPayload()!.getCountryBasedPaymentAccountPayload()!.getF2fAccountPayload()!.getCity()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.CITY).getValue());
        expect(account.getPaymentAccountPayload()!.getCountryBasedPaymentAccountPayload()!.getF2fAccountPayload()!.getContact()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.CONTACT).getValue());
        expect(account.getPaymentAccountPayload()!.getCountryBasedPaymentAccountPayload()!.getF2fAccountPayload()!.getExtraInfo()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.EXTRA_INFO).getValue());
        break;
      case PaymentAccountForm.FormId.STRIKE:
        expect(account.getPaymentAccountPayload()!.getCountryBasedPaymentAccountPayload()!.getStrikeAccountPayload()!.getHolderName()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.HOLDER_NAME).getValue());
        break;
      case PaymentAccountForm.FormId.MONEY_GRAM:
        expect(account.getPaymentAccountPayload()!.getMoneyGramAccountPayload()!.getCountryCode()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.COUNTRY).getValue()); // TODO: ok to not be CountryBasedPaymentAccountPayload?
        expect(account.getPaymentAccountPayload()!.getMoneyGramAccountPayload()!.getState()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.STATE).getValue());
        expect(account.getPaymentAccountPayload()!.getMoneyGramAccountPayload()!.getHolderName()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.HOLDER_NAME).getValue());
        expect(account.getPaymentAccountPayload()!.getMoneyGramAccountPayload()!.getEmail()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.EMAIL).getValue());
        expect(account.getTradeCurrenciesList().map(currency => currency.getCode()).join(",")).toEqual(getFormField(form, PaymentAccountFormField.FieldId.TRADE_CURRENCIES).getValue());
        break;
      case PaymentAccountForm.FormId.FASTER_PAYMENTS:
        expect(account.getPaymentAccountPayload()!.getFasterPaymentsAccountPayload()!.getHolderName()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.HOLDER_NAME).getValue());
        expect(account.getPaymentAccountPayload()!.getFasterPaymentsAccountPayload()!.getSortCode()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.SORT_CODE).getValue());
        expect(account.getPaymentAccountPayload()!.getFasterPaymentsAccountPayload()!.getAccountNr()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.ACCOUNT_NR).getValue());
        break;
      case PaymentAccountForm.FormId.UPHOLD:
        expect(account.getPaymentAccountPayload()!.getUpholdAccountPayload()!.getAccountOwner()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.ACCOUNT_OWNER).getValue());
        expect(account.getPaymentAccountPayload()!.getUpholdAccountPayload()!.getAccountId()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.ACCOUNT_ID).getValue());
        break;
      case PaymentAccountForm.FormId.PAXUM:
        expect(account.getPaymentAccountPayload()!.getPaxumAccountPayload()!.getEmail()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.EMAIL).getValue());
        expect(account.getTradeCurrenciesList().map(currency => currency.getCode()).join(",")).toEqual(getFormField(form, PaymentAccountFormField.FieldId.TRADE_CURRENCIES).getValue());
        break;
      case PaymentAccountForm.FormId.PAY_BY_MAIL:
        expect(account.getPaymentAccountPayload()!.getPayByMailAccountPayload()!.getContact()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.CONTACT).getValue());
        expect(account.getPaymentAccountPayload()!.getPayByMailAccountPayload()!.getPostalAddress()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.POSTAL_ADDRESS).getValue());
        expect(account.getPaymentAccountPayload()!.getPayByMailAccountPayload()!.getExtraInfo()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.EXTRA_INFO).getValue());
        expect(account.getTradeCurrenciesList().length).toEqual(1);
        expect(account.getTradeCurrenciesList()[0].getCode()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.TRADE_CURRENCIES).getValue());
        break;
      case PaymentAccountForm.FormId.CASH_AT_ATM:
        expect(account.getPaymentAccountPayload()!.getCashAtAtmAccountPayload()!.getExtraInfo()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.EXTRA_INFO).getValue());
        expect(account.getTradeCurrenciesList().length).toEqual(1);
        expect(account.getTradeCurrenciesList()[0].getCode()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.TRADE_CURRENCIES).getValue());
        break;
      case PaymentAccountForm.FormId.AUSTRALIA_PAYID:
        expect(account.getPaymentAccountPayload()!.getAustraliaPayidPayload()!.getBankAccountName()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.BANK_ACCOUNT_NAME).getValue());
        expect(account.getPaymentAccountPayload()!.getAustraliaPayidPayload()!.getPayid()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.PAYID).getValue());
        expect(account.getPaymentAccountPayload()!.getAustraliaPayidPayload()!.getExtraInfo()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.EXTRA_INFO).getValue());
        break;
      case PaymentAccountForm.FormId.CASH_APP:
        expect(account.getPaymentAccountPayload()!.getCashAppAccountPayload()!.getEmailOrMobileNrOrCashtag()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.EMAIL_OR_MOBILE_NR_OR_CASHTAG).getValue());
        expect(account.getTradeCurrenciesList().length).toEqual(2);
        expect(account.getTradeCurrenciesList().map(currency => currency.getCode()).join(",")).toEqual(getFormField(form, PaymentAccountFormField.FieldId.TRADE_CURRENCIES).getValue());
        break;
      case PaymentAccountForm.FormId.PAYPAL:
        expect(account.getPaymentAccountPayload()!.getPaypalAccountPayload()!.getEmailOrMobileNrOrUsername()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.EMAIL_OR_MOBILE_NR_OR_USERNAME).getValue());
        expect(account.getTradeCurrenciesList().map(currency => currency.getCode()).join(",")).toEqual(getFormField(form, PaymentAccountFormField.FieldId.TRADE_CURRENCIES).getValue());
        break;
      case PaymentAccountForm.FormId.VENMO:
        expect(account.getPaymentAccountPayload()!.getVenmoAccountPayload()!.getEmailOrMobileNrOrUsername()).toEqual(getFormField(form, PaymentAccountFormField.FieldId.EMAIL_OR_MOBILE_NR_OR_USERNAME).getValue());
        expect(account.getTradeCurrenciesList().length).toEqual(1);
        expect(account.getTradeCurrenciesList()[0].getCode()).toEqual("USD");
        break;
      default:
        throw new Error("Unhandled payment method type: " + form.getId());
    }
}