tapass 0.0.0-stage → 0.2.0

package/src/tapd_responses/rpc_addr_as_address.ts

@@ -0,0 +1,138 @@
+const addressVersions = [
+  'ADDR_VERSION_V0',
+  'ADDR_VERSION_V1',
+  'ADDR_VERSION_V2',
+];
+const assetVersions = ['ASSET_VERSION_V0', 'ASSET_VERSION_V1'];
+const hexOf = (n: Buffer) => (!n.length ? undefined : n.toString('hex'));
+const isBuffer = (n: unknown): n is Buffer => Buffer.isBuffer(n);
+const isNumeric = (n: unknown) => typeof n === 'string' && /^\d+$/.test(n);
+
+export type RpcAddr = {
+  address_version: string;
+  amount: string;
+  asset_id: Buffer;
+  asset_type: string;
+  asset_version: string;
+  encoded: string;
+  group_key: Buffer;
+  internal_key: Buffer;
+  proof_courier_addr: string;
+  script_key: Buffer;
+  taproot_output_key: Buffer;
+  tapscript_sibling: Buffer;
+};
+
+export type Address = {
+  /** Encoded Taproot Assets Address */
+  address: string;
+  /** Asset Units To Receive Numeric String */
+  amount: string;
+  /** Asset Id Hex */
+  asset_id?: string;
+  /** Asset Version */
+  asset_version: number;
+  /** Asset Group Key Hex */
+  group_key?: string;
+  /** Internal Key Hex */
+  internal_key: string;
+  /** Asset Is Collectible */
+  is_collectible: boolean;
+  /** Proof Courier Address */
+  proof_courier: string;
+  /** Script Key Hex */
+  script_key: string;
+  /** Tapscript Sibling Preimage Hex */
+  tapscript_sibling?: string;
+  /** Taproot Output Key Hex */
+  taproot_output_key: string;
+  /** Address Version */
+  version: number;
+};
+
+/** Address from an RPC Taproot Assets address
+
+  {
+    address_version: <Address Version String>
+    amount: <Asset Units Numeric String>
+    asset_id: <Asset Id Buffer Object>
+    asset_type: <Asset Type String>
+    asset_version: <Asset Version String>
+    encoded: <Encoded Address String>
+    group_key: <Asset Group Key Buffer Object>
+    internal_key: <Internal Key Buffer Object>
+    proof_courier_addr: <Proof Courier Address String>
+    script_key: <Script Key Buffer Object>
+    taproot_output_key: <Taproot Output Key Buffer Object>
+    tapscript_sibling: <Tapscript Sibling Preimage Buffer Object>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    address: <Encoded Taproot Assets Address String>
+    amount: <Asset Units To Receive Numeric String>
+    [asset_id]: <Asset Id Hex String>
+    asset_version: <Asset Version Number>
+    [group_key]: <Asset Group Key Hex String>
+    internal_key: <Internal Key Hex String>
+    is_collectible: <Asset Is Collectible Bool>
+    proof_courier: <Proof Courier Address String>
+    script_key: <Script Key Hex String>
+    [tapscript_sibling]: <Tapscript Sibling Preimage Hex String>
+    taproot_output_key: <Taproot Output Key Hex String>
+    version: <Address Version Number>
+  }
+*/
+export default (addr?: RpcAddr | null): Address => {
+  if (!addr) {
+    throw new Error('ExpectedRpcAddressDetails');
+  }
+
+  if (!addr.encoded) {
+    throw new Error('ExpectedEncodedAddressInRpcAddress');
+  }
+
+  if (!isNumeric(addr.amount)) {
+    throw new Error('ExpectedAmountInRpcAddress');
+  }
+
+  if (!isBuffer(addr.asset_id) || !isBuffer(addr.group_key)) {
+    throw new Error('ExpectedAssetIdentityInRpcAddress');
+  }
+
+  if (!isBuffer(addr.internal_key) || !isBuffer(addr.script_key)) {
+    throw new Error('ExpectedKeysInRpcAddress');
+  }
+
+  if (!isBuffer(addr.taproot_output_key)) {
+    throw new Error('ExpectedOutputKeyInRpcAddress');
+  }
+
+  if (!isBuffer(addr.tapscript_sibling)) {
+    throw new Error('ExpectedTapscriptSiblingInRpcAddress');
+  }
+
+  const version = addressVersions.indexOf(addr.address_version);
+
+  if (version === -1) {
+    throw new Error('ExpectedKnownVersionInRpcAddress');
+  }
+
+  return {
+    version,
+    address: addr.encoded,
+    amount: addr.amount,
+    asset_id: hexOf(addr.asset_id),
+    asset_version: assetVersions.indexOf(addr.asset_version),
+    group_key: hexOf(addr.group_key),
+    internal_key: addr.internal_key.toString('hex'),
+    is_collectible: addr.asset_type === 'COLLECTIBLE',
+    proof_courier: addr.proof_courier_addr,
+    script_key: addr.script_key.toString('hex'),
+    tapscript_sibling: hexOf(addr.tapscript_sibling),
+    taproot_output_key: addr.taproot_output_key.toString('hex'),
+  };
+};

package/src/tapd_responses/rpc_addr_event_as_receive.ts

@@ -0,0 +1,103 @@
+import outpointAsTransaction from './outpoint_as_transaction.js';
+import receiveStatuses from './receive_statuses.js';
+import rpcAddrAsAddress from './rpc_addr_as_address.js';
+import type {Address} from './rpc_addr_as_address.js';
+import type {RpcAddr} from './rpc_addr_as_address.js';
+
+const dateFrom = (n: string) => new Date(Number(n) * 1e3).toISOString();
+const hexOf = (n: Buffer) => (!n.length ? undefined : n.toString('hex'));
+const isBuffer = (n: unknown): n is Buffer => Buffer.isBuffer(n);
+const isNumeric = (n: unknown) => typeof n === 'string' && /^\d+$/.test(n);
+
+export type RpcAddrEvent = {
+  addr: RpcAddr | null;
+  confirmation_height: number;
+  creation_time_unix_seconds: string;
+  has_proof: boolean;
+  outpoint: string;
+  status: string;
+  taproot_sibling: Buffer;
+  utxo_amt_sat: string;
+};
+
+export type Receive = {
+  address: Address;
+  /** Confirmation Block Height */
+  confirmation_height?: number;
+  /** Receive Detected At ISO 8601 Date */
+  created_at: string;
+  /** Proof File Is Available */
+  is_proof_available: boolean;
+  /** Receive Status */
+  status: string;
+  /** Tapscript Sibling Hash Hex */
+  tapscript_sibling?: string;
+  /** Satoshis In the Anchor Output */
+  tokens: number;
+  /** Anchor Transaction Id Hex */
+  transaction_id: string;
+  /** Anchor Transaction Output Index */
+  transaction_vout: number;
+};
+
+/** Receive from an RPC address event
+
+  {
+    addr: <RPC Address Object>
+    confirmation_height: <Confirmation Block Height Number>
+    creation_time_unix_seconds: <Created At Unix Seconds Numeric String>
+    has_proof: <Proof File Is Available Bool>
+    outpoint: <Anchor Outpoint String>
+    status: <Address Event Status String>
+    taproot_sibling: <Tapscript Sibling Hash Buffer Object>
+    utxo_amt_sat: <Satoshis In the Anchor Output Numeric String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    address: <Address Object>
+    [confirmation_height]: <Confirmation Block Height Number>
+    created_at: <Receive Detected At ISO 8601 Date String>
+    is_proof_available: <Proof File Is Available Bool>
+    status: <Receive Status String>
+    [tapscript_sibling]: <Tapscript Sibling Hash Hex String>
+    tokens: <Satoshis In the Anchor Output Number>
+    transaction_id: <Anchor Transaction Id Hex String>
+    transaction_vout: <Anchor Transaction Output Index Number>
+  }
+*/
+export default (event?: RpcAddrEvent | null): Receive => {
+  if (!event) {
+    throw new Error('ExpectedRpcAddressEventDetails');
+  }
+
+  if (!isNumeric(event.creation_time_unix_seconds)) {
+    throw new Error('ExpectedCreationTimeInRpcAddressEvent');
+  }
+
+  if (!receiveStatuses[event.status]) {
+    throw new Error('ExpectedKnownStatusInRpcAddressEvent');
+  }
+
+  if (!isBuffer(event.taproot_sibling)) {
+    throw new Error('ExpectedTaprootSiblingInRpcAddressEvent');
+  }
+
+  if (!isNumeric(event.utxo_amt_sat)) {
+    throw new Error('ExpectedUtxoAmountInRpcAddressEvent');
+  }
+
+  return {
+    address: rpcAddrAsAddress(event.addr),
+    confirmation_height: event.confirmation_height || undefined,
+    created_at: dateFrom(event.creation_time_unix_seconds),
+    is_proof_available: event.has_proof,
+    status: receiveStatuses[event.status],
+    tapscript_sibling: hexOf(event.taproot_sibling),
+    tokens: Number(event.utxo_amt_sat),
+    ...outpointAsTransaction(event.outpoint),
+  };
+};

package/src/tapd_responses/rpc_asset_amount_as_amount.ts

@@ -0,0 +1,57 @@
+const hexOf = (n?: Buffer | null) =>
+  !n?.length ? undefined : n.toString('hex');
+const isBuffer = (n: unknown): n is Buffer => Buffer.isBuffer(n);
+const isNumeric = (n: unknown) => typeof n === 'string' && /^\d+$/.test(n);
+
+export type RpcAssetAmount = {
+  amount: string;
+  asset_id: Buffer;
+  group_key: Buffer;
+};
+
+export type AssetAmount = {
+  /** Asset Units Numeric String */
+  amount: string;
+  /** Asset Id Hex */
+  asset_id: string;
+  /** Asset Group Key Hex */
+  group_key?: string;
+};
+
+/** Asset amount from an RPC asset amount
+
+  {
+    amount: <Asset Units Numeric String>
+    asset_id: <Asset Id Buffer Object>
+    group_key: <Asset Group Key Buffer Object>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    amount: <Asset Units Numeric String>
+    asset_id: <Asset Id Hex String>
+    [group_key]: <Asset Group Key Hex String>
+  }
+*/
+export default (assetAmount?: RpcAssetAmount | null): AssetAmount => {
+  if (!assetAmount) {
+    throw new Error('ExpectedRpcAssetAmountDetails');
+  }
+
+  if (!isNumeric(assetAmount.amount)) {
+    throw new Error('ExpectedAmountInRpcAssetAmount');
+  }
+
+  if (!isBuffer(assetAmount.asset_id) || !assetAmount.asset_id.length) {
+    throw new Error('ExpectedAssetIdInRpcAssetAmount');
+  }
+
+  return {
+    amount: assetAmount.amount,
+    asset_id: assetAmount.asset_id.toString('hex'),
+    group_key: hexOf(assetAmount.group_key),
+  };
+};

package/src/tapd_responses/rpc_asset_as_asset.ts

@@ -0,0 +1,299 @@
+import outpointAsTransaction from './outpoint_as_transaction.js';
+
+const assetVersions = ['ASSET_VERSION_V0', 'ASSET_VERSION_V1'];
+const dateFrom = (n: string) => new Date(Number(n) * 1e3).toISOString();
+const hexOf = (n?: Buffer | null) =>
+  !n?.length ? undefined : n.toString('hex');
+const isBuffer = (n: unknown): n is Buffer => Buffer.isBuffer(n);
+const isNumeric = (n: unknown) => typeof n === 'string' && /^\d+$/.test(n);
+const scriptKeyTypes: Record<string, string> = {
+  SCRIPT_KEY_BIP86: 'bip86',
+  SCRIPT_KEY_BURN: 'burn',
+  SCRIPT_KEY_CHANNEL: 'channel',
+  SCRIPT_KEY_SCRIPT_PATH_EXTERNAL: 'script_path_external',
+  SCRIPT_KEY_TOMBSTONE: 'tombstone',
+  SCRIPT_KEY_UNIQUE_PEDERSEN: 'unique_pedersen',
+  SCRIPT_KEY_UNKNOWN: 'unknown',
+};
+const zero = '0';
+
+export type RpcAsset = {
+  amount: string;
+  asset_genesis: {
+    asset_id: Buffer;
+    asset_type: string;
+    genesis_point: string;
+    meta_hash: Buffer;
+    name: string;
+    output_index: number;
+  } | null;
+  asset_group: {
+    asset_witness: Buffer;
+    raw_group_key: Buffer;
+    tapscript_root: Buffer;
+    tweaked_group_key: Buffer;
+  } | null;
+  chain_anchor: {
+    anchor_block_hash: string;
+    anchor_outpoint: string;
+    anchor_tx: Buffer;
+    block_height: number;
+    block_timestamp: string;
+    internal_key: Buffer;
+    merkle_root: Buffer;
+    tapscript_sibling: Buffer;
+  } | null;
+  decimal_display: {decimal_display: number} | null;
+  is_burn: boolean;
+  is_spent: boolean;
+  lease_expiry: string;
+  lease_owner: Buffer;
+  lock_time: number;
+  relative_lock_time: number;
+  script_key: Buffer;
+  script_key_is_local: boolean;
+  script_key_type: string;
+  script_version: number;
+  version: string;
+};
+
+export type Asset = {
+  /** Asset Units Numeric String */
+  amount: string;
+  anchor?: {
+    /** Anchor Block Hash Hex */
+    block_hash?: string;
+    /** Anchor Block Height */
+    block_height?: number;
+    /** Anchor Confirmed At ISO 8601 Date */
+    confirmed_at?: string;
+    /** Anchor Internal Key Hex */
+    internal_key: string;
+    /** Anchor Taproot Merkle Root Hex */
+    merkle_root: string;
+    /** Tapscript Sibling Preimage Hex */
+    tapscript_sibling?: string;
+    /** Raw Anchor Transaction Hex */
+    transaction: string;
+    /** Anchor Transaction Id Hex */
+    transaction_id: string;
+    /** Anchor Transaction Output Index */
+    transaction_vout: number;
+  };
+  /** Asset Id Hex */
+  asset_id: string;
+  /** Decimal Places To Show */
+  decimal_display?: number;
+  /** Genesis Commitment Output Index */
+  genesis_output_index: number;
+  /** Genesis Point Transaction Id Hex */
+  genesis_transaction_id: string;
+  /** Genesis Point Transaction Output Index */
+  genesis_transaction_vout: number;
+  group?: {
+    /** Tweaked Group Key Hex */
+    key: string;
+    /** Raw Group Key Hex */
+    raw_key: string;
+    /** Group Tapscript Root Hex */
+    tapscript_root?: string;
+    /** Group Membership Witness Hex */
+    witness?: string;
+  };
+  /** Asset Is Burned */
+  is_burn: boolean;
+  /** Asset Is Collectible */
+  is_collectible: boolean;
+  /** Script Key Belongs To This Node */
+  is_local: boolean;
+  /** Asset Is Spent */
+  is_spent: boolean;
+  /** Lease Expires At ISO 8601 Date */
+  lease_expires_at?: string;
+  /** Lease Owner Id Hex */
+  lease_owner?: string;
+  /** Lock Time */
+  lock_time?: number;
+  /** Asset Metadata Hash Hex */
+  meta_hash: string;
+  /** Asset Name */
+  name: string;
+  /** Relative Lock Time */
+  relative_lock_time?: number;
+  /** Script Key Hex */
+  script_key: string;
+  /** Script Key Type */
+  script_key_type: string;
+  /** Script Version */
+  script_version: number;
+  /** Asset Version */
+  version: number;
+};
+
+/** Asset from an RPC asset
+
+  {
+    amount: <Asset Units Numeric String>
+    asset_genesis: {
+      asset_id: <Asset Id Buffer Object>
+      asset_type: <Asset Type String>
+      genesis_point: <Genesis Outpoint String>
+      meta_hash: <Metadata Hash Buffer Object>
+      name: <Asset Name String>
+      output_index: <Genesis Commitment Output Index Number>
+    }
+    [asset_group]: {
+      asset_witness: <Group Membership Witness Buffer Object>
+      raw_group_key: <Raw Group Key Buffer Object>
+      tapscript_root: <Group Tapscript Root Buffer Object>
+      tweaked_group_key: <Tweaked Group Key Buffer Object>
+    }
+    [chain_anchor]: {
+      anchor_block_hash: <Anchor Block Hash Hex String>
+      anchor_outpoint: <Anchor Outpoint String>
+      anchor_tx: <Raw Anchor Transaction Buffer Object>
+      block_height: <Anchor Block Height Number>
+      block_timestamp: <Anchor Block Unix Seconds Numeric String>
+      internal_key: <Anchor Internal Key Buffer Object>
+      merkle_root: <Anchor Taproot Merkle Root Buffer Object>
+      tapscript_sibling: <Tapscript Sibling Preimage Buffer Object>
+    }
+    [decimal_display]: {
+      decimal_display: <Decimal Places To Show Number>
+    }
+    is_burn: <Asset Is Burned Bool>
+    is_spent: <Asset Is Spent Bool>
+    lease_expiry: <Lease Expires At Unix Seconds Numeric String>
+    lease_owner: <Lease Owner Id Buffer Object>
+    lock_time: <Lock Time Number>
+    relative_lock_time: <Relative Lock Time Number>
+    script_key: <Script Key Buffer Object>
+    script_key_is_local: <Script Key Belongs To This Node Bool>
+    script_key_type: <Script Key Type String>
+    script_version: <Script Version Number>
+    version: <Asset Version String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    amount: <Asset Units Numeric String>
+    [anchor]: {
+      [block_hash]: <Anchor Block Hash Hex String>
+      [block_height]: <Anchor Block Height Number>
+      [confirmed_at]: <Anchor Confirmed At ISO 8601 Date String>
+      internal_key: <Anchor Internal Key Hex String>
+      merkle_root: <Anchor Taproot Merkle Root Hex String>
+      [tapscript_sibling]: <Tapscript Sibling Preimage Hex String>
+      transaction: <Raw Anchor Transaction Hex String>
+      transaction_id: <Anchor Transaction Id Hex String>
+      transaction_vout: <Anchor Transaction Output Index Number>
+    }
+    asset_id: <Asset Id Hex String>
+    [decimal_display]: <Decimal Places To Show Number>
+    genesis_output_index: <Genesis Commitment Output Index Number>
+    genesis_transaction_id: <Genesis Point Transaction Id Hex String>
+    genesis_transaction_vout: <Genesis Point Transaction Output Index Number>
+    [group]: {
+      key: <Tweaked Group Key Hex String>
+      raw_key: <Raw Group Key Hex String>
+      [tapscript_root]: <Group Tapscript Root Hex String>
+      [witness]: <Group Membership Witness Hex String>
+    }
+    is_burn: <Asset Is Burned Bool>
+    is_collectible: <Asset Is Collectible Bool>
+    is_local: <Script Key Belongs To This Node Bool>
+    is_spent: <Asset Is Spent Bool>
+    [lease_expires_at]: <Lease Expires At ISO 8601 Date String>
+    [lease_owner]: <Lease Owner Id Hex String>
+    [lock_time]: <Lock Time Number>
+    meta_hash: <Asset Metadata Hash Hex String>
+    name: <Asset Name String>
+    [relative_lock_time]: <Relative Lock Time Number>
+    script_key: <Script Key Hex String>
+    script_key_type: <Script Key Type String>
+    script_version: <Script Version Number>
+    version: <Asset Version Number>
+  }
+*/
+export default (asset?: RpcAsset | null): Asset => {
+  if (!asset) {
+    throw new Error('ExpectedRpcAssetDetails');
+  }
+
+  if (!isNumeric(asset.amount)) {
+    throw new Error('ExpectedAmountInRpcAsset');
+  }
+
+  const genesis = asset.asset_genesis;
+
+  if (!genesis || !isBuffer(genesis.asset_id) || !genesis.asset_id.length) {
+    throw new Error('ExpectedAssetGenesisInRpcAsset');
+  }
+
+  if (!isBuffer(genesis.meta_hash)) {
+    throw new Error('ExpectedMetaHashInRpcAssetGenesis');
+  }
+
+  if (!isBuffer(asset.script_key)) {
+    throw new Error('ExpectedScriptKeyInRpcAsset');
+  }
+
+  if (assetVersions.indexOf(asset.version) === -1) {
+    throw new Error('ExpectedKnownVersionInRpcAsset');
+  }
+
+  const anchor = asset.chain_anchor;
+  const genesisPoint = outpointAsTransaction(genesis.genesis_point);
+  const group = asset.asset_group;
+  const hasLease = !!asset.lease_owner?.length;
+
+  return {
+    amount: asset.amount,
+    anchor: !anchor
+      ? undefined
+      : {
+          block_hash: anchor.anchor_block_hash || undefined,
+          block_height: anchor.block_height || undefined,
+          confirmed_at:
+            !!anchor.block_timestamp && anchor.block_timestamp !== zero
+              ? dateFrom(anchor.block_timestamp)
+              : undefined,
+          internal_key: anchor.internal_key.toString('hex'),
+          merkle_root: anchor.merkle_root.toString('hex'),
+          tapscript_sibling: hexOf(anchor.tapscript_sibling),
+          transaction: anchor.anchor_tx.toString('hex'),
+          ...outpointAsTransaction(anchor.anchor_outpoint),
+        },
+    asset_id: genesis.asset_id.toString('hex'),
+    decimal_display: asset.decimal_display?.decimal_display || undefined,
+    genesis_output_index: genesis.output_index,
+    genesis_transaction_id: genesisPoint.transaction_id,
+    genesis_transaction_vout: genesisPoint.transaction_vout,
+    group:
+      !group || !group.tweaked_group_key?.length
+        ? undefined
+        : {
+            key: group.tweaked_group_key.toString('hex'),
+            raw_key: group.raw_group_key.toString('hex'),
+            tapscript_root: hexOf(group.tapscript_root),
+            witness: hexOf(group.asset_witness),
+          },
+    is_burn: asset.is_burn,
+    is_collectible: genesis.asset_type === 'COLLECTIBLE',
+    is_local: asset.script_key_is_local,
+    is_spent: asset.is_spent,
+    lease_expires_at: hasLease ? dateFrom(asset.lease_expiry) : undefined,
+    lease_owner: hasLease ? asset.lease_owner.toString('hex') : undefined,
+    lock_time: asset.lock_time || undefined,
+    meta_hash: genesis.meta_hash.toString('hex'),
+    name: genesis.name,
+    relative_lock_time: asset.relative_lock_time || undefined,
+    script_key: asset.script_key.toString('hex'),
+    script_key_type: scriptKeyTypes[asset.script_key_type] || 'unknown',
+    script_version: asset.script_version,
+    version: assetVersions.indexOf(asset.version),
+  };
+};

package/src/tapd_responses/rpc_asset_balance_as_balance.ts

@@ -0,0 +1,85 @@
+const hexOf = (n?: Buffer | null) =>
+  !n?.length ? undefined : n.toString('hex');
+const isBuffer = (n: unknown): n is Buffer => Buffer.isBuffer(n);
+const isNumeric = (n: unknown) => typeof n === 'string' && /^\d+$/.test(n);
+
+export type RpcAssetBalance = {
+  asset_genesis: {
+    asset_id: Buffer;
+    asset_type: string;
+    meta_hash: Buffer;
+    name: string;
+  } | null;
+  balance: string;
+  group_key: Buffer;
+};
+
+export type Balance = {
+  /** Asset Id Hex */
+  asset_id: string;
+  /** Balance Asset Units Numeric String */
+  balance: string;
+  /** Asset Group Key Hex */
+  group_key?: string;
+  /** Asset Is Collectible */
+  is_collectible: boolean;
+  /** Asset Metadata Hash Hex */
+  meta_hash: string;
+  /** Asset Name */
+  name: string;
+};
+
+/** Balance from an RPC asset balance
+
+  {
+    asset_genesis: {
+      asset_id: <Asset Id Buffer Object>
+      asset_type: <Asset Type String>
+      meta_hash: <Asset Metadata Hash Buffer Object>
+      name: <Asset Name String>
+    }
+    balance: <Balance Asset Units Numeric String>
+    group_key: <Asset Group Key Buffer Object>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    asset_id: <Asset Id Hex String>
+    balance: <Balance Asset Units Numeric String>
+    [group_key]: <Asset Group Key Hex String>
+    is_collectible: <Asset Is Collectible Bool>
+    meta_hash: <Asset Metadata Hash Hex String>
+    name: <Asset Name String>
+  }
+*/
+export default (balance?: RpcAssetBalance | null): Balance => {
+  if (!balance) {
+    throw new Error('ExpectedRpcAssetBalanceDetails');
+  }
+
+  if (!isNumeric(balance.balance)) {
+    throw new Error('ExpectedBalanceInRpcAssetBalance');
+  }
+
+  const genesis = balance.asset_genesis;
+
+  if (!genesis || !isBuffer(genesis.asset_id) || !genesis.asset_id.length) {
+    throw new Error('ExpectedAssetGenesisInRpcAssetBalance');
+  }
+
+  if (!isBuffer(genesis.meta_hash)) {
+    throw new Error('ExpectedMetaHashInRpcAssetBalance');
+  }
+
+  return {
+    asset_id: genesis.asset_id.toString('hex'),
+    balance: balance.balance,
+    group_key: hexOf(balance.group_key),
+    is_collectible: genesis.asset_type === 'COLLECTIBLE',
+    meta_hash: genesis.meta_hash.toString('hex'),
+    name: genesis.name,
+  };
+};