alcmy 0.1.2

Unofficial Rust client for the Alchemy API
Documentation

Features

  • NFT API - Ownership, metadata, sales, spam detection
  • Prices API - Token prices by symbol/address, historical data
  • Portfolio API - Multi-chain token balances and NFT holdings
  • Token API - ERC-20 balances, metadata, allowances
  • Transfers API - Historical transaction data
  • Debug API - Transaction and block tracing
  • Trace API - Parity-style tracing
  • Simulation API - Simulate transactions and asset changes
  • Bundler API - ERC-4337 Account Abstraction
  • Gas Manager API - Gas sponsorship and policy management
  • Wallet API - Smart wallet operations
  • Accounts API - Authentication (email, passkey, JWT)
  • Notify API - Webhook management
  • Beacon API - Ethereum consensus layer
  • Solana DAS API - Digital Asset Standard queries

Installation

[dependencies]
alcmy = "0.1"
tokio = { version = "1", features = ["full"] }

Quick Start

use alcmy::{Client, Network};

#[tokio::main]
async fn main() -> Result<(), alcmy::Error> {
    let client = Client::new("your-api-key", Network::EthMainnet)?;

    // Get NFTs for an address
    let nfts = client.nft().get_nfts_for_owner("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045").await?;
    println!("Found {} NFTs", nfts.total_count);

    // Get token balances
    let balances = client.token().get_token_balances("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045").await?;
    println!("Found {} tokens", balances.token_balances.len());

    Ok(())
}

Supported Networks

Ethereum, Polygon, Arbitrum, Optimism, Base, zkSync, Solana, and 20+ more networks.

use alcmy::Network;

let client = Client::new("api-key", Network::EthMainnet)?;
let client = Client::new("api-key", Network::Polygon)?;
let client = Client::new("api-key", Network::Arbitrum)?;
let client = Client::new("api-key", Network::Base)?;
let client = Client::new("api-key", Network::SolanaMainnet)?;

API Examples

NFT API

// Get NFTs for owner
let nfts = client.nft().get_nfts_for_owner("0x...").await?;

// Get NFT metadata
let nft = client.nft().get_nft_metadata("0xcontract", "1").await?;

// Check if address owns NFT from collection
let is_holder = client.nft().is_holder_of_contract("0xwallet", "0xcontract").await?;

// Get floor price
let floor = client.nft().get_floor_price("0xcontract").await?;

Token API

// Get ERC-20 balances
let balances = client.token().get_token_balances("0x...").await?;

// Get token metadata
let metadata = client.token().get_token_metadata("0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48").await?;
println!("{} ({})", metadata.name.unwrap(), metadata.symbol.unwrap());

// Get allowance
let allowance = client.token().get_token_allowance("0xtoken", "0xowner", "0xspender").await?;

Transfers API

use alcmy::transfers::AssetTransfersOptions;

// Get transfers from an address
let transfers = client.transfers().get_transfers_from("0x...").await?;

// Get transfers with options
let options = AssetTransfersOptions::from_address("0x...")
    .category(vec!["erc20", "erc721"])
    .with_metadata()
    .exclude_zero_value();
let transfers = client.transfers().get_asset_transfers(&options).await?;

Debug API

// Trace a transaction
let trace = client.debug().trace_transaction("0xtxhash").await?;

// Trace a call
let call = TraceCallObject::new("0xfrom", "0xto").data("0xcalldata");
let trace = client.debug().trace_call(&call, "latest").await?;

Simulation API

use alcmy::simulation::SimulationTransaction;

// Simulate asset changes
let tx = SimulationTransaction::new("0xfrom", "0xto")
    .data("0xcalldata")
    .value("1000000000000000000");
let result = client.simulation().simulate_asset_changes(&tx).await?;

for change in result.changes {
    println!("{}: {} {}", change.asset_type, change.amount, change.symbol.unwrap_or_default());
}

Bundler API (ERC-4337)

// Get supported entry points
let entry_points = client.bundler().supported_entry_points().await?;

// Estimate gas for UserOperation
let gas = client.bundler().estimate_user_operation_gas(&user_op, "0xEntryPoint").await?;

// Send UserOperation
let hash = client.bundler().send_user_operation(&user_op, "0xEntryPoint").await?;

// Get UserOperation receipt
let receipt = client.bundler().get_user_operation_receipt(&hash).await?;

Beacon API

// Get genesis info
let genesis = client.beacon().get_genesis().await?;

// Get validators
let validators = client.beacon().get_validators("head").await?;

// Get block
let block = client.beacon().get_block("head").await?;

Solana DAS API

// Get asset by ID
let asset = client.solana().get_asset("AssetId123...").await?;

// Get assets by owner
let assets = client.solana().get_assets_by_owner("WalletAddress...").await?;

// Search assets
let request = SearchAssetsRequest::new().owner("...").collection("...");
let results = client.solana().search_assets(&request).await?;

License

MIT