#![allow(
clippy::print_stdout,
clippy::print_stderr,
clippy::expect_used,
clippy::unwrap_used
)]
use std::sync::Arc;
use std::time::Duration;
use pyde_rust_sdk::constants::{GAS_DEPLOY, GAS_TRANSFER};
use pyde_rust_sdk::contract::{Contract, Value};
use pyde_rust_sdk::provider::{HttpTransport, RootProvider};
use pyde_rust_sdk::util::{format_quanta, parse_quanta};
use pyde_rust_sdk::{abi, Address, PendingTx, Provider, Signer, TxBuilder, Wallet};
#[path = "shared/common.rs"]
mod common;
#[tokio::main]
async fn main() -> anyhow::Result<()> {
let rpc_url = common::rpc_url();
let transport = HttpTransport::new(rpc_url.clone())?;
let provider = Arc::new(RootProvider::new(transport));
let dyn_provider: Arc<dyn Provider> = provider.clone();
println!("== connected: {rpc_url}\n");
let chain_id = provider.chain_id().await?;
let wave_id = provider.wave_id().await?;
println!("chain_id = {chain_id} (0x{chain_id:x})");
println!("wave_id = {wave_id}");
anyhow::ensure!(chain_id == 31337, "expected devnet chain_id 31337");
let seed_0 = common::devnet_secret(0);
let seed_1 = common::devnet_secret(1);
let sender = Wallet::from_seed(&seed_0)?;
let recipient_existing = Wallet::from_seed(&seed_1)?;
println!("\n== devnet-0 reproduced ==");
println!("address: {}", sender.address());
println!("pubkey: 0x{}…", &sender.pubkey().to_hex()[2..18]);
let bal_sender = provider.get_balance(&sender.address()).await?;
let bal_recipient = provider.get_balance(&recipient_existing.address()).await?;
let bal_sender_pyde = format_quanta(bal_sender);
let bal_recipient_pyde = format_quanta(bal_recipient);
println!("balance: {bal_sender_pyde} PYDE ({bal_sender} quanta)");
anyhow::ensure!(
bal_sender >= 1_000_000_000,
"sender balance below 1 PYDE floor; got {bal_sender_pyde}"
);
println!("devnet-1 balance: {bal_recipient_pyde} PYDE");
let account = provider.get_account(&sender.address()).await?;
println!(
"\n== account record ==\n type: {}\n nonce: {}\n code_hash: {}",
account.account_type, account.nonce, account.code_hash
);
let fresh_recipient = Wallet::generate()?;
let amount = parse_quanta("1.234").map_err(|e| anyhow::anyhow!(e))?;
let bal_before = provider.get_balance(&fresh_recipient.address()).await?;
println!(
"\n== transferring {} PYDE from devnet-0 → {} ==",
format_quanta(amount),
fresh_recipient.address()
);
let nonce = provider.get_nonce(&sender.address()).await?;
let mut tx = TxBuilder::new()
.from(sender.address())
.chain_id(chain_id)
.nonce(nonce)
.transfer(fresh_recipient.address(), amount)
.gas_limit(GAS_TRANSFER)
.build()?;
sender.sign_tx(&mut tx).await?;
println!("signed tx: {} sig bytes", tx.signature.as_bytes().len());
let hash = provider.send_raw_transaction(&tx).await?;
println!("submitted: 0x{}", hex::encode(hash.as_bytes()));
let pending = PendingTx::new(hash, dyn_provider.clone());
let receipt = pending
.with_poll_interval(Duration::from_millis(100))
.with_timeout(Duration::from_secs(15))
.wait_for_receipt()
.await?;
println!(
"committed: wave {} / tx_index {} / status {:?} / gas {}",
receipt.wave_id_u64(),
receipt.tx_index_u32(),
receipt.status,
receipt.gas()
);
anyhow::ensure!(receipt.is_success(), "transfer reverted");
let bal_recipient_after = provider.get_balance(&fresh_recipient.address()).await?;
println!(
"recipient balance: {} → {} ({}+{})",
bal_before,
bal_recipient_after,
bal_before,
bal_recipient_after - bal_before
);
anyhow::ensure!(
bal_recipient_after == bal_before + amount,
"recipient balance delta mismatch"
);
let bal_sender_after = provider.get_balance(&sender.address()).await?;
let spent = bal_sender - bal_sender_after;
println!(
"sender balance: {} → {} (spent {} quanta = {} gas + value)",
bal_sender,
bal_sender_after,
spent,
receipt.gas()
);
anyhow::ensure!(
spent >= amount,
"sender should have spent at least the transferred amount"
);
println!("\n== error-envelope test ==");
let req = pyde_rust_sdk::CallRequest {
to: sender.address().to_hex(),
data: "0x00".into(),
from: None,
value: None,
gas: None,
};
match provider.call(&req).await {
Ok(out) => println!("(unexpectedly ok) returned {} bytes", out.len()),
Err(e) => println!("(expected error) {e}"),
}
if let Ok(wasm_path) = std::env::var("PYDE_CONTRACT_WASM") {
println!("\n== contract deploy + call ({wasm_path}) ==");
let wasm = std::fs::read(&wasm_path)?;
let parsed_abi = abi::extract_abi(&wasm)?;
println!(
"ABI: {} v{} ({} functions, {} events)",
parsed_abi.name,
parsed_abi.version,
parsed_abi.functions.len(),
parsed_abi.events.len()
);
let contract_name = format!(
"counter-{}",
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0)
);
println!("deploying as: {contract_name}");
let deploy_nonce = provider.get_nonce(&sender.address()).await?;
let mut deploy_tx = TxBuilder::new()
.from(sender.address())
.chain_id(chain_id)
.nonce(deploy_nonce)
.deploy(
contract_name.clone(),
wasm,
pyde_rust_sdk::types::ContractType::Contract,
Vec::new(),
)
.map_err(|e| anyhow::anyhow!(e))?
.gas_limit(GAS_DEPLOY)
.build()?;
sender.sign_tx(&mut deploy_tx).await?;
let deploy_hash = provider.send_raw_transaction(&deploy_tx).await?;
println!("deploy tx: 0x{}", hex::encode(deploy_hash.as_bytes()));
let deploy_pending = PendingTx::new(deploy_hash, dyn_provider.clone())
.with_poll_interval(Duration::from_millis(100))
.with_timeout(Duration::from_secs(15));
let deploy_receipt = deploy_pending.wait_for_receipt().await?;
anyhow::ensure!(
deploy_receipt.is_success(),
"deploy reverted: {:?}",
String::from_utf8_lossy(&deploy_receipt.return_bytes())
);
let contract_addr = Address::from_contract_name(&contract_name);
println!(
"deployed: {} (wave {}, gas {})",
contract_addr,
deploy_receipt.wave_id_u64(),
deploy_receipt.gas()
);
let contract = Contract::new(contract_addr, parsed_abi, dyn_provider.clone());
if contract.abi().function_by_name("get").is_some() {
let result = contract.call("get", vec![]).await?;
println!("view get() => {result:?}");
}
if contract.abi().function_by_name("increment").is_some() {
let pending = contract
.send(&sender, "increment", vec![], 500_000, 0)
.await?;
let inc_receipt = pending
.with_poll_interval(Duration::from_millis(100))
.with_timeout(Duration::from_secs(15))
.wait_for_receipt()
.await?;
anyhow::ensure!(inc_receipt.is_success(), "increment reverted");
println!(
"increment() committed in wave {} (gas {})",
inc_receipt.wave_id_u64(),
inc_receipt.gas()
);
let return_bytes = inc_receipt.return_bytes();
if return_bytes.len() == 8 {
let mut arr = [0u8; 8];
arr.copy_from_slice(&return_bytes);
println!(" return: {}", u64::from_le_bytes(arr));
}
}
if contract.abi().function_by_name("get").is_some() {
let result = contract.call("get", vec![]).await?;
match result {
Some(Value::U64(v)) => println!("view get() => {v}"),
other => println!("view get() => {other:?}"),
}
}
} else {
println!("\n(set PYDE_CONTRACT_WASM=<path-to-counter.wasm> to exercise deploy/call)");
}
println!("\n✔ devnet E2E smoke test passed");
Ok(())
}