Sign SVM Transactions

Overview

Dynamic’s Python SDK exposes two transaction methods on DynamicSvmWalletClient:

send_transaction — signs a serialized message and broadcasts it via JSON-RPC. Returns the base58-encoded transaction signature. This is the path most apps want.
sign_transaction — signs only. Returns a hex-encoded Ed25519 signature you assemble into a transaction yourself. Note that this is asymmetric with sign_message, which returns a base58 signature — the SDK uses different encodings on purpose.

Both methods sign the transaction message (not the full transaction). Pass bytes(tx.message) or tx.serialize_message().

Prerequisites

Created a Solana wallet
solders and httpx installed for transaction construction and broadcasting

Quick Start: Send a Transaction

send_transaction builds the wire transaction, signs the message, and broadcasts it for you:

import asyncio
import os
from solders.pubkey import Pubkey
from solders.system_program import transfer, TransferParams
from solders.message import Message
from solders.hash import Hash
import httpx

from dynamic_wallet_sdk import DynamicSvmWalletClient


async def get_recent_blockhash(rpc_url: str) -> str:
    async with httpx.AsyncClient() as http:
        resp = await http.post(rpc_url, json={
            "jsonrpc": "2.0",
            "id": 1,
            "method": "getLatestBlockhash",
            "params": [{"commitment": "finalized"}],
        })
        return resp.json()["result"]["value"]["blockhash"]


async def main():
    rpc_url = "https://api.mainnet-beta.solana.com"
    from_address = "YourBase58WalletAddress"
    to_address = "RecipientBase58Address"

    from_pubkey = Pubkey.from_string(from_address)
    to_pubkey = Pubkey.from_string(to_address)

    blockhash = await get_recent_blockhash(rpc_url)
    instruction = transfer(TransferParams(
        from_pubkey=from_pubkey,
        to_pubkey=to_pubkey,
        lamports=1_000_000,
    ))
    message = Message.new_with_blockhash(
        [instruction],
        from_pubkey,
        Hash.from_string(blockhash),
    )

    async with DynamicSvmWalletClient(os.environ["DYNAMIC_ENV_ID"]) as client:
        await client.authenticate_api_token(os.environ["DYNAMIC_API_TOKEN"])

        tx_signature = await client.send_transaction(
            address=from_address,
            message_bytes=bytes(message),
            rpc_url=rpc_url,
        )
        print(f"Transaction: {tx_signature}")  # base58 tx signature

asyncio.run(main())

rpc_url resolution: explicit argument → DynamicSvmWalletClient(default_rpc_url=...) → falls back to https://api.devnet.solana.com.

Signing with a Password-Protected Wallet

tx_signature = await client.send_transaction(
    address=from_address,
    message_bytes=bytes(message),
    rpc_url=rpc_url,
    password="your-wallet-password",
)

Gas Sponsorship

Pass sponsor=True to have Dynamic pay network fees for the transaction:

tx_signature = await client.send_transaction(
    address=from_address,
    message_bytes=bytes(message),
    rpc_url=rpc_url,
    sponsor=True,
)

Gas sponsorship requires the feature to be enabled for your environment in the Dynamic developer console.

Manual Signing and Broadcasting

When you need to inspect, log, or relay the signed transaction yourself, use sign_transaction to get the raw signature and assemble the wire transaction by hand.

import asyncio
import os
from solders.pubkey import Pubkey
from solders.transaction import Transaction
from solders.system_program import transfer, TransferParams
from solders.message import Message
from solders.hash import Hash
import httpx

from dynamic_wallet_sdk import DynamicSvmWalletClient


async def send_sol(
    from_address: str,
    to_address: str,
    lamports: int,
    rpc_url: str,
    password: str | None = None,
):
    from_pubkey = Pubkey.from_string(from_address)
    to_pubkey = Pubkey.from_string(to_address)

    async with httpx.AsyncClient() as http:
        resp = await http.post(rpc_url, json={
            "jsonrpc": "2.0",
            "id": 1,
            "method": "getLatestBlockhash",
            "params": [{"commitment": "finalized"}],
        })
        blockhash = resp.json()["result"]["value"]["blockhash"]

    instruction = transfer(TransferParams(
        from_pubkey=from_pubkey,
        to_pubkey=to_pubkey,
        lamports=lamports,
    ))
    message = Message.new_with_blockhash(
        [instruction],
        from_pubkey,
        Hash.from_string(blockhash),
    )

    async with DynamicSvmWalletClient(os.environ["DYNAMIC_ENV_ID"]) as client:
        await client.authenticate_api_token(os.environ["DYNAMIC_API_TOKEN"])

        sig_hex = await client.sign_transaction(
            address=from_address,
            message_bytes=bytes(message),
            password=password,
        )

    sig_bytes = bytes.fromhex(sig_hex)
    tx = Transaction.populate(message, [sig_bytes])

    async with httpx.AsyncClient() as http:
        resp = await http.post(rpc_url, json={
            "jsonrpc": "2.0",
            "id": 1,
            "method": "sendTransaction",
            "params": [
                bytes(tx).hex(),
                {"encoding": "base64", "skipPreflight": False},
            ],
        })
        return resp.json()["result"]

sign_transaction returns the signature as hex (64 bytes / 128 hex chars). Convert to bytes with bytes.fromhex(sig_hex) before inserting into the transaction. If a downstream consumer expects base58:

import base58

sig_b58 = base58.b58encode(bytes.fromhex(sig_hex)).decode()

Verifying a Signature

import nacl.signing
import base58

sig_bytes = bytes.fromhex(signature_hex)
pubkey_bytes = base58.b58decode(address)

verify_key = nacl.signing.VerifyKey(pubkey_bytes)
verify_key.verify(message_bytes, sig_bytes)
print("Signature verified")

Error Handling

from dynamic_wallet_sdk import DynamicSDKError

try:
    sig_hex = await client.sign_transaction(
        address=address,
        message_bytes=bytes(message),
    )
except DynamicSDKError as e:
    print(f"Signing failed: {e}")

Learn

Build on the client

Build on the server

Configure

Sign SVM Transactions

Overview

Prerequisites

Quick Start: Send a Transaction

Signing with a Password-Protected Wallet

Gas Sponsorship

Manual Signing and Broadcasting

Verifying a Signature

Error Handling

Next Steps

​Overview

​Prerequisites

​Quick Start: Send a Transaction

​Signing with a Password-Protected Wallet

​Gas Sponsorship

​Manual Signing and Broadcasting

​Verifying a Signature

​Error Handling

​Next Steps

Overview

Prerequisites

Quick Start: Send a Transaction

Signing with a Password-Protected Wallet

Gas Sponsorship

Manual Signing and Broadcasting

Verifying a Signature

Error Handling

Next Steps