Developers Documentation

curl -sL https://raw.githubusercontent.com/paxi-web3/paxi/main/scripts/cli_install.sh | bash

# Add a new key
paxid keys add your_key_name

# Import key from seed phrase
paxid keys add your_key_name --recover

paxid tx bank send your_key_name paxi1... 1000000upaxi \
--gas auto --fees 30000upaxi

paxid q bank balances paxi1...

paxid tx wasm store your_contract.wasm \
--from your_key_name --gas auto --fees 10000000upaxi

paxid tx wasm instantiate 1 '{
  "name": "TestToken",
  "symbol": "TST",
  "decimals": 6,
  "initial_balances": [
    {
      "address": "paxi1...",
      "amount": "1000000"
    }
  ],
  "mint": {
    "minter": "paxi1..."
  },
  "marketing": {
    "project": "TestToken Project",
    "description": "This is a test token",
    "marketing": "paxi1...",
    "logo": {
      "url": "ipfs://bafkreiaaaaabbbbccccddddeeeeffff11112222333344445555666677778888"
    }
  }
}' --from your_key_name --label "TestToken" --no-admin --gas auto --fees 6000000upaxi

# Wait for 5 seconds and run the command below to get the contract address
curl -s 'GET' 'http://127.0.0.1:1317/cosmos/tx/v1beta1/txs/44E8739BF4F7C7B3148CC9BF9E2F3961FAA06ADEEEFC7F421190746DA3DE8104' | jq -r '.tx_response.events[]
  | select(.type=="instantiate")
  | .attributes[]
  | select(.key=="_contract_address")
  | .value'

paxid tx wasm instantiate 2 \
    '{"name":"Test NFT","symbol":"TNFT","minter":"paxi1..."}' \
    --from your_key_name \
    --label "Test Collections" \
    --no-admin \
    --gas auto \
    --fees 6000000upaxi

# Wait for 5 seconds and run the command below to get the contract address
curl -s 'GET' 'http://127.0.0.1:1317/cosmos/tx/v1beta1/txs/44E8739BF4F7C7B3148CC9BF9E2F3961FAA06ADEEEFC7F421190746DA3DE8104' | jq -r '.tx_response.events[]
  | select(.type=="instantiate")
  | .attributes[]
  | select(.key=="_contract_address")
  | .value'

paxid tx wasm execute prc721_contract_addr \
  '{"mint": {"token_id": "test_001", "owner": "paxi1...", "token_uri": "https://example.com/test_meta.json"}}' \
  --from your_key_name \
  --gas auto \
  --fees 20000upaxi

paxid tx wasm execute prc20_contract_addr '{"transfer":{"recipient":"paxi1...","amount":"1000"}}' \
--from your_key_name --gas auto --fees 30000upaxi

paxid tx wasm execute prc721_contract_addr '{"transfer_nft":{"recipient":"paxi1...","token_id":"1","minter":"paxi1..."}}' \
--from your_key_name --gas auto --fees 30000upaxi

paxid query wasm contract-state smart prc20_contract_addr '{"balance":{"address":"paxi1..."}}'

paxid query wasm contract-state smart prc721_contract_addr '{"nft_info":{"token_id":"1"}}'

paxid --help
paxid tx --help
paxid query wasm --help

./paxid tx wasm execute your_contract_address \
    '{"increase_allowance": {
    "spender": "paxi1mfru9azs5nua2wxcd4sq64g5nt7nn4n80r745t", # This is the swap module's address
    "amount": "10000000000000"
    }}' \
    --from your_key_name \
    --gas auto \
    --fees 21000upaxi

# Remember to increase allowance to the swap module before executing this command
./paxid tx swap provide-liquidity \
    --prc20 "your_contract_address" \
    --paxi-amount "1000000upaxi" \
    --prc20-amount "10000000" \
    --from your_key_name \
    --gas auto  \
    --fees 21000upaxi

./paxid tx swap withdraw-liquidity \
    --prc20 "your_contract_address" \
    --lp-amount "1000000" \
    --from your_key_name \
    --gas auto  \
    --fees 21000upaxi

# Remember to increase allowance to the swap module before executing this command
./paxid tx swap swap \
    --prc20 "your_contract_address" \
    --offer-denom upaxi \
    --offer-amount 10000 \
    --min-receive 10 \
    --from your_key_name \
    --gas auto  \
    --fees 21000upaxi

GET https://mainnet-lcd.paxinet.io/cosmos/tx/v1beta1/txs/{hash}

GET https://mainnet-lcd.paxinet.io/cosmos/tx/v1beta1/txs/block/{block_height}

GET https://mainnet-lcd.paxinet.io/cosmos/base/node/v1beta1/status

GET https://mainnet-lcd.paxinet.io/cosmos/base/tendermint/v1beta1/blocks/latest

GET https://mainnet-lcd.paxinet.io/cosmos/staking/v1beta1/validators

GET https://mainnet-lcd.paxinet.io/cosmos/bank/v1beta1/balances/{address}

GET https://mainnet-lcd.paxinet.io/cosmos/auth/v1beta1/accounts/{address}

GET https://mainnet-lcd.paxinet.io/paxi/paxi/circulating_supply

GET https://mainnet-lcd.paxinet.io/paxi/paxi/locked_vesting

GET https://mainnet-lcd.paxinet.io/paxi/paxi/total_supply

GET https://mainnet-lcd.paxinet.io/paxi/paxi/unlock_schedules

GET https://mainnet-lcd.paxinet.io/paxi/swap/all_pools

GET https://mainnet-lcd.paxinet.io/paxi/swap/pool/{prc20_address}

// Proto source code for TypeScript: https://github.com/paxi-web3/paxi/tree/main/ts_proto

import { DirectSecp256k1HdWallet } from "@cosmjs/proto-signing";
import { SigningStargateClient, coins, calculateFee, GasPrice } from "@cosmjs/stargate";

// endpoints & config
const rpcEndpoint = "https://mainnet-rpc.paxinet.io";
const lcdEndpoint = "https://mainnet-lcd.paxinet.io";
const prefix      = "paxi";
const denom       = "upaxi";

async function initWallet(mnemonic) {
  // create wallet from mnemonic
  const wallet = await DirectSecp256k1HdWallet.fromMnemonic(mnemonic, { prefix });
  const [firstAccount] = await wallet.getAccounts();
  return { wallet, address: firstAccount.address };
}

// Usage:
// const mnemonic = "your twelve word mnemonic here";
// const { wallet, address } = await initWallet(mnemonic);

async function fetchChainId() {
  const client = await SigningStargateClient.connect(rpcEndpoint);
  const chainId = await client.getChainId();
  return chainId;
}

// Usage:
// const chainId = await fetchChainId();

async function fetchAccountInfo(address) {
  const client = await SigningStargateClient.connect(rpcEndpoint);
  const account = await client.getAccount(address);
  return {
    accountNumber: account.accountNumber,
    sequence:      account.sequence
  };
}

// Usage:
// const info = await fetchAccountInfo("paxi1...");

async function sendTokens(mnemonic, toAddress, amount, memo = "") {
  const { wallet, address } = await initWallet(mnemonic);
  const client = await SigningStargateClient.connectWithSigner(rpcEndpoint, wallet);
  const fee    = calculateFee(200_000, GasPrice.fromString('0.0upaxi')); // gas & fee

  const result = await client.sendTokens(
      address,
      toAddress,
      coins(amount, denom),
      fee,
      memo,
  );
  return result.transactionHash;
}

// Usage:
// const txHash = await sendTokens("your mnemonic", "paxi1dest...", "1000000", "Test transfer");

# cosmpy==0.11.1
# mospy-wallet==0.6.0

from mospy import Account, Transaction
import requests
import json
from datetime import datetime, timedelta
from cosmpy.crypto.address import Address

paxi_lcd = 'https://mainnet-lcd.paxinet.io'
paxi_rpc = 'https://mainnet-rpc.paxinet.io'

def fetch_chain_id(lcd_url: str) -> str:
    resp = requests.get(f"{lcd_url}/cosmos/base/tendermint/v1beta1/node_info")
    resp.raise_for_status()
    return resp.json()["default_node_info"]["network"]

# Usage
chain_id = fetch_chain_id(paxi_lcd)

def fetch_account_info(lcd_url: str, address: str) -> tuple[int, int]:
    url = f"{lcd_url}/cosmos/auth/v1beta1/accounts/{address}"
    r = requests.get(url)
    data = r.json()
    base_account = data.get("account", {})
    return int(base_account.get("account_number", 0)), int(base_account.get("sequence", 0))

# Usage
acct_num, seq = fetch_account_info(paxi_lcd, "paxi1...")

def send_tx(account: Account, to_address: str, amount: float,
            fee: float, chain_id: str, lcd_url: str, memo: str = "") -> str | None:
    tx = Transaction(
        account=account,
        gas=int(fee * 10**6 / 0.05),
        chain_id=chain_id,
        memo=memo
    )
    tx.set_fee(amount=int(fee * 10**6), denom=denom)
    tx.add_msg(
        tx_type="transfer",
        sender=account,
        recipient=to_address,
        amount=int(amount * 10**6),
        denom=denom
    )
    payload = {
      "tx_bytes": tx.get_tx_bytes_as_string(),
      "mode": "BROADCAST_MODE_ASYNC"
    }
    resp = requests.post(f"{lcd_url}/cosmos/tx/v1beta1/txs", json=payload)
    resp.raise_for_status()
    return resp.json().get("tx_response", {}).get("txhash")

def fetch_tx_status(lcd_url: str, tx_hash: str) -> dict:
    url = f"{lcd_url}/cosmos/tx/v1beta1/txs/{tx_hash}"
    resp = requests.get(url)
    if resp.status_code != 200:
        return {"status": "pending", "detail": "Node unreachable"}
    data = resp.json().get("tx_response", {})
    code = data.get("code", 0)
    if code == 0:
        return {"status": "success", "height": data.get("height")}
    return {"status": "failed", "code": code, "raw_log": data.get("raw_log")}

# Usage
status = fetch_tx_status(paxi_lcd, "HASH123...")

def is_valid_bech32_address(addr: str, hrp: str = "paxi") -> bool:
    try:
        assert addr.startswith(hrp)
        Address(addr)  # raises if invalid
        return True
    except Exception:
        return False

# Usage
valid = is_valid_bech32_address("paxi1...")  # True or False

# 1. Import account from mnemonic
mnemonic = "canal lazy unveil sort dwarf bacon measure spawn increase neutral winter lucky"
account = Account(seed_phrase=mnemonic, hrp='paxi')
account_number, sequence = fetch_account_info(paxi_lcd, account.address)
account.account_number = account_number
account.next_sequence = sequence

# Alternative: import account from hex-encoded private key
# priv_key_hex = "abcdef1234567890..."
# account = Account(private_key=priv_key_hex, hrp='paxi')

# 2. Define transaction parameters
to_address = "paxi1..."
amount = 1.5  # amount in PAXI
fee = 0.04  # fee in PAXI
chain_id = fetch_chain_id(paxi_lcd)
memo = "Test transfer via Python SDK"

# 3. Send transaction and retrieve transaction hash
tx_hash = send_tx(account, to_address, amount, fee, chain_id, paxi_lcd, memo)
print(f"Transaction hash: {tx_hash}")