Crate quorum_vault_client

Source

Expand description

§Quorum Vault Client

A Rust client for the Quorum Vault Plugin API.

This client based on the Vault Client.

The following backends are supported:

Ethereum
- Create Ethereum Account
- List Ethereum Accounts
- Read Ethereum Account by Address
- Sign Ethereum Transaction (only Legacy)
Keys
- Create Key
- List Keys
- Read Key
- Delete Key
- Sign Data
- Import Private Key

§Installation

Add the following to your Cargo.toml:

[dependencies]
quorum-vault-client = "0.1.0"

§Usage

§Basic

The client is used to configure the connection to Vault and is required to be passed to all API calls for execution. Behind the scenes it uses an asynchronous client from Reqwest for communicating to Vault.

   use quorum_vault_client::{Client, VaultClient, VaultClientSettingsBuilder};

    // Create a client
    let client = VaultClient::new(
        VaultClientSettingsBuilder::default()
            .address("https://127.0.0.1:8200")
            .token("TOKEN")
            .build()
            .unwrap()
        ).unwrap();

§Ethereum

Create new Ethereum Wallet

The following example creates a new Ethereum Wallet in the Vault.

use quorum_vault_client::{Client, VaultClient, VaultClientSettingsBuilder};

#[tokio::main]
async fn main() {
    // Create a client
    let client = VaultClient::new(
        VaultClientSettingsBuilder::default()
            .address("https://127.0.0.1:8200")
            .token("TOKEN")
            .build()
            .unwrap()
    ).unwrap();

    // By default the plugin mounts the Ethereum backend at the path "quorum"
    let created_account = quorum_vault_client::api::ethereum::create_account(&client, "quorum").await.unwrap();
    println!("result: {:?}", created_account);
}

Result of the execution is the following:

> result: EthereumAccountResponse { address: 0x1a669bad7bda1f553087df8568b8782bcb0023ac, compressed_public_key: "0x020e44fde7435da96f8260788a89d4c37f2b3d96fd936dd978b886de6872d73062", public_key: "0x040e44fde7435da96f8260788a89d4c37f2b3d96fd936dd978b886de6872d730629c94a4803d3073b0bbe9a3d46f201eef5beec04d0e6f464e07704c159edd2c64", namespace: "" }

List all Ethereum Wallets

The following example gets list of all Ethereum Wallets in the Vault.

use quorum_vault_client::{Client, VaultClient, VaultClientSettingsBuilder};

#[tokio::main]
async fn main() {
    // Create a client
    let client = VaultClient::new(
        VaultClientSettingsBuilder::default()
            .address("https://127.0.0.1:8200")
            .token("TOKEN")
            .build()
            .unwrap()
    ).unwrap();

    let list_accounts = quorum_vault_client::api::ethereum::list_accounts(&client, "quorum").await.unwrap();
    println!("result: {:?}", list_accounts);
}

Result of the execution is the following:

> result: EthereumAccountsResponse { keys: [0x1a669bad7bda1f553087df8568b8782bcb0023ac, 0x8d3113e29cb92f44f1762e52d2a0276509b36b82] }

Read Ethereum Wallet

The following example gets the Ethereum Wallet by address.

use quorum_vault_client::{Client, VaultClient, VaultClientSettingsBuilder, Address};
use std::str::FromStr;

#[tokio::main]
async fn main() {
    // Create a client
    let client = VaultClient::new(
        VaultClientSettingsBuilder::default()
            .address("https://127.0.0.1:8200")
            .token("TOKEN")
            .build()
            .unwrap()
    ).unwrap();

    let address = Address::from_str("0x8d3113e29CB92F44F1762E52D2a0276509b36b82").unwrap();
    let read_account = quorum_vault_client::api::ethereum::read_account(&client, "quorum", address).await.unwrap();
    println!("result: {:?}", read_account);
}

Result of the execution is the following:

> result: EthereumAccountResponse { address: 0x8d3113e29cb92f44f1762e52d2a0276509b36b82, compressed_public_key: "0x03b1c069a45b14697567661e6426ab0639f73762d7526765b2bd6891a73d84ebb5", public_key: "0x04b1c069a45b14697567661e6426ab0639f73762d7526765b2bd6891a73d84ebb57e6abbec4c9738a025d1a611e431ecf006227dbf6ca400f85518df70e5d101cb", namespace: "" }

Sign Ethereum Transaction

The following example signs the Ethereum Transaction.

use quorum_vault_client::{Client, VaultClient, VaultClientSettingsBuilder, TransactionRequest, Address, U256};
use std::str::FromStr;

#[tokio::main]
async fn main() {
    // Create a client
    let client = VaultClient::new(
        VaultClientSettingsBuilder::default()
            .address("https://127.0.0.1:8200")
            .token("TOKEN")
            .build()
            .unwrap()
    ).unwrap();

    let address = Address::from_str("0x8d3113e29CB92F44F1762E52D2a0276509b36b82").unwrap();
    let mut tx: TransactionRequest = TransactionRequest::builder()
        .from(address)
        .to(address)
        .value(U256::from_dec_str("1000000000000000000").unwrap())
        .gas(U256::from(21000))
        .nonce(U256::from(0))
        .build();

    tx.gas_price = Some(U256::from(1));

    let sign_transaction = quorum_vault_client::api::ethereum::sign_transaction(&client, "quorum", 1, tx).await.unwrap();
    println!("result: {:?}", sign_transaction);
}

Result of the execution is the following:

> signature: EthereumSignTransactionResponse { signature: "0xf29001752503d05ae83874193a8d866d49fc897c1a2fcb6229a0c61e4b5663f7097817a26f4c6014bbfd24c484bad9587c9c627c6f70d020f8638a4067bb78e801" }

§Keys

Create Key

The following example creates a new key in the Vault.

use quorum_vault_client::{Client, VaultClient, VaultClientSettingsBuilder};
use quorum_vault_client::api::keys::KeyCryptoAlgorithm;

#[tokio::main]
async fn main() {
    // Create a client
    let client = VaultClient::new(
        VaultClientSettingsBuilder::default()
            .address("https://127.0.0.1:8200")
            .token("TOKEN")
            .build()
            .unwrap()
    ).unwrap();

    let created_key = quorum_vault_client::api::keys::create_key(&client, "quorum", "some-id", KeyCryptoAlgorithm::Secp256k1, [("tag".to_string(), "value".to_string())].into_iter().collect()).await.unwrap();

    println!("result: {:?}", created_key);
}

Result of the execution is the following:

> result: KeyResponse { created_at: "2023-01-30T09:08:22.217224856Z", curve: "secp256k1", id: "some-id", namespace: "", public_key: "BIwm5UiSGTiXVRlB_rS7qYSzQ6XZbaWfUOJKVicU85q-N7zuAak2JQfAHUs2Sm2WAA7YyWdN7_4UFJFggEa6AKw=", signing_algorithm: "ecdsa", tags: {"tag": "value0"}, updated_at: "2023-01-30T09:08:22.217224856Z", version: 1 }

Read Key

The following example reads the key by id.

use quorum_vault_client::{Client, VaultClient, VaultClientSettingsBuilder};

#[tokio::main]
async fn main() {
  // Create a client
  let client = VaultClient::new(
    VaultClientSettingsBuilder::default()
            .address("https://127.0.0.1:8200")
            .token("TOKEN")
            .build()
            .unwrap()
  ).unwrap();

  let key = quorum_vault_client::api::keys::read_key(&client, "quorum", "some-id").await.unwrap();
    println!("result: {:?}", key);
}

Result of the execution is the following:

> result: KeyResponse { created_at: "2023-01-30T09:08:22.217224856Z", curve: "secp256k1", id: "some-id", namespace: "", public_key: "BIwm5UiSGTiXVRlB_rS7qYSzQ6XZbaWfUOJKVicU85q-N7zuAak2JQfAHUs2Sm2WAA7YyWdN7_4UFJFggEa6AKw=", signing_algorithm: "ecdsa", tags: {"tag": "value0"}, updated_at: "2023-01-30T09:08:22.217224856Z", version: 1 }

List Keys

The following example lists all keys in the Vault.

use quorum_vault_client::{Client, VaultClient, VaultClientSettingsBuilder};

#[tokio::main]
async fn main() {
  // Create a client
  let client = VaultClient::new(
    VaultClientSettingsBuilder::default()
            .address("https://127.0.0.1:8200")
            .token("TOKEN")
            .build()
            .unwrap()
  ).unwrap();

  let keys = quorum_vault_client::api::keys::list_keys(&client, "quorum").await.unwrap();
  println!("result: {:?}", keys);
}

Result of the execution is the following:

> result: KeysResponse { keys: ["some-id"] }

Delete Key

The following example deletes the key by id.

use quorum_vault_client::{Client, VaultClient, VaultClientSettingsBuilder};

#[tokio::main]
async fn main() {
  // Create a client
  let client = VaultClient::new(
    VaultClientSettingsBuilder::default()
            .address("https://127.0.0.1:8200")
            .token("TOKEN")
            .build()
            .unwrap()
  ).unwrap();

  quorum_vault_client::api::keys::destroy_key(&client, "quorum", "some-id").await.unwrap();
}

Sign data

The following example signs the data by key id.

use quorum_vault_client::{Client, VaultClient, VaultClientSettingsBuilder};

#[tokio::main]
async fn main() {
  // Create a client
  let client = VaultClient::new(
    VaultClientSettingsBuilder::default()
            .address("https://127.0.0.1:8200")
            .token("TOKEN")
            .build()
            .unwrap()
  ).unwrap();

  let signature = quorum_vault_client::api::keys::sign(&client, "quorum", "some-id", "some-data".as_bytes()).await.unwrap();
  println!("signature: {:?}", signature);
}

Result of the execution is the following:

> signature: SignResponse { signature: "Z1ibkBIGjMLh5pSR5mFZ5NbesrM57g-FGkFr0sbIyIlI_M0BYVN_LD-Nt7x1wUo6AoLQyL0I-z7PD8MsdgmkhQ==" }

Modules§

api
error

Structs§

AccessListItem: Access list item
AccountDiff: Serde-friendly AccountDiff shadow.
Block: The block type returned from RPC calls. This is generic over a TX type.
BlockHeader: The block header type returned from RPC calls.
BlockTrace: Ad-Hoc trace API type
Bytes: Raw bytes wrapper
BytesArray: A wrapper type for array of bytes.
Call: Call response
CallRequest: Call contract request (eth_call / eth_estimateGas)
CallResult: Call Result
ChangedType: Aux type for Diff::Changed.
Create: Create response
CreateResult: Craete Result
EthProtocolInfo: eth chain version, difficulty, and head of chain which soft fork? Olympic, Frontier, Homestead, Metropolis, Serenity, etc.
FeeHistory: The fee history type returned from eth_feeHistory call.
Filter: Filter
FilterBuilder: Filter Builder
H64
H128
H160: Fixed-size uninterpreted hash type with 20 bytes (160 bits) size.
H256: Fixed-size uninterpreted hash type with 32 bytes (256 bits) size.
H512: Fixed-size uninterpreted hash type with 64 bytes (512 bits) size.
H520
H2048: Bloom hash type with 256 bytes (2048 bits) size.
Log: A log produced by a transaction.
MemoryDiff: A diff of some chunk of memory.
ParityPeerInfo: details of a peer
ParityPeerType: Stores active peer count, connected count, max connected peers and a list of peers for parity node
ParityPendingTransactionFilter: Filter for pending transactions (only openethereum/Parity)
ParityPendingTransactionFilterBuilder: Filter Builder
ParseSignatureError: An error parsing a raw signature.
PeerNetworkInfo: ip address of both local and remote
PeerProtocolsInfo: chain protocol info
PipProtocolInfo: pip version, difficulty, and head
Proof: Proof struct returned by eth_getProof method
RawTransaction: Raw bytes of a signed, but not yet sent transaction
Recovery: Data for recovering the public address of signed data.
Reward: Reward action
SignedData: Struct representing signed data returned from Accounts::sign method.
SignedTransaction: Data for offline signed transaction
StateDiff: Serde-friendly StateDiff shadow.
StorageDiff: A diff of some storage value.
Suicide: Suicide
SyncInfo: Information about current blockchain syncing operations.
Trace: Trace-Filtering API trace type
TraceFilter: Trace filter
TraceFilterBuilder: Trace Filter Builder
Transaction: Description of a Transaction, pending or in the chain.
TransactionParameters: Transaction data for signing.
TransactionReceipt: “Receipt” of an executed transaction: details of its execution.
TransactionRequest: Send Transaction Parameters
TransactionTrace: Trace
TxpoolContentInfo: Transaction Pool Content Info
TxpoolInspectInfo: Transaction Pool Inspect Info
TxpoolStatus: Transaction Pool Status
U64: Little-endian large integer type Unsigned 64-bit integer.
U128: Little-endian large integer type 128-bit unsigned integer.
U256: Little-endian large integer type 256-bit unsigned integer.
VMExecutedOperation: A record of an executed VM operation.
VMOperation: A record of the execution of a single VM operation.
VMTrace: A record of a full VM trace for a CALL/CREATE.
VaultClient: A client which can be used to execute calls against a Vault server.
VaultClientSettingsBuilder: Builder for VaultClientSettings.
Work: Miner’s work package

Enums§

Action: Action
ActionType: An external action type.
BlockId: Block Identifier
BlockNumber: Block Number
CallType: Call type.
Diff: Serde-friendly Diff shadow.
FilterCondition: Condition to filter pending transactions
RecoveryMessage: Recovery message data.
Res: Response
RewardType: Reward type.
SyncState: The current state of blockchain syncing operations.
ToFilter: To Filter
TraceType: Description of the type of trace to make
TransactionCondition: Represents condition on minimum block number or block timestamp.
TransactionId: Transaction Identifier

Traits§

Client: The client interface capabale of interacting with API functions

Type Aliases§

AccessList: Access list
Address: Address
Index: Index in block

Crate quorum_vault_clientCopy item path

§Quorum Vault Client

§Installation

§Usage

§Basic

§Ethereum

§Keys

Modules§

Structs§

Enums§

Traits§

Type Aliases§

Crate quorum_vault_client