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())

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())

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())

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)

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