py-near 1.2.21

Async client for NEAR Blockchain with native HOT Protocol & NEAR Intents support

py-near

py-near is a Async client for NEAR Blockchain with native HOT Protocol & NEAR Intents support

Examples

📚 Click to see some basic examples

Few steps before getting started...

• Install the latest stable version of py-near, simply running pip install py-near
• Create NEAR account and get your private key wallet

Simple money transfer

from py_near.account import Account
import asyncio
from py_near.dapps.core import NEAR

ACCOUNT_ID = "bob.near"
PRIVATE_KEY = "ed25519:..."


async def main():
   acc = Account(ACCOUNT_ID, PRIVATE_KEY)

   await acc.startup()
   print(await acc.get_balance() / NEAR)
   print(await acc.get_balance("bob.near") / NEAR)

   tr = await acc.send_money("bob.near", NEAR * 2)
   print(tr.transaction.hash)
   print(tr.logs)


asyncio.run(main())

Working with NEAR Intents (OmniBalance)

from py_near.omni_balance import OmniBalance
import asyncio

ACCOUNT_ID = "bob.near"
PRIVATE_KEY = "ed25519:..."


async def main():
   omni = OmniBalance(ACCOUNT_ID, PRIVATE_KEY)
   await omni.startup()

   # Create intent with multiple actions: transfer, token swap, and auth call
   commitment = omni.transfer(
      tokens={"nep141:wrap.near": "5"},
      receiver_id="alice.near",
      memo="Test transfer",
   )._token_diff({
      "nep141:wrap.near": "-5",
   }).auth_call("contract.near", msg="test").sign()

   # Simulate intent before submitting
   sim = await omni.simulate_intent(commitment)
   print(sim.logged_intents)

   # Submit intent to solver network
   intent_hash = await omni.publish_intents(commitment)
   print(f"Intent hash: {intent_hash}")

   # Wait for transaction hash
   tr_hash = await omni.get_tr_hash_from_intent(intent_hash)
   print(f"Transaction hash: {tr_hash}")

   await omni.shutdown()


asyncio.run(main())

Working with HeX Orderbook

HeX is a decentralized orderbook for trading tokens on NEAR. It supports limit orders, market orders, and order management.

from py_near.omni_balance import OmniBalance
from py_near.dapps.hex import OrderbookClient
import asyncio

ACCOUNT_ID = "bob.near"
PRIVATE_KEY = "ed25519:..."

async def main():
    async with OmniBalance(ACCOUNT_ID, PRIVATE_KEY) as omni:
        # Initialize orderbook for HOT/USDT pair
        ob = OrderbookClient(
            omni,
            base="nep245:v2_1.omni.hot.tg:4444119_wyixUKCL",
            decimal_base=9,
        )
        
        # Get and print orderbook
        orderbook = await ob.get_orderbook()
        orderbook.print()
        
        # Simulate market order to get quote
        amount_in = int(0.1 * 10**9)  # 0.1 HOT
        result = await ob.simulate_market_order(
            str(amount_in),
            token_in="nep245:v2_1.omni.hot.tg:4444119_wyixUKCL",
            min_amount_out="0",
        )
        print(f"Expected output: {result.book_fill_result.taker_receive_total}")
        
        # Place limit order
        tx = await ob.place_limit_order(
            price=ob.get_price(1.50),  # $1.50 per HOT
            amount=str(int(0.35 * 10**6)),
            token_in="nep141:usdt.tether-token.near",
        )
        print(f"Limit order: {tx}")
        
        # Place market order
        tx = await ob.place_market_order(
            amount=str(int(0.1 * 10**9)),
            token_in="nep245:v2_1.omni.hot.tg:4444119_wyixUKCL",
        )
        print(f"Market order: {tx}")
        
        # Cancel orders
        orders = await ob.get_orders()
        for order in orders:
            if order.order.maker == omni.account_id:
                await ob.cancel_order(order.hash)

asyncio.run(main())

Parallel requests

Only one parallel request can be made from one private key. All transaction calls execute sequentially. To make several parallel calls you need to use several private keys

acc = Account("bob.near", private_key1)

for i in range(2):
  signer = InMemorySigner.from_random(AccountId("bob.near"), KeyType.ED25519)
  await acc.add_full_access_public_key(str(signer.public_key))
  print(signer.secret_key)

Now we can call transactions in parallel

acc = Account("bob.near", [private_key1, private_key2, private_key3])
# request time = count transactions / count public keys
tasks = [
  asyncio.create_task(acc.send_money("alisa.near", 1)),
  asyncio.create_task(acc.send_money("alisa.near", 1)),
  asyncio.create_task(acc.send_money("alisa.near", 1)),
]
for t in tasks:
  await t

Official py-near resources:

• News: @herewallet
• Social media:
  • 🇺🇸 Telegram
  • 🇺🇸 Twitter
• PyPI: py-near
• Documentation: py-near.readthedocs.io
• Source: Github repo
• Issues/Bug tracker: Github issues tracker

Contributors

Code Contributors

This project exists thanks to all the people who contribute. [Code of conduct].