Creating an AMM Pool

Now we will create an AMM Pool to provide some liquidity for our new token.

Create an AMM Pool

Now that the receiver has tokens, we can use the receiver's account to create an AMM. Note that this is the usual architecture where the issuer account solely issues the token, and other proprietary accounts hold the token and can create liquidity.

For this example, we will use pools that have XRP as one side.

Here is the createAMM.ts file:

createAMM.ts

import { AMMCreate } from "xrpl";

export const createAMM = async ({
  issuer,
  receiver,
  client,
  tokenCode,
}: any) => {
  console.log("create AMM", { issuer, receiver, tokenCode });
  let createAmm: AMMCreate = {
    TransactionType: "AMMCreate",
    Account: receiver.address,
    TradingFee: 600,
    Amount: {
      currency: tokenCode,
      issuer: issuer.classicAddress,
      value: "2000000", // 2M tokens
    },
    Amount2: "50000000", // 50 XRP in drops
  };
  console.log(createAmm);

  const prepared = await client.autofill(createAmm);
  const signed = receiver.sign(prepared);
  const result = await client.submitAndWait(signed.tx_blob);

  console.log(result);
  console.log("Create amm tx: ", result.result.hash);

  return;
};

Putting it all together, the final main function and index.ts should now look like this:

index.ts

import {  Client,  Wallet }  from "xrpl" 
import { createToken } from "./createToken"
import { createAMM } from "./createAMM"
import { convertStringToHexPadded, enableRippling } from "./utils"

const client = new Client("wss://s.altnet.rippletest.net:51233")

// get these from https://xrpl.org/resources/dev-tools/xrp-faucets
const issuerSeed = "s...";
const receiverSeed = "s...;

const issuer = Wallet.fromSeed(issuerSeed);
const receiver = Wallet.fromSeed(receiverSeed);

// edit this to match your vibe
const token = "COOL"

const main = async () => {
  console.log("lets get started...");
  await client.connect();

  // enable ripling
  await enableRippling({ wallet: issuer, client });

  // create Token
  await createToken({
    issuer,
    receiver,
    client,
    tokenCode: convertStringToHexPadded(token),
  });

  // create AMM
  await createAMM({
    issuer,
    receiver,
    client,
    tokenCode: convertStringToHexPadded(token),
  });

  await client.disconnect();

  console.log("all done!");
};

main();

Don't forget to import enableRippling, createToken, createAMM and convertStringToHexPadded if needed.

You can now go to the training website at https://amm.xrpl.at/ and interact with other pools.

You will need to set up Xaman with the receiver account you created above. You can use the family seed import route. If you are new to Xaman don't forget to enable developer mode in the advanced settings and then switch to testnet from the home page of the Xaman app.

Interact with your pool (swap)

Using the training app, connect and add your public address to the list. When you click a user in the list you can see that account's token holdings.

You can create Trustlines for tokens you have not interacted with yet. You can swap XRP for other tokens where you have trustlines using the pool view's swap feature.

You may need to mint more XRP for your receiver account. That's where the print money function might come in handy.

Extra credits

Become a liquidity provider for other pools

You can become a Liquidity Provider for other pools by using the AMMDeposit function: (https://xrpl.org/docs/references/protocol/transactions/types/ammdeposit/)

Withdraw from pools

You can also withdraw from pools using your LP tokens by utilizing the AMMWithdraw transaction. (https://xrpl.org/docs/references/protocol/transactions/types/ammwithdraw/)