Sign SVM Transactions

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

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

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

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"]

import base58

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

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

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}")