Utila

https://docs.utila.io/
Admin
Utila provides a robust REST API for developers to programmatically track, manage, and initiate...
Tokens:300,989
Snippets:823
Trust Score:9.2
Update:11 months ago
Show doc for...
Tokens:
Raw
### Python Utila.io API Call Setup

Source: https://docs.utila.io/reference/example-client

Example setup for calling the Utila.io API to list vaults using the previously defined RestClient. It requires setting the API domain, endpoint, and bearer token. The code initializes the client and executes the `get_vaults` method.

```python
domain = "api.utila.io/"
endpoint = "v2/vaults"
token= "ADD_YOUR_TOKEN_HERE"
client = RestClient(token,domain)
client.get_vaults()
```

--------------------------------

### Get Help for Utila CLI Commands

Source: https://docs.utila.io/reference/utila-cli

This example demonstrates how to access help information for the Utila CLI. You can get general help by using the `--help` flag. To get help for a specific command group, append the group name before the `--help` flag. This is useful for understanding available subcommands and their usage.

```bash
utila --help
```

```bash
utila auth --help
```

--------------------------------

### Co-Signer Webhook Response Example (JSON)

Source: https://docs.utila.io/reference/cosigner-setup-guide

This JSON object represents the expected response format from a webhook used with the Utila Co-Signer in webhook mode. A 'signTransaction' field set to true indicates the transaction should be signed, while false cancels it. The co-signer expects an HTTP 200 OK status code.

```json
{
  "signTransaction": true
}
```

--------------------------------

### Python RestClient for Utila.io API

Source: https://docs.utila.io/reference/example-client

A Python RestClient class for interacting with the Utila.io API. It supports GET and POST requests with authentication and error handling. Dependencies include the 'requests' and 'json' libraries. It handles common headers and provides specific methods for API calls like getting vaults.

```python
import requests
import json

class RestClient:
    def __init__(self, token, domain, timeout=10):
        self.token = token
        self.domain = domain
        self.timeout = timeout  # Default timeout for requests

    def get(self, endpoint, headers=None):
        try:
            res = requests.get(
                f'https://{self.domain}{endpoint}',
                headers=self._common_headers(headers),
                timeout=self.timeout
            )
            res.raise_for_status()
            return res.json()
        except requests.RequestException as e:
            print(f"GET request failed: {e}")
                  # Try to extract the response content if available
            if hasattr(e, 'response') and e.response is not None:
                print(f"Response content: {e.response.text}")  # Print response body
            return None

    def post(self, endpoint, req, headers=None):
        try:
            custom_headers = self._common_headers(headers)
            custom_headers['Content-Type'] = 'application/json'
            res = requests.post(
                f'https://{self.domain}{endpoint}',
                headers=custom_headers,
                json=req,
                timeout=self.timeout
            )
            res.raise_for_status()
            return res.json()
        except requests.RequestException as e:
            print(f"POST request failed: {e}")
            if hasattr(e, 'response') and e.response is not None:
                print(f"Response content: {e.response.text}")  # Print response body
            return None

    def _common_headers(self, additional_headers=None):
        headers = {'Authorization': f'Bearer {self.token}'}
        if additional_headers:
            headers.update(additional_headers)  # Merge with additional headers
        return headers
      
    def get_vaults(self):
       endpoint = "v2/vaults"
       parsed_json = json.dumps(self.get(endpoint),indent=4)
       print(parsed_json)
```

--------------------------------

### Retrieve Asset by ID (Ruby)

Source: https://docs.utila.io/reference/assets

A Ruby example demonstrating how to retrieve asset information via the Ula.io API. It uses the built-in 'net/http' library for making requests.

```ruby
require 'net/http'
require 'uri'
require 'json'

def get_asset(asset_id)
  uri = URI.parse("https://api.utila.io/v2/assets/#{asset_id}")
  http = Net::HTTP.new(uri.host, uri.port)
  http.use_ssl = true

  request = Net::HTTP::Get.new(uri.request_uri)
  request['accept'] = 'application/json'

  begin
    response = http.request(request)
    if response.is_a?(Net::HTTPSuccess)
      return JSON.parse(response.body)
    else
      puts "Error fetching asset: #{response.code} #{response.message}"
      return nil
    end
  rescue StandardError => e
    puts "Error: #{e.message}"
    return nil
  end
end

# Example usage:
# asset_data = get_asset('asset_id')
# puts asset_data
```

--------------------------------

### Run Co-Signer in Sign All Transactions Mode (Shell)

Source: https://docs.utila.io/reference/cosigner-setup-guide

This command executes the Utila Co-Signer in a mode that automatically signs all designated transactions. It requires the vault ID and device ID as parameters. This is the simplest mode of operation.

```shell
./utilacli cosigner run --vault-id <vault-id> --device-id <device-id> --sign-all-txs
```

--------------------------------

### Retrieve Network Information using Node.js

Source: https://docs.utila.io/reference/blockchains

Example of retrieving network details using Node.js. This typically involves using a library like 'axios' or the built-in 'https' module to make the GET request.

--------------------------------

### Retrieve Asset by ID (Node.js)

Source: https://docs.utila.io/reference/assets

Provides a Node.js example for retrieving asset information by ID. It utilizes the 'axios' library for making HTTP requests to the Ula.io API.

```javascript
const axios = require('axios');

const getAsset = async (assetId) => {
  try {
    const response = await axios.get(`https://api.utila.io/v2/assets/${assetId}`, {
      headers: {
        'accept': 'application/json'
      }
    });
    return response.data;
  } catch (error) {
    console.error('Error fetching asset:', error);
    throw error;
  }
};

// Example usage:
// getAsset('asset_id').then(data => console.log(data));
```

--------------------------------

### Setup ERC20 Gas Wallet Allowance (Python)

Source: https://docs.utila.io/reference/ethereum-sepolia

This snippet demonstrates how to prepare and initiate an ERC20 'approve' transaction on the Ethereum Sepolia network. It requires the web3.py library and the requests library for API interaction. The code defines token addresses, wallet addresses, amount, and constructs the transaction data before sending it to the Uila.io API.

```python
from web3 import Web3
import requests

bearer_token = "YOUR_BEARER_TOKEN" # Replace with an updated token
vault_id = "YOUR_VAULT_ID"  # Replace with the actual vault ID
token_address = "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238" # approval token smart contract address (USDC Sepolia)
source_wallet_address = "0xB70e07bAc842d9547C1d56AB7eF5e27021024f23" # Source Wallet
gas_wallet_address = "0x968284717EcdB5696c03e842A5aFa3d1F0333bBd" # Gas Wallet
amount = 1 * (10 ** 6) # Amount to approve (1 USDC = 1 * 10^6 because USDC has 6 decimals)

# ABI for approve function
approve_abi =[{
    "constant": False,
    "inputs": [
        {"name": "spender", "type": "address"},
        {"name": "amount", "type": "uint256"}
    ],
    "name": "approve",
    "outputs": [{"name": "", "type": "bool"}],
    "stateMutability": "nonpayable",
    "type": "function"
}]
# Connect to the Sepolia network
rpc_url = "https://ethereum-sepolia-rpc.publicnode.com"  # Replace with a valid Polygon RPC URL if needed
web3 = Web3(Web3.HTTPProvider(rpc_url))
# Encode function call data
contract = web3.eth.contract(address=token_address, abi=approve_abi)
calldata = contract.functions.approve(gas_wallet_address, amount).build_transaction({"from": source_wallet_address})["data"]

url = f"https://api.utila.io/v2/vaults/{vault_id}/transactions:initiate"
approve_payload = {
    "details": {
        "evmTransaction": {
            "network": "networks/ethereum-testnet-sepolia",
            "fromAddress": "{0}".format(source_wallet_address),
            "toAddress": "{0}".format(token_address),
            "data": "{0}".format(calldata),  # Replace with actual calldata
        },
    },
    "note": "Token Approval",
    "includeReferencedResources": True
}
headers = {
    "Content-Type": "application/json",
    "Authorization": "Bearer {0}".format(bearer_token)  # If authentication is required
}
response = requests.post(url, json=approve_payload, headers=headers)
print(response.status_code)
print(response.json())
```

--------------------------------

### Retrieve Vault by ID - Python Example

Source: https://docs.utila.io/reference/vaults

Example code in Python to fetch vault details using the GetVault API. This example would typically use the 'requests' library.

```python
# Assumes vault_id is defined
# import requests
# 
# url = f"https://api.utila.io/v2/vaults/{vault_id}"
# headers = {'accept': 'application/json'}
# 
# response = requests.get(url, headers=headers)
# print(response.json())
```

--------------------------------

### Example Public RSA Key Format

Source: https://docs.utila.io/reference/set-up-a-service-account

This snippet shows the expected format for a public RSA key when creating a service account. The key must be enclosed within BEGIN PUBLIC KEY and END PUBLIC KEY markers. Ensure the entire public key is copied accurately.

```plaintext
-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAr9R9Xpo2mp1O4jHmvdn/
+Fci4brA3nO9aHr3VAPWrW6N1587JhiQMZpB17RZjWWQUvONf1QcDwYHLZOFjXGN
w2xhLOUIVswfHsUENExMiQfeXBIP5e+cNhkJMVCHT8xMAT6IIh2ex33/dwXObiOs
h49GB13Id2hOYCBdOYWpVhr5Pre3Cp2sK0DL4j6B/jkwWesx2+ercqHPLQq+HnOc
ZELKTWbecKKwXWJsyT+gIVcI9zH1h4N3gEuL1Sozw0lJ1ouPLj6WNHHXyb2CplbB
VFbRyV8fl7EvkVhw0bgcLXnYWphnreh1J0TLPI/BXKQmHrxLL1Lx84xPIAXNHHki
TL92I8XswdKoy0gmTgsQM8p7kN81XKD45T2GoMxMsJBTt/fb818cRQ4a8OB2Ii21
gcaPWc58aaYCZuO4Ibiq/ugvqtrmB+WkTeLPDDDFdHKjlmLyjRM5u4a8haigR2s9
zCdNnQgdMktUZGLqbpM1aNNCu12FTHEBF+rT4YHl97NvtAlPGRapDDxTY3S+5CXH
W/KuvtvulNiwjYEzWqUpq1fdGYirI3sblIx6/8wUYI9Gm/IlJyG7qFTJwLc7pPlm
2FaAFIu8YvGsD0Yy0aChMssGCL4w/d2wJNN41VJvNTyRv60xDGuPF9iRVXj+2adn
u+TDNpU/PNelqdqk7j6fPLMCAwEAAQ==
-----END PUBLIC KEY-----
```

--------------------------------

### Register Utila Device with Existing Private Key

Source: https://docs.utila.io/reference/cli-device-and-key-shares-setup-guide

Registers a new device with the Utila CLI using a pre-existing private key. This command requires the vault ID and the path to the private key file. The private key is used to create the device's key pair.

```shell
utila devices register --vault-id <vault-id> \
  --private-key-path <private-key-file-path>
```

--------------------------------

### Retrieve Vault by ID - Node.js Example

Source: https://docs.utila.io/reference/vaults

Example code in Node.js to fetch vault details using the GetVault API. This example would typically involve an HTTP client library like 'axios' or the built-in 'https' module.

```javascript
// Assumes vault_id is defined and an HTTP client is available
// Example using a hypothetical client:
// const response = await httpClient.get('https://api.utila.io/v2/vaults/' + vault_id, { headers: { 'accept': 'application/json' } });
// console.log(response.data);
```

--------------------------------

### Download Utila Key Shares

Source: https://docs.utila.io/reference/cli-device-and-key-shares-setup-guide

Downloads the encrypted wallet key shares for an approved device. This command requires the vault ID and the device ID. These key shares are essential for signing transactions using the Utila CLI.

```shell
utila keys download --vault-id <vault-id> --device-id <device-id>
```

--------------------------------

### Retrieve Vault by ID - PHP Example

Source: https://docs.utila.io/reference/vaults

Example code in PHP to fetch vault details using the GetVault API. This would typically be implemented using cURL or file_get_contents with stream contexts.

```php
// Assumes vault_id is defined
// $curl = curl_init();
// 
// curl_setopt($curl, CURLOPT_URL, "https://api.utila.io/v2/vaults/{$vault_id}");
// curl_setopt($curl, CURLOPT_HTTPHEADER, array('accept: application/json'));
// curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
// 
// $response = curl_exec($curl);
// curl_close($curl);
// 
// echo $response;
```

--------------------------------

### Register Utila Device with New Key Generation

Source: https://docs.utila.io/reference/cli-device-and-key-shares-setup-guide

Registers a new device with the Utila CLI by automatically generating a new private key. This command requires the vault ID and the `--generate-key` flag to initiate key generation.

```shell
utila devices register --vault-id <vault-id> --generate-key
```

--------------------------------

### GET /v2/assets/{asset_id}

Source: https://docs.utila.io/reference/assets

Retrieves an asset by its unique identifier. The asset ID is a required path parameter.

```APIDOC
## GET /v2/assets/{asset_id}

### Description
Retrieves an asset by its resource name (asset_id).

### Method
GET

### Endpoint
`https://api.utila.io/v2/assets/{asset_id}`

### Parameters
#### Path Parameters
- **asset_id** (string) - Required - The unique identifier for the asset.

### Request Example
```json
{
  "example": "curl --request GET \
     --url https://api.utila.io/v2/assets/asset_id \
     --header 'accept: application/json'"
}
```

### Response
#### Success Response (200)
- **asset** (object) - The asset object containing details.
  - **name** (string) - The resource name of the asset (e.g., `assets/{asset_id}`).
  - **displayName** (string) - The display name of the asset (e.g., "Bitcoin").
  - **network** (string) - The resource name of the network (e.g., `networks/{network_id}`).
  - **type** (string) - The type of the asset (`NATIVE_CURRENCY` or `TOKEN`).
  - **symbol** (string) - The symbol of the asset (may not be reliable for non-native assets).
  - **decimals** (int32) - The number of decimal places for the asset.
  - **convertedValue** (object) - Information about converted values.
  - **tokenInfo** (object) - Token-specific information (only present if type is `TOKEN`).

#### Response Example
```json
{
  "asset": {
    "name": "assets/bitcoin",
    "displayName": "Bitcoin",
    "network": "networks/bitcoin",
    "type": "NATIVE_CURRENCY",
    "symbol": "BTC",
    "decimals": 8,
    "convertedValue": {},
    "tokenInfo": {}
  }
}
```
```

--------------------------------

### Create Wallet

Source: https://docs.utila.io/reference/balances_querybalances

Creates a new wallet within a specified vault. This endpoint allows for the initial setup of a wallet, including its display name and associated networks.

```APIDOC
## POST /websites/utila_io/wallets

### Description
Creates a new wallet within a specified vault. This endpoint allows for the initial setup of a wallet, including its display name and associated networks.

### Method
POST

### Endpoint
`/websites/utila_io/wallets`

### Parameters
#### Request Body
- **vaultId** (string) - Required - The ID of the vault where the wallet will be created.
- **displayName** (string) - Required - A human-readable name for the wallet. Must match the regular expression `[a-zA-Z0-9\.,:\-'# _$]+$` and be shorter than 100 characters.
- **networks** (array) - Optional - A list of resource names for the networks to associate with the wallet during creation.

### Request Example
```json
{
  "vaultId": "vaults/1b25635a5b3f",
  "displayName": "My New Wallet",
  "networks": [
    "networks/ethereum-mainnet",
    "networks/polygon-mainnet"
  ]
}
```

### Response
#### Success Response (201)
- **name** (string) - The resource name of the newly created wallet. Format: `vaults/{vault_id}/wallets/{wallet_id}`.
- **displayName** (string) - The human-readable name of the wallet.
- **external** (boolean) - Indicates if the wallet is external (always false for newly created wallets).
- **archived** (boolean) - Indicates if the wallet is archived (always false for newly created wallets).
- **networks** (array) - A list of resource names for the networks associated with the wallet.

#### Response Example
```json
{
  "name": "vaults/1b25635a5b3f/wallets/a1b2c3d4e5f6",
  "displayName": "My New Wallet",
  "external": false,
  "archived": false,
  "networks": [
    "networks/ethereum-mainnet",
    "networks/polygon-mainnet"
  ]
}
```
```

--------------------------------

### Retrieve Vault by ID - Ruby Example

Source: https://docs.utila.io/reference/vaults

Example code in Ruby to fetch vault details using the GetVault API. This snippet would typically use Ruby's built-in Net::HTTP library or a gem like 'httparty'.

```ruby
# Assumes vault_id is defined
# require 'net/http'
# require 'uri'
# 
# uri = URI.parse("https://api.utila.io/v2/vaults/#{vault_id}")
# http = Net::HTTP.new(uri.host, uri.port)
# http.use_ssl = true
# request = Net::HTTP::Get.new(uri.request_uri)
# request['accept'] = 'application/json'
# 
# response = http.request(request)
# puts response.body
```

--------------------------------

### Pack and Unpack Protobuf Any Message in Go

Source: https://docs.utila.io/reference/transactions_getlatesttransactionsimulation

Provides an example of packing a protobuf message into an 'Any' type and unpacking it in Go. This facilitates the transmission of various protobuf messages.

```go
foo := &pb.Foo{...}
any, err := anypb.New(foo)
if err != nil {
  ...
}
...
foo := &pb.Foo{}
if err := any.UnmarshalTo(foo); err != nil {
  ...
}
```

--------------------------------

### GET /v2/vaults/{vault_id}

Source: https://docs.utila.io/reference/vaults

Retrieves a specific vault by its unique identifier. Requires the vault ID as a path parameter.

```APIDOC
## GET /v2/vaults/{vault_id}

### Description
Retrieves a vault by its resource name.

### Method
GET

### Endpoint
`https://api.utila.io/v2/vaults/{vault_id}`

### Parameters
#### Path Parameters
- **vault_id** (string) - Required - The unique identifier of the vault.

### Request Example
```bash
curl --request GET \
     --url https://api.utila.io/v2/vaults/vault_id \
     --header 'accept: application/json'
```

### Response
#### Success Response (200)
- **vault** (object) - The vault object containing details.
  - **name** (string) - The resource name of the vault. Format: `vaults/{vault_id}`.
  - **displayName** (string) - Required - A human-readable name for the vault. Must match the regular expression `[a-zA-Z0-9\.,:\-'# _$]+$` and be shorter than 100 characters.
  - **archived** (boolean) - Whether this vault is archived.
  - **createTime** (date-time) - Creation timestamp of the vault.

#### Response Example
```json
{
  "vault": {
    "name": "vaults/vault_id",
    "displayName": "My Vault Name",
    "archived": false,
    "createTime": "2023-10-27T10:00:00Z"
  }
}
```
```

--------------------------------

### GET /v2/networks/{network_id}

Source: https://docs.utila.io/reference/blockchains

Retrieves a Network by its resource name (network_id). This endpoint returns detailed information about a specific network, including its display name, CAIP details, and native asset.

```APIDOC
## GET /v2/networks/{network_id}

### Description
Retrieves a Network by resource name.

### Method
GET

### Endpoint
`https://api.utila.io/v2/networks/{network_id}`

### Parameters
#### Path Parameters
- **network_id** (string) - Required - The unique identifier for the network.

### Request Example
```json
{
  "example": "curl --request GET \
     --url https://api.utila.io/v2/networks/network_id \
     --header 'accept: application/json'"
}
```

### Response
#### Success Response (200)
- **network** (object) - The network object containing details.
  - **name** (string) - The resource name of the network. Format: `networks/{network_id}`.
  - **displayName** (string) - A user-readable name for the network.
  - **caipDetails** (object) - Chain-Agnostic Identifiers (CAIP) details for this network.
    - **testnet** (boolean) - Whether this network is a testnet.
    - **nativeAsset** (string) - The native asset of this network. Format: `assets/{asset_id}`.
    - **custom** (boolean) - Whether this network is custom.

#### Response Example
```json
{
  "network": {
    "name": "networks/mainnet",
    "displayName": "Ethereum Mainnet",
    "caipDetails": {
      "chainId": "eip155:1",
      "blockchainNamespace": "evm",
      "testnet": false,
      "nativeAsset": "assets/eip155:1:0x0000000000000000000000000000000000000001",
      "custom": false
    }
  }
}
```
```

--------------------------------

### Wallet Creation API

Source: https://docs.utila.io/reference/wallets_createwallet

This section details the structure of a wallet object and its associated network details. It describes the properties required for creating a new wallet, including display name and network configurations.

```APIDOC
## POST /websites/utila_io/wallets

### Description
Creates a new wallet with specified network details.

### Method
POST

### Endpoint
/websites/utila_io/wallets

### Parameters
#### Request Body
- **displayName** (string) - Required - The display name of the wallet.
- **networks** (object) - Required - An object containing details for different network types.
  - **tronDetails** (object) - Optional - Details for the Tron network.
    - **address** (string) - Optional - The address of the wallet on the Tron network.
  - **tonDetails** (object) - Optional - Details for the Ton network.
    - **address** (string) - Optional - The address of the wallet on the Ton network.
  - **solanaDetails** (object) - Optional - Details for the Solana network.
    - **address** (string) - Optional - The address of the wallet on the Solana network.
  - **btcDetails** (object) - Optional - Details for the Bitcoin network.
    - **btcNetworkDetails** (array) - Optional - An array of specific Bitcoin network configurations.
      - **network** (string) - Optional - A specific BTC network of the wallet (e.g., 'networks/bitcoin-mainnet').
      - **mainAddress** (string) - Optional - The main deposit address of the wallet in the network.
      - **xpub** (string) - Optional - The xpub of the wallet in the network. Included only when `FULL` view is requested.

### Request Example
```json
{
  "displayName": "My Main Wallet",
  "networks": {
    "tronDetails": {
      "address": "0x12345abcde..."
    },
    "btcDetails": {
      "btcNetworkDetails": [
        {
          "network": "networks/bitcoin-mainnet",
          "mainAddress": "bc1q...",
          "xpub": "xpub..."
        }
      ]
    }
  }
}
```

### Response
#### Success Response (200)
- **id** (string) - The unique identifier for the created wallet.
- **displayName** (string) - The display name of the wallet.
- **createdAt** (string) - The timestamp when the wallet was created.
- **networks** (object) - An object containing details for different network types (same structure as request body).

#### Response Example
```json
{
  "id": "wallet-12345",
  "displayName": "My Main Wallet",
  "createdAt": "2023-10-27T10:00:00Z",
  "networks": {
    "tronDetails": {
      "address": "0x12345abcde..."
    },
    "btcDetails": {
      "btcNetworkDetails": [
        {
          "network": "networks/bitcoin-mainnet",
          "mainAddress": "bc1q...",
          "xpub": "xpub..."
        }
      ]
    }
  }
}
```
```

--------------------------------

### GetVault API Request using cURL

Source: https://docs.utila.io/reference/vaults

This snippet demonstrates how to make a GET request to the GetVault API endpoint using cURL. It requires the vault_id as a path parameter and an 'accept' header for JSON response.

```shell
curl --request GET \
     --url https://api.utila.io/v2/vaults/vault_id \
     --header 'accept: application/json'
```

--------------------------------

### Initiate ERC20 transferFrom Transaction (Python)

Source: https://docs.utila.io/reference/ethereum-sepolia

This Python snippet shows how to set up and initiate an ERC20 'transferFrom' transaction on the Ethereum Sepolia network. It requires the web3.py library for ABI encoding and the requests library for API calls. The code specifies destination address, amount, and constructs the necessary transaction data before sending it to the Uila.io API.

```python
destination_address = "0x9e21BF0F214cD33b2DC3Bfd49301E86d62b564Dc" 
amount = int(0.05 * (10 ** 6)) # Amount to approve (1 USDC = 1 * 10^6 because USDC has 6 decimals)

transfer_from_abi = [{
    "constant": False,
    "inputs": [
        {"name": "from", "type": "address"},
        {"name": "to", "type": "address"},
        {"name": "value", "type": "uint256"}
    ],
    "name": "transferFrom",
    "outputs": [{"name": "", "type": "bool"}],
    "stateMutability": "nonpayable",
    "type": "function"
}]
# Connect to the Sepolia network
rpc_url = "https://ethereum-sepolia-rpc.publicnode.com"  # Replace with a valid Polygon RPC URL if needed
web3 = Web3(Web3.HTTPProvider(rpc_url))
```

--------------------------------

### Initiate Asset Transfer

Source: https://docs.utila.io/reference/asset-transfer

Initiates a transfer of a specified asset (e.g., USDC on Sepolia Testnet) from a source to a destination address. Optional parameters include paying fees from the transfer amount and adding an on-chain memo.

```APIDOC
## POST /v2/vaults/{vault_id}/transactions:initiate

### Description
Initiates a transfer of a specified asset (e.g., USDC on Sepolia Testnet) from a source to a destination address. Optional parameters include paying fees from the transfer amount and adding an on-chain memo.

### Method
POST

### Endpoint
`/v2/vaults/{vault_id}/transactions:initiate`

### Parameters
#### Path Parameters
- **vault_id** (string) - Required - The ID of the vault from which the transaction is initiated.

#### Request Body
- **details** (object) - Required - Contains the details of the asset transfer.
  - **assetTransfer** (object) - Required - Specifies the parameters for the asset transfer.
    - **asset** (string) - Required - The identifier for the asset to be transferred (e.g., `assets/erc20.networks/ethereum-testnet-sepolia.0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238`).
    - **amount** (string) - Required - The amount of the asset to transfer (e.g., "1.3").
    - **source** (string) - Required - The source address or identifier for the asset.
    - **destination** (string) - Required - The destination address for the asset.
    - **payFeeFromAmount** (boolean) - Optional - If true, gas fees will be paid from the transfer amount (EVM-only). Defaults to false.
    - **memo** (string) - Optional - An on-chain memo to include with the transfer.

### Request Example
```json
{
  "details": {
    "assetTransfer": {
      "asset": "assets/erc20.ethereum-testnet-sepolia.0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
      "amount": "1.3",
      "source": "0xB70e07bAc842d9547C1d56AB7eF5e27021024f23",
      "destination": "0x9e21BF0F214cD33b2DC3Bfd49301E86d62b564Dc",
      "payFeeFromAmount": false,
      "memo": "my first transfer"
    }
  }
}
```

### Response
#### Success Response (200)
- **transaction** (object) - Details of the initiated transaction.
  - **name** (string) - The unique identifier for the transaction.
  - **type** (string) - The type of transaction (e.g., "TRANSACTION").
  - **subType** (string) - The subtype of the transaction (e.g., "TOKEN_TRANSFER").
  - **state** (string) - The current state of the transaction (e.g., "AWAITING_POLICY_CHECK").
  - **network** (string) - The network on which the transaction is initiated.
  - **request** (object) - Information about the transaction request.
  - **transfers** (array) - A list of asset transfers included in the transaction.
  - **evmTransaction** (object) - Details specific to EVM transactions, including gas information.

#### Response Example
```json
{
  "transaction": {
    "name": "vaults/19e826e48ef4/transactions/90151924a6c7",
    "type": "TRANSACTION",
    "subType": "TOKEN_TRANSFER",
    "state": "AWAITING_POLICY_CHECK",
    "note": "",
    "network": "networks/ethereum-testnet-sepolia",
    "request": {
      "initiator": "users/34e9eedd2b3e",
      "sourceWallet": "vaults/19e826e48ef4/wallets/369806e309a2"
    },
    "signingSession": "",
    "transfers": [
      {
        "amount": "1.3",
        "asset": "assets/erc20.ethereum-testnet-sepolia.0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
        "sourceAddress": {
          "value": "0xB70e07bAc842d9547C1d56AB7eF5e27021024f23"
        },
        "destinationAddress": {
          "value": "0x9e21BF0F214cD33b2DC3Bfd49301E86d62b564Dc"
        }
      }
    ],
    "tokenAllowances": [],
    "designatedSigners": [],
    "evmTransaction": {
      "fromAddress": {
        "value": "0xB70e07bAc842d9547C1d56AB7eF5e27021024f23"
      },
      "toAddress": {
        "value": "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"
      },
      "value": "0",
      "data": "0xa9059cbb0000000000000000000000009e21bf0f214cd33b2dc3bfd49301e86d62b564dc000000000000000000000000000000000000000000000000000000000013d620",
      "fee": {
        "gasLimit": "45439",
        "maxPriorityFeePerGas": "2625507",
        "maxFeePerGas": "30501983307",
        "gasUsed": ""
      }
    },
    "createTime": "2025-03-13T13:31:05.281801602Z"
  },
  "referencedResources": {},
  "referencedAddressesInfo": {}
}
```
```

--------------------------------

### Wallet Details

Source: https://docs.utila.io/reference/transactions_initiatetransaction

Retrieves detailed information about a user's wallet, including addresses and configurations for supported networks.

```APIDOC
## GET /wallets/{walletId}

### Description
Retrieves detailed information about a specific wallet, including addresses and configurations for supported networks such as Tron, Ton, Solana, and Bitcoin.

### Method
GET

### Endpoint
`/wallets/{walletId}`

### Parameters
#### Path Parameters
- **walletId** (string) - Required - The unique identifier of the wallet.

### Response
#### Success Response (200)
- **displayName** (string) - The display name of the wallet.
- **networks** (array) - A list of supported networks for the wallet.
  - **tronDetails** (object) - Details for the Tron network.
    - **address** (string) - The Tron address of the wallet.
  - **tonDetails** (object) - Details for the Ton network.
    - **address** (string) - The Ton address of the wallet.
  - **solanaDetails** (object) - Details for the Solana network.
    - **address** (string) - The Solana address of the wallet.
  - **btcDetails** (object) - Details for the Bitcoin network.
    - **btcNetworkDetails** (array) - Specific Bitcoin network details.
      - **network** (string) - The Bitcoin network (e.g., `networks/bitcoin-mainnet`).
      - **mainAddress** (string) - The main deposit address for the network.
      - **xpub** (string) - The xpub of the wallet in the network (included when `FULL` view is requested).

#### Response Example
```json
{
  "displayName": "My Primary Wallet",
  "networks": ["TRON", "TON", "SOLANA", "BITCOIN"],
  "tronDetails": {
    "address": "TLK3q9LwDqfC4jRz9sX5sY7z8v9c0b1d2"
  },
  "tonDetails": {
    "address": "UQBNq9LwDqfC4jRz9sX5sY7z8v9c0b1d2"
  },
  "solanaDetails": {
    "address": "9LwDqfC4jRz9sX5sY7z8v9c0b1d2a3b4c5"
  },
  "btcDetails": {
    "btcNetworkDetails": [
      {
        "network": "networks/bitcoin-mainnet",
        "mainAddress": "1BvBMSEYstWetqTFn5Au4m4GFg7xJaNVN2",
        "xpub": "xpub6CoUfJ3G665Zp33xQ3nQ4z3k9p8b5w7v8d9e0f1g2h3i4j5k6l7m8n9o0p1q2r3s4t5u6v7w8x9y0z1"
      }
    ]
  }
}
```
```

--------------------------------

### Get Transaction Details

Source: https://docs.utila.io/reference/balances_querywalletbalances

Retrieves the details of a specific transaction by its resource name.

```APIDOC
## GET /websites/utila_io/vaults/{vault_id}/transactions/{transaction_id}

### Description
Retrieves the details of a specific transaction using its resource name. The resource name is a unique identifier for the transaction within a vault.

### Method
GET

### Endpoint
`/websites/utila_io/vaults/{vault_id}/transactions/{transaction_id}`

### Parameters
#### Path Parameters
- **vault_id** (string) - Required - The unique identifier of the vault.
- **transaction_id** (string) - Required - The unique identifier of the transaction.

### Request Example
```json
{
  "example": ""
}
```

### Response
#### Success Response (200)
- **name** (string) - The resource name of the transaction (e.g., `vaults/1b25635a5b3f/transactions/95257c5a522f`).
- **type** (string) - The type of the transaction (`TRANSACTION` or `MESSAGE`).
- **subType** (string) - The subtype of the transaction (e.g., `NATIVE_TRANSFER`, `TOKEN_TRANSFER`, `CONTRACT_CALL`).
- **state** (string) - The current state of the transaction (e.g., `AWAITING_APPROVAL`, `PUBLISHED`, `MINED`, `FAILED`).

#### Response Example
```json
{
  "name": "vaults/1b25635a5b3f/transactions/95257c5a522f",
  "type": "TRANSACTION",
  "subType": "NATIVE_TRANSFER",
  "state": "MINED"
}
```
```

--------------------------------

### GET /websites/utila_io/transactions/{transactionId}

Source: https://docs.utila.io/reference/transactions_gettransaction

Retrieves the details of a specific transaction using its unique identifier.

```APIDOC
## GET /websites/utila_io/transactions/{transactionId}

### Description
Retrieves the details of a specific transaction using its unique identifier.

### Method
GET

### Endpoint
/websites/utila_io/transactions/{transactionId}

### Parameters
#### Path Parameters
- **transactionId** (string) - Required - The unique identifier of the transaction.

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **blockNumber** (string) - The block number of the transaction if it was mined.
- **signingSession** (string) - Available when the transaction has been prepared for signing / signed.
- **request** (object) - The request details of the transaction. Relevant only for transactions initiated through Utila.
  - **name** (string) - The resource name of the transaction request.
  - **initiator** (string) - The initiator of the transaction.
  - **sourceWallet** (string) - If the transaction was initiated through a wallet, the wallet will be listed here.
  - **cancelTime** (string) - The timestamp when the transaction was canceled.
  - **signTime** (string) - The timestamp when the transaction was signed.
  - **failTime** (string) - The timestamp when the transaction failed.
  - **declineTime** (string) - The timestamp when the transaction was declined.
  - **publishTime** (string) - The timestamp when the transaction was published.
  - **dropTime** (string) - The timestamp when the transaction was dropped.
  - **expireTime** (string) - The timestamp when the transaction expires.
  - **approveTime** (string) - The timestamp when the transaction was approved.

#### Response Example
```json
{
  "blockNumber": "1234567",
  "signingSession": "vaults/2d2e40r3/signingSessions/132e40r3",
  "request": {
    "name": "vaults/1b25635a5b3f/transactionRequests/95257c5a522f",
    "initiator": "users/2d2e40r3",
    "sourceWallet": "wallets/2d2e40r3",
    "cancelTime": "2023-10-27T10:00:00Z",
    "signTime": "2023-10-27T10:05:00Z",
    "failTime": null,
    "declineTime": null,
    "publishTime": "2023-10-27T10:03:00Z",
    "dropTime": null,
    "expireTime": "2023-11-26T10:00:00Z",
    "approveTime": "2023-10-27T10:04:00Z"
  }
}
```
```

--------------------------------

### Configure Service Account Credentials via CLI (Private Key File)

Source: https://docs.utila.io/reference/cli-authentication

This command configures the Utila CLI to authenticate using a service account's private key file. It requires the service account email and the path to the private key file. This is a common method for initial setup or when managing credentials directly.

```shell
utila auth add-service-account-credentials \
  --email my-service-account@vault-a1b2c3d4.utilaserviceaccount.io \
  --private-key-path ~/keys/my-service-account-key.pem
```
Tokens:
Raw