// 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', // authority
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()
}
