Handling Swap Simulation For Estimating MinOut

{
  PriceMath,
} from "@metadaoproject/futarchy/v0.4";

const simlulation = PriceMath.simulateSwap(
  inputAmountBN,
  swapType,
  amm.baseAmount,
  amm.quoteAmount,
  new BN(slippageBps),
);

returns 
{
expectedOut,
newBaseReserves,
newQuoteReserves,
minExpectedOut,
}

Fetching AMM tokens via AMM

const ammClient = AmmClient.createClient({ provider });
const amm = await ammClient.getAmm(new PublicKey(ammAddr));
const baseMint = amm.baseMint;
const quoteMint = amm.quoteMint;

Fetching AMM tokens via Autocrat

const autocratClient = AutocratClient.createClient({
  provider,
});

const conditionalVaultClient = ConditionalVaultClient.createClient({
  provider,
});

const proposalKey = new PublicKey("")

const proposal = await autocratClient.fetchProposal(proposalKey)

const baseVault = await conditionalVaultClient.fetchVault(new PublicKey(proposal.baseVault))
const quoteVault = await conditionalVaultClient.fetchVault(new PublicKey(proposal.quoteVault))
const baseVaultMint = baseVault?.underlyingTokenMint
const quoteVaultMint = quoteVault?.underlyingTokenMint

const passBaseMint = baseVault?.conditionalTokenMints[0]
const failBaseMint = baseVault?.conditionalTokenMints[1]
const passQuoteMint = quoteVault?.conditionalTokenMints[0]
const failQuoteMint = quoteVault?.conditionalTokenMints[1]

Fetching AMM balances for swap and simulating swap

const amm = await ammClient.getAmm(new PublicKey(ammAddr));

const isBuySelected = true;
const inputAmountBN = 1_000_000; // $1 USDC
const slippageBps = 100; // 100 bps or 1%
const swapType: SwapType = isBuySelected ? { buy: {} } : { sell: {} };

const swapSimulationResult = PriceMath.simulateSwap(
  inputAmountBN,
  swapType,
  amm.baseAmount,
  amm.quoteAmount,
  new BN(slippageBps),
);

Combined Split + Swap Example

if (activeConditionalBalanceBN.lt(inputAmountBN)) {
  const mintAmount = inputAmountBN.sub(activeConditionalBalanceBN);

  const mintTxBuilder = await conditionalVaultClient
    .splitTokensIx(
      questionAddr,
      underlyingVaultAddr,
      underlyingTokenMintAddr,
      mintAmount,
      2,
      userPublicKey
    )
    .preInstructions([...associatedTokenAccountInstructions]);
}

const swapSimulationResult = await PriceMath.simulateSwap(
  inputAmountBN,
  swapType,
  amm.baseAmount,
  amm.quoteAmount,
  new BN(slippageBps)
);

const minExpectedOutBN = swapSimulationResult.minExpectedOut!;

const swapTxBuilder = await ammClient.swapIx(
  ammAddr,
  baseMintAddr,
  quoteMintAddr,
  swapType,
  inputAmountBN,
  minExpectedOutBN,
  userPublicKey
);

const instructions: TransactionInstruction[] = [
  ComputeBudgetProgram.setComputeUnitLimit({
    units: mintTxBuilder ? 200_000 : 150_000,
  }),
];

if (mintTxBuilder) {
  instructions.push(...(await InstructionUtils.getInstructions(mintTxBuilder)));
}

instructions.push(...(await InstructionUtils.getInstructions(swapTxBuilder)));

const tx = new Transaction().add(...instructions);

📚 Previously

API Reference

📚 Next Up

Troubleshooting