mudbase 1.0.0

data/docs/WalletApi.md

@@ -0,0 +1,1232 @@
+# Mudbase::WalletApi
+
+All URIs are relative to *https://cloud.mudbase.dev*
+
+| Method | HTTP request | Description |
+| ------ | ------------ | ----------- |
+| [**wallet_broadcast_transaction**](WalletApi.md#wallet_broadcast_transaction) | **POST** /api/wallet/non-custodial/broadcast | Broadcast a client-signed transaction |
+| [**wallet_create_webhook**](WalletApi.md#wallet_create_webhook) | **POST** /api/wallet/non-custodial/webhooks | Create a wallet webhook |
+| [**wallet_delete_address**](WalletApi.md#wallet_delete_address) | **DELETE** /api/wallet/non-custodial/addresses/{addressId} | Delete (soft-delete) a non-custodial address |
+| [**wallet_delete_webhook**](WalletApi.md#wallet_delete_webhook) | **DELETE** /api/wallet/non-custodial/webhooks/{webhookId} | Delete a wallet webhook |
+| [**wallet_estimate_gas**](WalletApi.md#wallet_estimate_gas) | **POST** /api/wallet/non-custodial/estimate-gas | Estimate network fee from blockchain (all supported chains; not controlled by Mudbase) |
+| [**wallet_get_address**](WalletApi.md#wallet_get_address) | **GET** /api/wallet/non-custodial/addresses/{addressId} | Get non-custodial address by ID |
+| [**wallet_get_balance**](WalletApi.md#wallet_get_balance) | **GET** /api/wallet/non-custodial/addresses/{addressId}/balance | Get balance for a non-custodial address |
+| [**wallet_get_cancel_params**](WalletApi.md#wallet_get_cancel_params) | **POST** /api/wallet/non-custodial/cancel | Get replacement tx params for cancel (stuck EVM tx) |
+| [**wallet_get_speed_up_params**](WalletApi.md#wallet_get_speed_up_params) | **POST** /api/wallet/non-custodial/speed-up | Get replacement tx params for speed-up (stuck EVM tx) |
+| [**wallet_get_transaction_by_hash**](WalletApi.md#wallet_get_transaction_by_hash) | **GET** /api/wallet/non-custodial/transactions/{txHash} | Get transaction by hash |
+| [**wallet_get_transactions**](WalletApi.md#wallet_get_transactions) | **GET** /api/wallet/non-custodial/addresses/{addressId}/transactions | Get transaction history for a non-custodial address |
+| [**wallet_get_webhook_logs**](WalletApi.md#wallet_get_webhook_logs) | **GET** /api/wallet/non-custodial/webhooks/{webhookId}/logs | Get webhook delivery logs |
+| [**wallet_list_addresses**](WalletApi.md#wallet_list_addresses) | **GET** /api/wallet/non-custodial/addresses | List registered non-custodial addresses |
+| [**wallet_list_webhooks**](WalletApi.md#wallet_list_webhooks) | **GET** /api/wallet/non-custodial/webhooks | List wallet webhooks |
+| [**wallet_register_address**](WalletApi.md#wallet_register_address) | **POST** /api/wallet/non-custodial/register-address | Register a non-custodial wallet address |
+| [**wallet_test_webhook**](WalletApi.md#wallet_test_webhook) | **POST** /api/wallet/non-custodial/webhooks/test | Test a webhook delivery (sends a single test payload) |
+| [**wallet_update_webhook**](WalletApi.md#wallet_update_webhook) | **PUT** /api/wallet/non-custodial/webhooks/{webhookId} | Update a wallet webhook |
+
+
+## wallet_broadcast_transaction
+
+> <WalletBroadcastTransaction200Response> wallet_broadcast_transaction(wallet_broadcast_transaction_request)
+
+Broadcast a client-signed transaction
+
+Broadcast a transaction that has been signed client-side. The transaction must be fully signed before sending. The fromAddress must be registered and belong to your organization (POST /api/wallet/non-custodial/register-address). **Supported chains:** EVM (ethereum, polygon, arbitrum, optimism, base, bsc, binance, avalanche, celo), UTXO (bitcoin, litecoin, dogecoin), and chain-specific (tron, solana, ton, cardano). Use `binance` or `bsc` for BNB Smart Chain. **Testing with custodial:** You can create a wallet via POST /api/wallet/create, get its private key via GET /api/wallet/{walletId}/private-key, register that address with POST /api/wallet/non-custodial/register-address, then build a signed tx (using POST /api/wallet/estimate-network-fee or estimate-gas for fees) and broadcast it here to test the non-custodial flow end-to-end. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+wallet_broadcast_transaction_request = Mudbase::WalletBroadcastTransactionRequest.new({chain: 'ethereum', signed_tx: '0x02f8...', from_address: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb'}) # WalletBroadcastTransactionRequest | Chain, signed transaction (hex), and fromAddress (must be registered).
+
+begin
+  # Broadcast a client-signed transaction
+  result = api_instance.wallet_broadcast_transaction(wallet_broadcast_transaction_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_broadcast_transaction: #{e}"
+end
+```
+
+#### Using the wallet_broadcast_transaction_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<WalletBroadcastTransaction200Response>, Integer, Hash)> wallet_broadcast_transaction_with_http_info(wallet_broadcast_transaction_request)
+
+```ruby
+begin
+  # Broadcast a client-signed transaction
+  data, status_code, headers = api_instance.wallet_broadcast_transaction_with_http_info(wallet_broadcast_transaction_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <WalletBroadcastTransaction200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_broadcast_transaction_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **wallet_broadcast_transaction_request** | [**WalletBroadcastTransactionRequest**](WalletBroadcastTransactionRequest.md) | Chain, signed transaction (hex), and fromAddress (must be registered). |  |
+
+### Return type
+
+[**WalletBroadcastTransaction200Response**](WalletBroadcastTransaction200Response.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## wallet_create_webhook
+
+> <WalletCreateWebhook201Response> wallet_create_webhook(wallet_create_webhook_request)
+
+Create a wallet webhook
+
+Register a webhook URL to receive wallet events (balance updates, transaction confirmed/failed/detected/broadcast, token balance, address created/deactivated). Optional filters by addresses and chains. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+wallet_create_webhook_request = Mudbase::WalletCreateWebhookRequest.new({url: 'https://your-app.com/webhooks/wallet', events: ["wallet.balance.updated", "wallet.transaction.confirmed"]}) # WalletCreateWebhookRequest | Webhook URL, events array, optional secret and filters (addresses, chains, projectId).
+
+begin
+  # Create a wallet webhook
+  result = api_instance.wallet_create_webhook(wallet_create_webhook_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_create_webhook: #{e}"
+end
+```
+
+#### Using the wallet_create_webhook_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<WalletCreateWebhook201Response>, Integer, Hash)> wallet_create_webhook_with_http_info(wallet_create_webhook_request)
+
+```ruby
+begin
+  # Create a wallet webhook
+  data, status_code, headers = api_instance.wallet_create_webhook_with_http_info(wallet_create_webhook_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <WalletCreateWebhook201Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_create_webhook_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **wallet_create_webhook_request** | [**WalletCreateWebhookRequest**](WalletCreateWebhookRequest.md) | Webhook URL, events array, optional secret and filters (addresses, chains, projectId). |  |
+
+### Return type
+
+[**WalletCreateWebhook201Response**](WalletCreateWebhook201Response.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## wallet_delete_address
+
+> <FunctionsDelete200Response> wallet_delete_address(address_id)
+
+Delete (soft-delete) a non-custodial address
+
+Soft-deletes a registered non-custodial address. The address is marked inactive and no longer used for broadcasts or balance/transaction queries. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+address_id = 'address_id_example' # String | Registered address ID to delete.
+
+begin
+  # Delete (soft-delete) a non-custodial address
+  result = api_instance.wallet_delete_address(address_id)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_delete_address: #{e}"
+end
+```
+
+#### Using the wallet_delete_address_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<FunctionsDelete200Response>, Integer, Hash)> wallet_delete_address_with_http_info(address_id)
+
+```ruby
+begin
+  # Delete (soft-delete) a non-custodial address
+  data, status_code, headers = api_instance.wallet_delete_address_with_http_info(address_id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <FunctionsDelete200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_delete_address_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **address_id** | **String** | Registered address ID to delete. |  |
+
+### Return type
+
+[**FunctionsDelete200Response**](FunctionsDelete200Response.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## wallet_delete_webhook
+
+> <FunctionsDelete200Response> wallet_delete_webhook(webhook_id)
+
+Delete a wallet webhook
+
+Permanently delete a wallet webhook. Delivery will stop immediately.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+webhook_id = 'webhook_id_example' # String | Webhook ID (MongoDB ObjectId) to delete.
+
+begin
+  # Delete a wallet webhook
+  result = api_instance.wallet_delete_webhook(webhook_id)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_delete_webhook: #{e}"
+end
+```
+
+#### Using the wallet_delete_webhook_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<FunctionsDelete200Response>, Integer, Hash)> wallet_delete_webhook_with_http_info(webhook_id)
+
+```ruby
+begin
+  # Delete a wallet webhook
+  data, status_code, headers = api_instance.wallet_delete_webhook_with_http_info(webhook_id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <FunctionsDelete200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_delete_webhook_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **webhook_id** | **String** | Webhook ID (MongoDB ObjectId) to delete. |  |
+
+### Return type
+
+[**FunctionsDelete200Response**](FunctionsDelete200Response.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## wallet_estimate_gas
+
+> <WalletEstimateGas200Response> wallet_estimate_gas(wallet_estimate_gas_request)
+
+Estimate network fee from blockchain (all supported chains; not controlled by Mudbase)
+
+**Network fee (from blockchain only).** Returns network fee **estimated directly from the blockchain** via RPC or fee APIs. **Not controlled by Mudbase.** Both POST /api/wallet/estimate-network-fee (or calculate-fee) and this endpoint return network fee only; use either for gas/fee display. This endpoint is chain-oriented and supports full transaction shape for EVM. **EVM chains:** ethereum, polygon, arbitrum, optimism, base, bsc, binance, avalanche, celo — require `transaction` (from, and to/value or tokenAddress/amount). Response includes gasLimit, gasPrice, networkFee, estimatedTime, currency. **Non-EVM chains:** bitcoin, litecoin, dogecoin, solana, tron, ton, cardano — only `chain` is required; `transaction` is optional/ignored. Returns networkFee, estimatedTime, currency (and e.g. satPerVb for UTXO). See docs/FEE_ARCHITECTURE.md. Results cached 15s. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+wallet_estimate_gas_request = Mudbase::WalletEstimateGasRequest.new({chain: 'ethereum'}) # WalletEstimateGasRequest | Chain and optional transaction shape (required for EVM). Returns network fee from blockchain.
+
+begin
+  # Estimate network fee from blockchain (all supported chains; not controlled by Mudbase)
+  result = api_instance.wallet_estimate_gas(wallet_estimate_gas_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_estimate_gas: #{e}"
+end
+```
+
+#### Using the wallet_estimate_gas_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<WalletEstimateGas200Response>, Integer, Hash)> wallet_estimate_gas_with_http_info(wallet_estimate_gas_request)
+
+```ruby
+begin
+  # Estimate network fee from blockchain (all supported chains; not controlled by Mudbase)
+  data, status_code, headers = api_instance.wallet_estimate_gas_with_http_info(wallet_estimate_gas_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <WalletEstimateGas200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_estimate_gas_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **wallet_estimate_gas_request** | [**WalletEstimateGasRequest**](WalletEstimateGasRequest.md) | Chain and optional transaction shape (required for EVM). Returns network fee from blockchain. |  |
+
+### Return type
+
+[**WalletEstimateGas200Response**](WalletEstimateGas200Response.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## wallet_get_address
+
+> <NonCustodialAddressResponse> wallet_get_address(address_id)
+
+Get non-custodial address by ID
+
+Returns metadata and status for a single registered non-custodial address (ID, address, chain, label, org, project, derivationPath, isActive, timestamps). 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+address_id = 'address_id_example' # String | Registered address ID (MongoDB ObjectId).
+
+begin
+  # Get non-custodial address by ID
+  result = api_instance.wallet_get_address(address_id)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_get_address: #{e}"
+end
+```
+
+#### Using the wallet_get_address_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<NonCustodialAddressResponse>, Integer, Hash)> wallet_get_address_with_http_info(address_id)
+
+```ruby
+begin
+  # Get non-custodial address by ID
+  data, status_code, headers = api_instance.wallet_get_address_with_http_info(address_id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <NonCustodialAddressResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_get_address_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **address_id** | **String** | Registered address ID (MongoDB ObjectId). |  |
+
+### Return type
+
+[**NonCustodialAddressResponse**](NonCustodialAddressResponse.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## wallet_get_balance
+
+> <WalletGetBalance200Response> wallet_get_balance(address_id)
+
+Get balance for a non-custodial address
+
+Returns native token balance (confirmed, unconfirmed, total, currency) for a registered non-custodial address. Updated periodically from the chain. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+address_id = 'address_id_example' # String | Registered address ID.
+
+begin
+  # Get balance for a non-custodial address
+  result = api_instance.wallet_get_balance(address_id)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_get_balance: #{e}"
+end
+```
+
+#### Using the wallet_get_balance_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<WalletGetBalance200Response>, Integer, Hash)> wallet_get_balance_with_http_info(address_id)
+
+```ruby
+begin
+  # Get balance for a non-custodial address
+  data, status_code, headers = api_instance.wallet_get_balance_with_http_info(address_id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <WalletGetBalance200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_get_balance_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **address_id** | **String** | Registered address ID. |  |
+
+### Return type
+
+[**WalletGetBalance200Response**](WalletGetBalance200Response.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## wallet_get_cancel_params
+
+> <WalletGetCancelParams200Response> wallet_get_cancel_params(wallet_get_cancel_params_request)
+
+Get replacement tx params for cancel (stuck EVM tx)
+
+Returns **replacement transaction params** to cancel a stuck EVM transaction (same nonce, to=self, value=0, data=0x, higher gas). Client signs and broadcasts via POST /api/wallet/non-custodial/broadcast. Address must be registered for your organization. EVM chains only. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+wallet_get_cancel_params_request = Mudbase::WalletGetCancelParamsRequest.new({chain: 'ethereum'}) # WalletGetCancelParamsRequest | Stuck transaction identifier (txId or txHash) and EVM chain for cancel.
+
+begin
+  # Get replacement tx params for cancel (stuck EVM tx)
+  result = api_instance.wallet_get_cancel_params(wallet_get_cancel_params_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_get_cancel_params: #{e}"
+end
+```
+
+#### Using the wallet_get_cancel_params_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<WalletGetCancelParams200Response>, Integer, Hash)> wallet_get_cancel_params_with_http_info(wallet_get_cancel_params_request)
+
+```ruby
+begin
+  # Get replacement tx params for cancel (stuck EVM tx)
+  data, status_code, headers = api_instance.wallet_get_cancel_params_with_http_info(wallet_get_cancel_params_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <WalletGetCancelParams200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_get_cancel_params_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **wallet_get_cancel_params_request** | [**WalletGetCancelParamsRequest**](WalletGetCancelParamsRequest.md) | Stuck transaction identifier (txId or txHash) and EVM chain for cancel. |  |
+
+### Return type
+
+[**WalletGetCancelParams200Response**](WalletGetCancelParams200Response.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## wallet_get_speed_up_params
+
+> <WalletGetSpeedUpParams200Response> wallet_get_speed_up_params(wallet_get_speed_up_params_request)
+
+Get replacement tx params for speed-up (stuck EVM tx)
+
+Returns **replacement transaction params** for a stuck EVM transaction (same nonce, same to/value/data, higher gas). Client signs the replacement and broadcasts via POST /api/wallet/non-custodial/broadcast. Address must be registered for your organization. Use when a tx has been pending >5 min (stuck). EVM chains only. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+wallet_get_speed_up_params_request = Mudbase::WalletGetSpeedUpParamsRequest.new({chain: 'ethereum'}) # WalletGetSpeedUpParamsRequest | Stuck transaction identifier (txId or txHash) and EVM chain.
+
+begin
+  # Get replacement tx params for speed-up (stuck EVM tx)
+  result = api_instance.wallet_get_speed_up_params(wallet_get_speed_up_params_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_get_speed_up_params: #{e}"
+end
+```
+
+#### Using the wallet_get_speed_up_params_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<WalletGetSpeedUpParams200Response>, Integer, Hash)> wallet_get_speed_up_params_with_http_info(wallet_get_speed_up_params_request)
+
+```ruby
+begin
+  # Get replacement tx params for speed-up (stuck EVM tx)
+  data, status_code, headers = api_instance.wallet_get_speed_up_params_with_http_info(wallet_get_speed_up_params_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <WalletGetSpeedUpParams200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_get_speed_up_params_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **wallet_get_speed_up_params_request** | [**WalletGetSpeedUpParamsRequest**](WalletGetSpeedUpParamsRequest.md) | Stuck transaction identifier (txId or txHash) and EVM chain. |  |
+
+### Return type
+
+[**WalletGetSpeedUpParams200Response**](WalletGetSpeedUpParams200Response.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## wallet_get_transaction_by_hash
+
+> <WalletGetTransactionByHash200Response> wallet_get_transaction_by_hash(tx_hash, chain)
+
+Get transaction by hash
+
+Returns a transaction by its hash. The **chain** query parameter is required because the same hash format can exist on different chains (e.g. 0x-style on EVM chains). 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+tx_hash = 'tx_hash_example' # String | Transaction hash (e.g. 0x... for EVM, or block explorer format for UTXO)
+chain = 'ethereum' # String | Chain the transaction belongs to (required for lookup)
+
+begin
+  # Get transaction by hash
+  result = api_instance.wallet_get_transaction_by_hash(tx_hash, chain)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_get_transaction_by_hash: #{e}"
+end
+```
+
+#### Using the wallet_get_transaction_by_hash_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<WalletGetTransactionByHash200Response>, Integer, Hash)> wallet_get_transaction_by_hash_with_http_info(tx_hash, chain)
+
+```ruby
+begin
+  # Get transaction by hash
+  data, status_code, headers = api_instance.wallet_get_transaction_by_hash_with_http_info(tx_hash, chain)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <WalletGetTransactionByHash200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_get_transaction_by_hash_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **tx_hash** | **String** | Transaction hash (e.g. 0x... for EVM, or block explorer format for UTXO) |  |
+| **chain** | **String** | Chain the transaction belongs to (required for lookup) |  |
+
+### Return type
+
+[**WalletGetTransactionByHash200Response**](WalletGetTransactionByHash200Response.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## wallet_get_transactions
+
+> <WalletGetTransactions200Response> wallet_get_transactions(address_id, opts)
+
+Get transaction history for a non-custodial address
+
+Returns paginated transaction history for a registered non-custodial address (incoming/outgoing, status, confirmations, amounts). 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+address_id = 'address_id_example' # String | Registered address ID.
+opts = {
+  limit: 56, # Integer | Number of transactions per page.
+  page: 56 # Integer | Page number (1-based).
+}
+
+begin
+  # Get transaction history for a non-custodial address
+  result = api_instance.wallet_get_transactions(address_id, opts)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_get_transactions: #{e}"
+end
+```
+
+#### Using the wallet_get_transactions_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<WalletGetTransactions200Response>, Integer, Hash)> wallet_get_transactions_with_http_info(address_id, opts)
+
+```ruby
+begin
+  # Get transaction history for a non-custodial address
+  data, status_code, headers = api_instance.wallet_get_transactions_with_http_info(address_id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <WalletGetTransactions200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_get_transactions_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **address_id** | **String** | Registered address ID. |  |
+| **limit** | **Integer** | Number of transactions per page. | [optional][default to 50] |
+| **page** | **Integer** | Page number (1-based). | [optional][default to 1] |
+
+### Return type
+
+[**WalletGetTransactions200Response**](WalletGetTransactions200Response.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## wallet_get_webhook_logs
+
+> <WalletGetWebhookLogs200Response> wallet_get_webhook_logs(webhook_id, opts)
+
+Get webhook delivery logs
+
+List delivery attempts for a wallet webhook (success/failure, payload, response, duration). Paginated by limit.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure API key authorization: ApiKeyAuth
+  config.api_key['X-API-Key'] = 'YOUR API KEY'
+  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+  # config.api_key_prefix['X-API-Key'] = 'Bearer'
+
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+webhook_id = 'webhook_id_example' # String | Webhook ID (MongoDB ObjectId) to get logs for.
+opts = {
+  limit: 56 # Integer | Maximum number of log entries to return.
+}
+
+begin
+  # Get webhook delivery logs
+  result = api_instance.wallet_get_webhook_logs(webhook_id, opts)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_get_webhook_logs: #{e}"
+end
+```
+
+#### Using the wallet_get_webhook_logs_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<WalletGetWebhookLogs200Response>, Integer, Hash)> wallet_get_webhook_logs_with_http_info(webhook_id, opts)
+
+```ruby
+begin
+  # Get webhook delivery logs
+  data, status_code, headers = api_instance.wallet_get_webhook_logs_with_http_info(webhook_id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <WalletGetWebhookLogs200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_get_webhook_logs_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **webhook_id** | **String** | Webhook ID (MongoDB ObjectId) to get logs for. |  |
+| **limit** | **Integer** | Maximum number of log entries to return. | [optional][default to 50] |
+
+### Return type
+
+[**WalletGetWebhookLogs200Response**](WalletGetWebhookLogs200Response.md)
+
+### Authorization
+
+[ApiKeyAuth](../README.md#ApiKeyAuth), [BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## wallet_list_addresses
+
+> <WalletListAddresses200Response> wallet_list_addresses(opts)
+
+List registered non-custodial addresses
+
+Returns all non-custodial addresses registered for the current project/organization. Optional filters by chain and projectId. Addresses must be registered via POST /api/wallet/non-custodial/register-address before use. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+opts = {
+  chain: 'ethereum', # String | Filter by chain (optional)
+  project_id: 'project_id_example' # String | Filter by project ID (optional).
+}
+
+begin
+  # List registered non-custodial addresses
+  result = api_instance.wallet_list_addresses(opts)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_list_addresses: #{e}"
+end
+```
+
+#### Using the wallet_list_addresses_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<WalletListAddresses200Response>, Integer, Hash)> wallet_list_addresses_with_http_info(opts)
+
+```ruby
+begin
+  # List registered non-custodial addresses
+  data, status_code, headers = api_instance.wallet_list_addresses_with_http_info(opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <WalletListAddresses200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_list_addresses_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **chain** | **String** | Filter by chain (optional) | [optional] |
+| **project_id** | **String** | Filter by project ID (optional). | [optional] |
+
+### Return type
+
+[**WalletListAddresses200Response**](WalletListAddresses200Response.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## wallet_list_webhooks
+
+> <WalletListWebhooks200Response> wallet_list_webhooks(opts)
+
+List wallet webhooks
+
+Returns all wallet webhooks for the current context, optionally filtered by projectId. Includes delivery stats and active status. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+opts = {
+  project_id: 'project_id_example' # String | Filter by project ID (optional).
+}
+
+begin
+  # List wallet webhooks
+  result = api_instance.wallet_list_webhooks(opts)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_list_webhooks: #{e}"
+end
+```
+
+#### Using the wallet_list_webhooks_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<WalletListWebhooks200Response>, Integer, Hash)> wallet_list_webhooks_with_http_info(opts)
+
+```ruby
+begin
+  # List wallet webhooks
+  data, status_code, headers = api_instance.wallet_list_webhooks_with_http_info(opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <WalletListWebhooks200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_list_webhooks_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **project_id** | **String** | Filter by project ID (optional). | [optional] |
+
+### Return type
+
+[**WalletListWebhooks200Response**](WalletListWebhooks200Response.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## wallet_register_address
+
+> <NonCustodialAddressResponse> wallet_register_address(wallet_register_address_request)
+
+Register a non-custodial wallet address
+
+Register a public wallet address for balance monitoring, transaction indexing, and webhook notifications. Keys are never sent to the server; generation and signing happen client-side only. Supports EVM, UTXO, Solana, Tron, TON, Cardano, and other chains. Optionally provide derivation path and label for multi-address tracking. 
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+wallet_register_address_request = Mudbase::WalletRegisterAddressRequest.new({address: '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb', chain: 'ethereum'}) # WalletRegisterAddressRequest | Public address, chain identifier, and optional derivation path and label. projectId scopes the registration to a project.
+
+begin
+  # Register a non-custodial wallet address
+  result = api_instance.wallet_register_address(wallet_register_address_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_register_address: #{e}"
+end
+```
+
+#### Using the wallet_register_address_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<NonCustodialAddressResponse>, Integer, Hash)> wallet_register_address_with_http_info(wallet_register_address_request)
+
+```ruby
+begin
+  # Register a non-custodial wallet address
+  data, status_code, headers = api_instance.wallet_register_address_with_http_info(wallet_register_address_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <NonCustodialAddressResponse>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_register_address_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **wallet_register_address_request** | [**WalletRegisterAddressRequest**](WalletRegisterAddressRequest.md) | Public address, chain identifier, and optional derivation path and label. projectId scopes the registration to a project. |  |
+
+### Return type
+
+[**NonCustodialAddressResponse**](NonCustodialAddressResponse.md)
+
+### Authorization
+
+[BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## wallet_test_webhook
+
+> <WalletTestWebhook200Response> wallet_test_webhook(wallet_test_webhook_request)
+
+Test a webhook delivery (sends a single test payload)
+
+Sends a test payload to the given URL to verify webhook connectivity and signature. Uses the same signing as real deliveries.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure API key authorization: ApiKeyAuth
+  config.api_key['X-API-Key'] = 'YOUR API KEY'
+  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+  # config.api_key_prefix['X-API-Key'] = 'Bearer'
+
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+wallet_test_webhook_request = Mudbase::WalletTestWebhookRequest.new({url: 'url_example'}) # WalletTestWebhookRequest | URL to send the test POST to; optional secret and projectId for scoping; optional event type to simulate.
+
+begin
+  # Test a webhook delivery (sends a single test payload)
+  result = api_instance.wallet_test_webhook(wallet_test_webhook_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_test_webhook: #{e}"
+end
+```
+
+#### Using the wallet_test_webhook_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<WalletTestWebhook200Response>, Integer, Hash)> wallet_test_webhook_with_http_info(wallet_test_webhook_request)
+
+```ruby
+begin
+  # Test a webhook delivery (sends a single test payload)
+  data, status_code, headers = api_instance.wallet_test_webhook_with_http_info(wallet_test_webhook_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <WalletTestWebhook200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_test_webhook_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **wallet_test_webhook_request** | [**WalletTestWebhookRequest**](WalletTestWebhookRequest.md) | URL to send the test POST to; optional secret and projectId for scoping; optional event type to simulate. |  |
+
+### Return type
+
+[**WalletTestWebhook200Response**](WalletTestWebhook200Response.md)
+
+### Authorization
+
+[ApiKeyAuth](../README.md#ApiKeyAuth), [BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## wallet_update_webhook
+
+> <WalletUpdateWebhook200Response> wallet_update_webhook(webhook_id, wallet_update_webhook_request)
+
+Update a wallet webhook
+
+Update webhook URL, events, secret, or filters. Partially applied; only provided fields are updated.
+
+### Examples
+
+```ruby
+require 'time'
+require 'mudbase'
+# setup authorization
+Mudbase.configure do |config|
+  # Configure API key authorization: ApiKeyAuth
+  config.api_key['X-API-Key'] = 'YOUR API KEY'
+  # Uncomment the following line to set a prefix for the API key, e.g. 'Bearer' (defaults to nil)
+  # config.api_key_prefix['X-API-Key'] = 'Bearer'
+
+  # Configure Bearer authorization (JWT): BearerToken
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Mudbase::WalletApi.new
+webhook_id = 'webhook_id_example' # String | Webhook ID (MongoDB ObjectId) to update.
+wallet_update_webhook_request = Mudbase::WalletUpdateWebhookRequest.new # WalletUpdateWebhookRequest | Fields to update (url, events, secret, filters). Omitted fields are left unchanged.
+
+begin
+  # Update a wallet webhook
+  result = api_instance.wallet_update_webhook(webhook_id, wallet_update_webhook_request)
+  p result
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_update_webhook: #{e}"
+end
+```
+
+#### Using the wallet_update_webhook_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<WalletUpdateWebhook200Response>, Integer, Hash)> wallet_update_webhook_with_http_info(webhook_id, wallet_update_webhook_request)
+
+```ruby
+begin
+  # Update a wallet webhook
+  data, status_code, headers = api_instance.wallet_update_webhook_with_http_info(webhook_id, wallet_update_webhook_request)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <WalletUpdateWebhook200Response>
+rescue Mudbase::ApiError => e
+  puts "Error when calling WalletApi->wallet_update_webhook_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **webhook_id** | **String** | Webhook ID (MongoDB ObjectId) to update. |  |
+| **wallet_update_webhook_request** | [**WalletUpdateWebhookRequest**](WalletUpdateWebhookRequest.md) | Fields to update (url, events, secret, filters). Omitted fields are left unchanged. |  |
+
+### Return type
+
+[**WalletUpdateWebhook200Response**](WalletUpdateWebhook200Response.md)
+
+### Authorization
+
+[ApiKeyAuth](../README.md#ApiKeyAuth), [BearerToken](../README.md#BearerToken)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+