MST Blockchain SDK (Python)

A modular and lightweight blockchain development kit for interacting with any MST-compatible network. This is a Python port of the MST Blockchain SDK (JS), built on web3.py and eth-account, providing the same easy-to-use abstractions for providers, signers, and contract interactions.

Table of Contents

• Features
• Installation
• Quick Start
  • 1. Initialize the Client
  • 2. Generate a Random Wallet
  • 3. Check Account Balance (via Provider)
  • 4. Estimate Gas & Send Transactions
  • 5. Deploy Contract & Get Address
• Networks
• Core Modules
  • 1. Client
  • 2. Provider
  • 3. Signer
  • 4. Errors
• Testing
• License

Features

• Client Orchestration: Universal entry point for all SDK features.
• Provider Management: Simple JSON-RPC provider (via web3.py) for fetching block data and account state.
• Secure Signing: Integrated Signer using eth-account for secure transaction signing and address management.
• Balances: Built-in utilities for checking native token balances.
• Network Selection: Pick "mainnet" or "testnet" and the SDK resolves the correct RPC endpoint for you — no config files or env vars needed.

Installation

pip install -r requirements.txt

For local development (so the blockchain_sdk package resolves from src/), install it in editable mode:

pip install -e .

(Recommended: do this inside a virtual environment — python -m venv .venv then activate it — before installing.)

There is no .env file or environment configuration to set up. The network is selected by name at runtime, and the private key is passed directly wherever you construct a Client — both are plain user input, not config.

Quick Start

1. Initialize the Client

from blockchain_sdk import Client

private_key = "0x..."

client = Client("testnet", private_key)   # or "mainnet"

2. Generate a Random Wallet

# Creates a new client with a fresh random private key
client = Client.create_random("testnet")
print(f"Generated Address: {client.signer.address}")
print(f"Private Key: {client.signer.get_private_key()}")

3. Check Account Balance (via Provider)

address = "0x..."
# Access balance through the provider
balance = client.provider.get_balance(address)
print(f"Address Balance: {balance} wei")

4. Estimate Gas & Send Transactions

to_address = "0x..."
amount = "1000000000000000000"  # 1 TOKEN

# 1. Estimate gas first
gas_limit = client.signer.estimate_gas("sendNative", [to_address, amount])
print(f"Estimated Gas: {gas_limit}")

# 2. Send the transaction
tx_hash = client.signer.send_native(to_address, amount)
print(f"Transaction Hash: {tx_hash}")

5. Deploy Contract & Get Address

abi = [...]
bytecode = "0x..."
args = ["InitialValue"]

# 1. Start deployment
tx_hash = client.signer.deploy(abi, bytecode, args)
print(f"Deployment Hash: {tx_hash}")

# 2. Wait for it to be mined
receipt = client.provider.wait_for_transaction(tx_hash)

# 3. Get the new contract address
print(f"Contract Deployed at: {receipt.contractAddress}")

Networks

Client resolves its RPC endpoint from a network name (defined in blockchain_sdk.utils.constants.NETWORKS):

from blockchain_sdk import Client

testnet_client = Client("testnet", private_key)
mainnet_client = Client("mainnet", private_key)

Passing an unrecognized network name raises a ValueError.

Core Modules

1. Client

The root container and main entry point.

• Client(network="testnet", private_key=None): Resolves the RPC URL for network and constructs the Provider/Signer.
• Client.create_random(network="testnet"): Returns a new Client instance with a random signer.
• provider: Instance of Provider.
• signer: Instance of Signer (if private_key provided).

2. Provider (Read-only)

Accessed via client.provider.

• get_block_number(): Returns the latest block.
• get_balance(address): Fetches raw balance.
• get_transaction_receipt(tx_hash): Fetches the receipt of a mined txn.
• wait_for_transaction(tx_hash): Waits for a txn to be mined.
• estimate_gas(transaction): Estimates gas for a raw transaction object.

3. Signer (Identity & Writing)

Accessed via client.signer.

• Signer.create_random(provider): Generates a new random Signer attached to a provider.
• get_private_key(): Returns the private key of the current wallet.
• estimate_gas(method, args): Estimates gas for Signer methods (sendNative, sendToken, deploy).
• send_transaction(tx): Signs and broadcasts any transaction.
• send_native(to, amount): Shortcut for sending native tokens.
• send_token(token_address, to, amount): Sends ERC20 tokens.
• deploy(abi, bytecode, args=None): Deploys smart contracts.
• get_address(): Returns the signer's public address.

4. Errors

Custom error classes for better debugging (blockchain_sdk.Errors).

• ProviderError: Network or RPC issues.
• TransactionError: Validation or on-chain submission failures.
• WalletError: Private key or signer initialization issues.

Testing

Run the test suite to ensure everything is configured correctly:

pytest

License

MIT