Go Back ↗
API Reference

ListWallets

List all wallets for a given owner.

rpc ListWallets

wallet_api.v1.ListWallets

List all wallets for a given owner.

requests ListWalletsRequest

wallet_api.v1.ListWalletsRequest

FieldTypeDescription
pageint32Page number for pagination.
page_sizeint32Size of the page for pagination.
api_keystringAPI key given to the wallet owner at the time of owner creation.
filtersFilterPotential filters to apply to the list of wallets.
sort_bySortByPotential sort to apply to the list of wallets.
resp, _ := custodialWallet.ListWallets(ctx, &v1.ListWalletsRequest{
  ApiKey: "API_KEY",
  Filters: &common.Filter{
    Operator: common.LogicalOperator_LOGICAL_OPERATOR_UNSPECIFIED,
    Filters: []*common.FilterItem{
      &common.FilterItem{
        Field: "FIELD1",
        Operator: common.FilterItem_FILTER_OPERATOR_UNSPECIFIED,
        Value: &common.FilterItem_StrValue{
          StrValue:"STRINGVAL",
        },
      },
      &common.FilterItem{
        Field: "FIELD2",
        Operator: common.FilterItem_FILTER_OPERATOR_UNSPECIFIED,
        Value: &common.FilterItem_IntValue{
          IntValue:10,
        },
      },
      &common.FilterItem{
        Field: "FIELD3",
        Operator: common.FilterItem_FILTER_OPERATOR_UNSPECIFIED,
        Value: &common.FilterItem_BoolValue{
          BoolValue:false,
        },
      },
    },
  },
  Page: 0,
  PageSize: 10,
  SortBy: &common.SortBy{
    Items: []*common.SortItem{
      &common.SortItem{
        Direction: common.SortDirection_SORT_DIRECTION_UNSPECIFIED,
        Field: "FIELD1",
      },
      &common.SortItem{
        Direction: common.SortDirection_SORT_DIRECTION_UNSPECIFIED,
        Field: "FIELD2",
      },
    },
  },
})
fmt.Println(resp)

const filteritem = new FilterItem();
filteritem.setField("FIELD1");
filteritem.setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_UNSPECIFIED);
filteritem.setStrValue("STRINGVAL");
const filteritem1 = new FilterItem();
filteritem1.setField("FIELD2");
filteritem1.setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_EQ);
filteritem1.setIntValue(10);
const filteritem2 = new FilterItem();
filteritem2.setField("FIELD3");
filteritem2.setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_UNSPECIFIED);
filteritem2.setBoolValue(false);
const filter = new Filter();
filter.setOperator(LogicalOperator.LOGICAL_OPERATOR_AND);
filter.setFiltersList([filteritem, filteritem1, filteritem2]);
const sortitem = new SortItem();
sortitem.setDirection(SortDirection.SORT_DIRECTION_UNSPECIFIED);
sortitem.setField("FIELD1");
const sortitem1 = new SortItem();
sortitem1.setDirection(SortDirection.SORT_DIRECTION_UNSPECIFIED);
sortitem1.setField("FIELD2");
const sortby = new SortBy();
sortby.setItemsList([sortitem, sortitem1]);
const listwalletsrequest = new ListWalletsRequest();
listwalletsrequest.setApiKey("API_KEY");
listwalletsrequest.setFilters(filter);
listwalletsrequest.setPage(0);
listwalletsrequest.setPageSize(10);
listwalletsrequest.setSortBy(sortby);

service.listWallets(listwalletsrequest, (err, value:ListWalletsResponse|null) => {
    const resp = JSON.stringify(err ? err : value);
    console.log("received ", resp);
})

using System;
using Grpc.Core;
using Common;
using WalletApi.V1;

namespace main
{
  class Program
  {
    static void Main(string[] args)
    {
      Channel channel = new Channel("wallet.YOUR_SANDBOX_ID.knoxnetworks.io:443", ChannelCredentials.Insecure); 
      var client = new CustodialWallet.CustodialWalletClient(channel); 
      var headers = new Metadata();
      var filterItem = new FilterItem{
        Field = "FIELD1",
        Operator = FilterItem.Types.FilterOperator.Filter_operator_unspecified,
        StrValue = "STRINGVAL",
      };
      var filterItem1 = new FilterItem{
        Field = "FIELD2",
        Operator = FilterItem.Types.FilterOperator.Filter_operator_unspecified,
        IntValue = 10,
      };
      var filterItem2 = new FilterItem{
        Field = "FIELD3",
        Operator = FilterItem.Types.FilterOperator.Filter_operator_unspecified,
        BoolValue = false,
      };
      var filter = new Filter{
        Operator = LogicalOperator.Logical_operator_unspecified,
        Filters = {filterItem, filterItem1, filterItem2},
      };
      var sortItem = new SortItem{
        Direction = SortDirection.Sort_direction_unspecified,
        Field = "FIELD1",
      };
      var sortItem1 = new SortItem{
        Direction = SortDirection.Sort_direction_unspecified,
        Field = "FIELD2",
      };
      var sortBy = new SortBy{
        Items = {sortItem, sortItem1},
      };
      var listWalletsRequest = new ListWalletsRequest{
        ApiKey = "API_KEY",
        Filters = filter,
        Page = 0,
        PageSize = 10,
        SortBy = sortBy,
      };
      var reply = client.ListWallets(listWalletsRequest, headers);
      Console.WriteLine("Response: " + reply);
      channel.ShutdownAsync().Wait();
    }
  }
}

package demo;

import io.grpc.Channel;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import common.Common.Filter;
import common.Common.FilterItem;
import common.Common.LogicalOperator;
import common.Common.SortBy;
import common.Common.SortDirection;
import common.Common.SortItem;
import wallet_api.v1.Wallet.ListWalletsRequest;
import wallet_api.v1.Wallet.ListWalletsResponse;
import wallet_api.v1.CustodialWalletGrpc;

public class App {
  public static void main(String[] args) {
    ManagedChannel channel = ManagedChannelBuilder
      .forAddress("wallet.YOUR_SANDBOX_ID.knoxnetworks.io", 443)
      .usePlaintext()
      .build();
    CustodialWalletGrpc.CustodialWalletBlockingStub blockStub =
        CustodialWalletGrpc.newBlockingStub(channel);
    
    FilterItem req_FilterItem =
        FilterItem.newBuilder()
          .setField("FIELD1")
          .setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_UNSPECIFIED)
          .setStrValue("STRINGVAL")
          .build();
    FilterItem req_FilterItem2 =
        FilterItem.newBuilder()
          .setField("FIELD2")
          .setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_UNSPECIFIED)
          .setIntValue(10)
          .build();
    FilterItem req_FilterItem3 =
        FilterItem.newBuilder()
          .setField("FIELD3")
          .setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_UNSPECIFIED)
          .setBoolValue(false)
          .build();
    Filter req_Filter =
        Filter.newBuilder()
          .setOperator(LogicalOperator.LOGICAL_OPERATOR_UNSPECIFIED)
          .addFilters(req_FilterItem)
          .addFilters(req_FilterItem2)
          .addFilters(req_FilterItem3)
          .build();
    SortItem req_SortItem =
        SortItem.newBuilder()
          .setDirection(SortDirection.SORT_DIRECTION_UNSPECIFIED)
          .setField("FIELD1")
          .build();
    SortItem req_SortItem2 =
        SortItem.newBuilder()
          .setDirection(SortDirection.SORT_DIRECTION_UNSPECIFIED)
          .setField("FIELD2")
          .build();
    SortBy req_SortBy =
        SortBy.newBuilder()
          .addItems(req_SortItem)
          .addItems(req_SortItem2)
          .build();
    ListWalletsRequest req_ListWalletsRequest =
        ListWalletsRequest.newBuilder()
          .setApiKey("API_KEY")
          .setFilters(req_Filter)
          .setPage(0)
          .setPageSize(10)
          .setSortBy(req_SortBy)
          .build();
    ListWalletsResponse resp = blockStub.listWallets(req_ListWalletsRequest);
    System.out.println(resp);
    channel.shutdown();
  }
}

const filteritem = new FilterItem();
filteritem.setField("FIELD1");
filteritem.setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_IN);
filteritem.setStrValue("STRINGVAL");
const filteritem1 = new FilterItem();
filteritem1.setField("FIELD2");
filteritem1.setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_NE);
filteritem1.setIntValue(10);
const filteritem2 = new FilterItem();
filteritem2.setField("FIELD3");
filteritem2.setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_LTE);
filteritem2.setBoolValue(false);
const filter = new Filter();
filter.setOperator(LogicalOperator.LOGICAL_OPERATOR_UNSPECIFIED);
filter.setFiltersList([filteritem, filteritem1, filteritem2]);
const sortitem = new SortItem();
sortitem.setDirection(SortDirection.SORT_DIRECTION_DESCENDING);
sortitem.setField("FIELD1");
const sortitem1 = new SortItem();
sortitem1.setDirection(SortDirection.SORT_DIRECTION_UNSPECIFIED);
sortitem1.setField("FIELD2");
const sortby = new SortBy();
sortby.setItemsList([sortitem, sortitem1]);
const listwalletsrequest = new ListWalletsRequest();
listwalletsrequest.setApiKey("API_KEY");
listwalletsrequest.setFilters(filter);
listwalletsrequest.setPage(0);
listwalletsrequest.setPageSize(10);
listwalletsrequest.setSortBy(sortby);

service.listWallets(listwalletsrequest, (err, value) => {
    const resp = JSON.stringify(err ? err : value);
    console.log("received ", resp);
})

extern crate grpc-sdks;
use tonic::transport::Channel;

use grpc-sdks::wallet_api::v1::wallet_service_client::CustodialWalletClient;
use grpc-sdks::common::SortDirection;
use grpc-sdks::common::SortItem;
use grpc-sdks::wallet_api::v1::ListWalletsRequest;
use grpc-sdks::common::SortBy;
use grpc-sdks::common::Filter;
use grpc-sdks::common::LogicalOperator;
use grpc-sdks::common::filter_item::FilterOperator;
use grpc-sdks::common::filter_item;
use grpc-sdks::common::FilterItem;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
  let channel = Channel::from_static("wallet.YOUR_SANDBOX_ID.knoxnetworks.io")
    .connect()
    .await?;
  let mut client = CustodialWalleteClient::new(channel); 

  let request = tonic::Request::new(
    ListWalletsRequest{
      api_key: String::from("API_KEY"),
      filters: Some(Filter{
        filters: Vec::from([FilterItem{
          field: String::from("FIELD1"),
          operator: FilterOperator::FilterOperatorUnspecified as i32,
          value: Some(filter_item::Value::StrValue(String::from("STRINGVAL")))
        }, FilterItem{
          field: String::from("FIELD2"),
          operator: FilterOperator::FilterOperatorUnspecified as i32,
          value: Some(filter_item::Value::IntValue(10))
        }, FilterItem{
          field: String::from("FIELD3"),
          operator: FilterOperator::FilterOperatorUnspecified as i32,
          value: Some(filter_item::Value::BoolValue(false))
        }]),
        operator: LogicalOperator::LogicalOperatorUnspecified as i32
      }),
      page: 0,
      page_size: 10,
      sort_by: Some(SortBy{
        items: Vec::from([SortItem{
          direction: SortDirection::SortDirectionUnspecified as i32,
          field: String::from("FIELD1")
        }, SortItem{
          direction: SortDirection::SortDirectionUnspecified as i32,
          field: String::from("FIELD2")
        }])
      })
    });
// sending request and waiting for response
  let response = client.list_wallets(request).await?.into_inner();
  println!("RESPONSE={:?}", response);
  Ok(())
}

package app

import io.grpc.ManagedChannelBuilder
import common.Common.Filter
import common.Common.FilterItem
import common.Common.LogicalOperator
import common.Common.SortBy
import common.Common.SortDirection
import common.Common.SortItem
import wallet_api.v1.Wallet.ListWalletsRequest
import wallet_api.v1.Wallet.ListWalletsResponse
import wallet_api.v1.CustodialWalletGrpc

fun main() {
    val channel = ManagedChannelBuilder
            .forAddress("wallet.YOUR_SANDBOX_ID.knoxnetworks.io", 443)
            .usePlaintext()
            .build()
    var blockStub = CustodialWalletGrpc.newBlockingStub(channel)
    
    val req_FilterItem = FilterItem.newBuilder()
          .setField("FIELD1")
          .setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_UNSPECIFIED)
          .setStrValue("STRINGVAL")
          .build()
    val req_FilterItem2 = FilterItem.newBuilder()
          .setField("FIELD2")
          .setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_UNSPECIFIED)
          .setIntValue(10)
          .build()
    val req_FilterItem3 = FilterItem.newBuilder()
          .setField("FIELD3")
          .setOperator(FilterItem.FilterOperator.FILTER_OPERATOR_UNSPECIFIED)
          .setBoolValue(false)
          .build()
    val req_Filter = Filter.newBuilder()
          .setOperator(LogicalOperator.LOGICAL_OPERATOR_UNSPECIFIED)
          .addFilters(req_FilterItem)
          .addFilters(req_FilterItem2)
          .addFilters(req_FilterItem3)
          .build()
    val req_SortItem = SortItem.newBuilder()
          .setDirection(SortDirection.SORT_DIRECTION_UNSPECIFIED)
          .setField("FIELD1")
          .build()
    val req_SortItem2 = SortItem.newBuilder()
          .setDirection(SortDirection.SORT_DIRECTION_UNSPECIFIED)
          .setField("FIELD2")
          .build()
    val req_SortBy = SortBy.newBuilder()
          .addItems(req_SortItem)
          .addItems(req_SortItem2)
          .build()
    val req_ListWalletsRequest = ListWalletsRequest.newBuilder()
          .setApiKey("API_KEY")
          .setFilters(req_Filter)
          .setPage(0)
          .setPageSize(10)
          .setSortBy(req_SortBy)
          .build()
    val resp = blockStub.listWallets(req_ListWalletsRequest)
    println(resp)
    channel.shutdown()
}

returns ListWalletsResponse

wallet_api.v1.ListWalletsResponse

FieldTypeDescription
walletsWallet repeatedList of Wallet objects.
total_owned_walletsuint32Number of wallets belonging to the owner.
{
  "wallets": [
    {
      "wallet_name": "WALLET1",
      "wallet_id": "zWalletIDMultibase58Encoded",
      "public_key": "zPublicKeyMultibase58Encoded",
      "did": "did:method-name:zDIDMultibase58Encoded"
    },
    {
      "wallet_name": "WALLET2",
      "wallet_id": "zWalletIDMultibase58Encoded",
      "public_key": "zPublicKeyMultibase58Encoded",
      "did": "did:method-name:zDIDMultibase58Encoded"
    }
  ],
  "total_owned_wallets": 5
}