Interacting with InitiaDEX

// NOTE: In this example, we use the same mnemonic for both user and validator.
//       The reason is that we want to simplify the example. 
//       This will make it easier to whitelist during the proposal.
//       It takes a bit of time to whitelist, so you can skip this step 3 and do it manually.

// Some possible errors:
// location=0000000000000000000000000000000000000000000000000000000000000001::object, code=524289 -> The object (pair) is already created, skip step 1
// location=0000000000000000000000000000000000000000000000000000000000000001::object, code=393218 -> The object (pair) is not created yet, retry step 1

import { AccAddress, bcs, RESTClient, MnemonicKey, MsgDelegate, MsgExecute, MsgSubmitProposal, MsgVote, MsgWhitelist, MsgWithdrawDelegatorReward, Wallet } from "@initia/initia.js"
import { ProposalStatus, VoteOption } from "@initia/initia.proto/cosmos/gov/v1/gov"
import { delay } from "bluebird"
import { sha3_256 } from "@noble/hashes/sha3";
import { concatBytes, toBytes } from "@noble/hashes/utils";
import { toHex } from "@cosmjs/encoding"
import { MsgUndelegate } from "vm/move/msgs/staking";

const user = new Wallet(
  new RESTClient('http://localhost:1317', {
    gasPrices: '0.015uinit',
    gasAdjustment: '1.75'
  }),
  new MnemonicKey({
    // TODO: put your mnemonic here
    mnemonic: 'mimic exist actress ...'
  })
)

const validator = new Wallet(
  new RESTClient('http://localhost:1317', {
    gasPrices: '0.015uinit',
    gasAdjustment: '1.75'
  }),
  new MnemonicKey({
    // TODO: put your mnemonic here
    mnemonic: 'mimic exist actress ...'
  })
)

function coinMetadata(creator: string, symbol: string) {
  const OBJECT_FROM_SEED_ADDRESS_SCHEME = 0xfe
  const addrBytes = bcs.address().serialize(creator).toBytes()
  const seed = toBytes(symbol)
  const bytes = new Uint8Array([...concatBytes(addrBytes, seed), OBJECT_FROM_SEED_ADDRESS_SCHEME])
  const sum = sha3_256.create().update(bytes).digest()
  return toHex(sum)
}

async function getLastProposalId(restClient: RESTClient): Promise<number> {
  const [proposals, pagination] = await restClient.gov.proposals()
  if (proposals.length === 0) return 0
  return proposals[proposals.length - 1].id
}

async function getProposalStatus(restClient: RESTClient, proposalId: number): Promise<ProposalStatus | null> {
  const proposal = await restClient.gov.proposal(proposalId)
  return proposal ? proposal.status : null
}

async function checkProposalPassed(restClient: RESTClient, proposalId: number): Promise<void> {
  for (;;) {
    console.log(`checking proposal ${proposalId} status... in ${restClient.URL}/cosmos/gov/v1/proposals/${proposalId}`)
    const status = await getProposalStatus(restClient, proposalId)
    
    if (status === ProposalStatus.PROPOSAL_STATUS_PASSED) return
    if (status === ProposalStatus.PROPOSAL_STATUS_REJECTED) throw new Error(`proposal ${proposalId} rejected`)
    if (status === ProposalStatus.PROPOSAL_STATUS_FAILED) throw new Error(`proposal ${proposalId} failed`)
    await delay(5_000)
  }
}

async function provideLiquidity(
  lp_metadata: string,
  coin_a_amount: number,
  coin_b_amount: number,
  min_liquidity: number | null
) {
  const msg = new MsgExecute(
    user.key.accAddress,
    '0x1',
    'dex',
    'provide_liquidity_script',
    [],
    [
      bcs.string().serialize(lp_metadata).toBase64(),
      bcs.u64().serialize(coin_a_amount).toBase64(),
      bcs.u64().serialize(coin_b_amount).toBase64(),
      bcs.option(bcs.u64()).serialize(min_liquidity).toBase64()
    ]
  )

  const signedTx = await user.createAndSignTx({ msgs: [msg] })
  await user.rest.tx.broadcast(signedTx).catch(console.log)
}

async function createPairScript(
  sender: Wallet,
  name: string,
  symbol: string,
  swap_fee_rate: number,
  coin_a_weight: number,
  coin_b_weight: number,
  coin_a_metadata: string,
  coin_b_metadata: string,
  coin_a_amount: number,
  coin_b_amount: number
) {
  const msg = new MsgExecute(
    sender.key.accAddress,
    '0x1',
    'dex',
    'create_pair_script',
    [],
    [
      bcs.string().serialize(name).toBase64(),
      bcs.string().serialize(symbol).toBase64(),
      bcs.bigdecimal().serialize(swap_fee_rate).toBase64(),
      bcs.bigdecimal().serialize(coin_a_weight).toBase64(),
      bcs.bigdecimal().serialize(coin_b_weight).toBase64(),
      bcs.object().serialize(coin_a_metadata).toBase64(),
      bcs.object().serialize(coin_b_metadata).toBase64(),
      bcs.u64().serialize(coin_a_amount).toBase64(),
      bcs.u64().serialize(coin_b_amount).toBase64()
    ]
  )

  const signedTx = await sender.createAndSignTx({ msgs: [msg] })
  await sender.rest.tx.broadcast(signedTx).catch(console.log)
}

async function whitelistLP(lpMetadata: string) {
  const msgWhiteList = new MsgWhitelist(
    'init10d07y265gmmuvt4z0w9aw880jnsr700j55nka3', // autority
    AccAddress.fromHex(lpMetadata),                // metadata
    '1000000000000000000'                          // weight for reward (10^18)
  )

  const proposal = new MsgSubmitProposal(
    [msgWhiteList],
    '100000000uinit',           // deposit
    user.key.accAddress,        // proposer
    'uinit',                    // metadata
    'awesome proposal',         // title
    'it is awesome',            // summary
    false                       // expedited
  )

  const proposalId = (await getLastProposalId(user.rest)) + 1
  
  // if there's only one validator, it will exceed the quorum (cause we set as user = validator)
  const vote = new MsgVote(proposalId, user.key.accAddress, VoteOption.VOTE_OPTION_YES, '') 
  const signedTx = await user.createAndSignTx({ msgs: [proposal, vote]})
  
  await user.rest.tx.broadcast(signedTx).catch(console.log)
  await checkProposalPassed(user.rest, proposalId)
}

async function delegateLP(
  lpMetadata: string,
  amount: number
) {
  // we can get lp denom from lp metadata by adding 'move/' prefix
  // if lp metadata is ff5c7412979...
  // then lp denom is move/ff5c7412979...
  const msg = new MsgDelegate(
    user.key.accAddress,                   // delegator
    validator.key.valAddress,              // validator
    `${amount}move/${lpMetadata}` // lp token
  )

  const signedTx = await user.createAndSignTx({ msgs: [msg] })
  await user.rest.tx.broadcast(signedTx).catch(console.log)
}

async function withdrawRewards() {
  const msg = new MsgWithdrawDelegatorReward(
    user.key.accAddress,
    validator.key.valAddress
  )

  const signedTx = await user.createAndSignTx({ msgs: [msg] })
  await user.rest.tx.broadcast(signedTx).catch(console.log
}

// NOTE: if you uncomment step 2, there will be an error
//       because it takes a bit of time to create a pair
async function main() {
  console.log('user:', user.key.accAddress)
  console.log('validator:', validator.key.valAddress)

  // step 1: create pair script
  await createPairScript(
    user,
    'init-usdc',
    'init-usdc',
    0.003,
    0.5,
    0.5,
    coinMetadata('0x1', 'uinit'),
    coinMetadata('0x1', 'uusdc'),
    100_000_000,
    100_000_000
  )

  const lpMetadata = coinMetadata(user.key.accAddress, 'init-usdc') // ff5c7412979176c5e7f084a6...
  console.log('step 1 done, lp metadata:', lpMetadata)

  // step 2 (optional): provide liquidity 
  // you will get LP tokens when you create a pair, so you can skip this step
  // await provideLiquidity(
  //   lpMetadata,
  //   100_000_000,
  //   100_000_000,
  //   100_000
  // )
  // console.log('step 2 provide liquidity done')

  // step 3: whitelist LP
  // this step could take a while (check your 'expedited_voting_period' time in genesis.json)
  await whitelistLP(lpMetadata)
  console.log('step 3 whitelist done')

  // step 4: delegate LP tokens to the validator
  await delegateLP(lpMetadata, 100_000)
  console.log('step 4 delegate done')

  // step 5: withdraw rewards
  // await withdrawRewards()
  // console.log('step 5 withdraw done')
}

if (require.main === module) {
  main()
}