tapass 0.1.0 → 0.2.0

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,
+  };
+};

package/src/tapd_responses/rpc_asset_burn_as_burn.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);
+const txIdByteLength = 32;
+
+export type RpcAssetBurn = {
+  amount: string;
+  anchor_txid: Buffer;
+  asset_id: Buffer;
+  asset_type: string;
+  note: string;
+  tweaked_group_key: Buffer;
+};
+
+export type Burn = {
+  /** Burned Asset Units Numeric String */
+  amount: string;
+  /** Asset Id Hex */
+  asset_id: string;
+  /** Asset Group Key Hex */
+  group_key?: string;
+  /** Asset Is Collectible */
+  is_collectible: boolean;
+  /** Burn Note */
+  note?: string;
+  /** Burn Anchor Transaction Id Hex */
+  transaction_id: string;
+};
+
+/** Burn from an RPC asset burn
+
+  tapd sends the anchor transaction id in internal byte order
+
+  {
+    amount: <Burned Asset Units Numeric String>
+    anchor_txid: <Anchor Transaction Id Internal Byte Order Buffer Object>
+    asset_id: <Asset Id Buffer Object>
+    asset_type: <Asset Type String>
+    note: <Burn Note String>
+    tweaked_group_key: <Asset Group Key Buffer Object>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    amount: <Burned Asset Units Numeric String>
+    asset_id: <Asset Id Hex String>
+    [group_key]: <Asset Group Key Hex String>
+    is_collectible: <Asset Is Collectible Bool>
+    [note]: <Burn Note String>
+    transaction_id: <Burn Anchor Transaction Id Hex String>
+  }
+*/
+export default (burn?: RpcAssetBurn | null): Burn => {
+  if (!burn) {
+    throw new Error('ExpectedRpcAssetBurnDetails');
+  }
+
+  if (!isNumeric(burn.amount)) {
+    throw new Error('ExpectedAmountInRpcAssetBurn');
+  }
+
+  if (
+    !isBuffer(burn.anchor_txid) ||
+    burn.anchor_txid.length !== txIdByteLength
+  ) {
+    throw new Error('ExpectedAnchorTransactionIdInRpcAssetBurn');
+  }
+
+  if (!isBuffer(burn.asset_id) || !burn.asset_id.length) {
+    throw new Error('ExpectedAssetIdInRpcAssetBurn');
+  }
+
+  return {
+    amount: burn.amount,
+    asset_id: burn.asset_id.toString('hex'),
+    group_key: hexOf(burn.tweaked_group_key),
+    is_collectible: burn.asset_type === 'COLLECTIBLE',
+    note: burn.note || undefined,
+    transaction_id: Buffer.from(burn.anchor_txid).reverse().toString('hex'),
+  };
+};

package/src/tapd_responses/rpc_asset_invoice_as_invoice.ts

@@ -0,0 +1,62 @@
+import type {GetInvoicesResult} from 'lightning';
+import {rpcInvoiceAsInvoice} from 'lightning/lnd_responses/index.js';
+
+import rpcAssetAmountAsAmount from './rpc_asset_amount_as_amount.js';
+import type {AssetAmount} from './rpc_asset_amount_as_amount.js';
+import type {RpcAssetAmount} from './rpc_asset_amount_as_amount.js';
+
+const {isArray} = Array;
+
+export type RpcAssetInvoice = {
+  asset_amounts: RpcAssetAmount[];
+  invoice: unknown;
+};
+
+export type AssetInvoice = GetInvoicesResult['invoices'][number] & {
+  assets: AssetAmount[];
+};
+
+/** Asset invoice from an RPC asset invoice
+
+  The lnd invoice maps with rpcInvoiceAsInvoice from lightning
+
+  {
+    asset_amounts: [{
+      amount: <Asset Units Numeric String>
+      asset_id: <Asset Id Buffer Object>
+      group_key: <Asset Group Key Buffer Object>
+    }]
+    invoice: <RPC lnd Invoice Object>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    assets: [{
+      amount: <Asset Units Numeric String>
+      asset_id: <Asset Id Hex String>
+      [group_key]: <Asset Group Key Hex String>
+    }]
+    ...<lightning Invoice Object>
+  }
+*/
+export default (assetInvoice?: RpcAssetInvoice | null): AssetInvoice => {
+  if (!assetInvoice) {
+    throw new Error('ExpectedRpcAssetInvoiceDetails');
+  }
+
+  if (!isArray(assetInvoice.asset_amounts)) {
+    throw new Error('ExpectedAssetAmountsInRpcAssetInvoice');
+  }
+
+  if (!assetInvoice.invoice) {
+    throw new Error('ExpectedInvoiceInRpcAssetInvoice');
+  }
+
+  return {
+    ...rpcInvoiceAsInvoice(assetInvoice.invoice),
+    assets: assetInvoice.asset_amounts.map(rpcAssetAmountAsAmount),
+  };
+};