tapass 0.1.0 → 0.2.0

package/src/tapd_responses/rpc_asset_meta_as_metadata.ts

@@ -0,0 +1,113 @@
+const hexOf = (n?: Buffer | null) =>
+  !n?.length ? undefined : n.toString('hex');
+const {isArray} = Array;
+const isBuffer = (n: unknown): n is Buffer => Buffer.isBuffer(n);
+const {entries} = Object;
+const types: Record<string, Metadata['type']> = {
+  META_TYPE_JSON: 'json',
+  META_TYPE_OPAQUE: 'opaque',
+};
+
+export type RpcAssetMeta = {
+  canonical_universe_urls: string[];
+  data: Buffer;
+  decimal_display: number;
+  delegation_key: Buffer;
+  meta_hash: Buffer;
+  type: string;
+  universe_commitments: boolean;
+  unknown_odd_types: Record<string, Buffer>;
+};
+
+export type Metadata = {
+  /** Canonical Universe URLs */
+  canonical_universes: string[];
+  /** Metadata Hex */
+  data: string;
+  /** Decimal Places To Show */
+  decimal_display?: number;
+  /** Supply Commitment Delegation Public Key Hex */
+  delegation_key?: string;
+  /** Metadata Hash Hex */
+  hash: string;
+  /** Issuer Publishes Universe Supply Commitments */
+  is_publishing_supply_commitments: boolean;
+  /** Metadata Type */
+  type: 'json' | 'opaque' | 'unknown';
+  unknown_types: {
+    /** TLV Type Numeric String */
+    type: string;
+    /** Value Hex */
+    value: string;
+  }[];
+};
+
+/** Metadata from an RPC asset metadata response
+
+  {
+    canonical_universe_urls: [<Canonical Universe URL String>]
+    data: <Metadata Buffer Object>
+    decimal_display: <Decimal Places To Show Number>
+    delegation_key: <Supply Commitment Delegation Public Key Buffer Object>
+    meta_hash: <Metadata Hash Buffer Object>
+    type: <Metadata Type String>
+    universe_commitments: <Issuer Publishes Universe Supply Commitments Bool>
+    unknown_odd_types: {
+      <TLV Type Numeric String>: <Value Buffer Object>
+    }
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    canonical_universes: [<Canonical Universe URL String>]
+    data: <Metadata Hex String>
+    [decimal_display]: <Decimal Places To Show Number>
+    [delegation_key]: <Supply Commitment Delegation Public Key Hex String>
+    hash: <Metadata Hash Hex String>
+    is_publishing_supply_commitments: <Issuer Publishes Supply Commitments Bool>
+    type: <Metadata Type String> // json, opaque, unknown
+    unknown_types: [{
+      type: <TLV Type Numeric String>
+      value: <Value Hex String>
+    }]
+  }
+*/
+export default (meta?: RpcAssetMeta | null): Metadata => {
+  if (!meta) {
+    throw new Error('ExpectedRpcAssetMetaDetails');
+  }
+
+  if (!isBuffer(meta.data)) {
+    throw new Error('ExpectedDataInRpcAssetMeta');
+  }
+
+  if (!isBuffer(meta.meta_hash) || !meta.meta_hash.length) {
+    throw new Error('ExpectedMetaHashInRpcAssetMeta');
+  }
+
+  if (
+    !!meta.canonical_universe_urls &&
+    !isArray(meta.canonical_universe_urls)
+  ) {
+    throw new Error('ExpectedArrayOfUniverseUrlsInRpcAssetMeta');
+  }
+
+  return {
+    canonical_universes: meta.canonical_universe_urls || [],
+    data: meta.data.toString('hex'),
+    decimal_display: meta.decimal_display || undefined,
+    delegation_key: hexOf(meta.delegation_key),
+    hash: meta.meta_hash.toString('hex'),
+    is_publishing_supply_commitments: meta.universe_commitments,
+    type: types[meta.type] || 'unknown',
+    unknown_types: entries(meta.unknown_odd_types || {}).map(
+      ([type, value]) => ({
+        type,
+        value: value.toString('hex'),
+      }),
+    ),
+  };
+};

package/src/tapd_responses/rpc_asset_pay_req_as_request.ts

@@ -0,0 +1,114 @@
+import type {DecodePaymentRequestResult} from 'lightning';
+import {paymentRequestDetails} from 'lightning/lnd_responses/index.js';
+
+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 RpcAssetPayReq = {
+  asset_amount: string;
+  asset_group: {tweaked_group_key: Buffer} | null;
+  decimal_display: {decimal_display: number} | null;
+  genesis_info: {
+    asset_id: Buffer;
+    asset_type: string;
+    meta_hash: Buffer;
+    name: string;
+  } | null;
+  pay_req: unknown;
+};
+
+export type AssetPaymentRequest = DecodePaymentRequestResult & {
+  asset: {
+    /** Asset Units To Pay Numeric String */
+    amount: string;
+    /** Decimal Places To Show */
+    decimal_display?: number;
+    /** Asset Group Key Hex */
+    group_key?: string;
+    /** Asset Id Hex */
+    id: string;
+    /** Asset Is Collectible */
+    is_collectible: boolean;
+    /** Asset Metadata Hash Hex */
+    meta_hash: string;
+    /** Asset Name */
+    name: string;
+  };
+};
+
+/** Asset payment request details from an RPC asset pay req response
+
+  The lnd payment request maps with paymentRequestDetails from lightning
+
+  {
+    asset_amount: <Asset Units To Pay Numeric String>
+    [asset_group]: {
+      tweaked_group_key: <Asset Group Key Buffer Object>
+    }
+    [decimal_display]: {
+      decimal_display: <Decimal Places To Show Number>
+    }
+    genesis_info: {
+      asset_id: <Asset Id Buffer Object>
+      asset_type: <Asset Type String>
+      meta_hash: <Asset Metadata Hash Buffer Object>
+      name: <Asset Name String>
+    }
+    pay_req: <RPC lnd PayReq Object>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    asset: {
+      amount: <Asset Units To Pay Numeric String>
+      [decimal_display]: <Decimal Places To Show Number>
+      [group_key]: <Asset Group Key Hex String>
+      id: <Asset Id Hex String>
+      is_collectible: <Asset Is Collectible Bool>
+      meta_hash: <Asset Metadata Hash Hex String>
+      name: <Asset Name String>
+    }
+    ...<lightning Decoded Payment Request Object>
+  }
+*/
+export default (res?: RpcAssetPayReq | null): AssetPaymentRequest => {
+  if (!res) {
+    throw new Error('ExpectedRpcAssetPayReqDetails');
+  }
+
+  if (!isNumeric(res.asset_amount)) {
+    throw new Error('ExpectedAssetAmountInRpcAssetPayReq');
+  }
+
+  const genesis = res.genesis_info;
+
+  if (!genesis || !isBuffer(genesis.asset_id) || !genesis.asset_id.length) {
+    throw new Error('ExpectedGenesisInfoInRpcAssetPayReq');
+  }
+
+  if (!isBuffer(genesis.meta_hash)) {
+    throw new Error('ExpectedMetaHashInRpcAssetPayReq');
+  }
+
+  if (!res.pay_req) {
+    throw new Error('ExpectedPayReqInRpcAssetPayReq');
+  }
+
+  return {
+    ...paymentRequestDetails(res.pay_req),
+    asset: {
+      amount: res.asset_amount,
+      decimal_display: res.decimal_display?.decimal_display || undefined,
+      group_key: hexOf(res.asset_group?.tweaked_group_key),
+      id: genesis.asset_id.toString('hex'),
+      is_collectible: genesis.asset_type === 'COLLECTIBLE',
+      meta_hash: genesis.meta_hash.toString('hex'),
+      name: genesis.name,
+    },
+  };
+};

package/src/tapd_responses/rpc_asset_payment_as_payment.ts

@@ -0,0 +1,62 @@
+import type {GetPaymentsResult} from 'lightning';
+import {rpcPaymentAsPayment} 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 RpcAssetPayment = {
+  asset_amounts: RpcAssetAmount[];
+  payment: unknown;
+};
+
+export type AssetPayment = GetPaymentsResult['payments'][number] & {
+  assets: AssetAmount[];
+};
+
+/** Asset payment from an RPC asset payment
+
+  The lnd payment maps with rpcPaymentAsPayment from lightning
+
+  {
+    asset_amounts: [{
+      amount: <Asset Units Numeric String>
+      asset_id: <Asset Id Buffer Object>
+      group_key: <Asset Group Key Buffer Object>
+    }]
+    payment: <RPC lnd Payment Object>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    assets: [{
+      amount: <Asset Units Numeric String>
+      asset_id: <Asset Id Hex String>
+      [group_key]: <Asset Group Key Hex String>
+    }]
+    ...<lightning Payment Object>
+  }
+*/
+export default (assetPayment?: RpcAssetPayment | null): AssetPayment => {
+  if (!assetPayment) {
+    throw new Error('ExpectedRpcAssetPaymentDetails');
+  }
+
+  if (!isArray(assetPayment.asset_amounts)) {
+    throw new Error('ExpectedAssetAmountsInRpcAssetPayment');
+  }
+
+  if (!assetPayment.payment) {
+    throw new Error('ExpectedPaymentInRpcAssetPayment');
+  }
+
+  return {
+    ...rpcPaymentAsPayment(assetPayment.payment),
+    assets: assetPayment.asset_amounts.map(rpcAssetAmountAsAmount),
+  };
+};

package/src/tapd_responses/rpc_batch_as_batch.ts

@@ -0,0 +1,281 @@
+import states from './batch_states.js';
+
+const assetVersions = ['ASSET_VERSION_V0', 'ASSET_VERSION_V1'];
+const base64AsHex = (n: string) => Buffer.from(n, 'base64').toString('hex');
+const dateFrom = (n: string) => new Date(Number(n) * 1e3).toISOString();
+const hexOf = (n?: Buffer | null) =>
+  !n?.length ? undefined : n.toString('hex');
+const {isArray} = Array;
+const isBuffer = (n: unknown): n is Buffer => Buffer.isBuffer(n);
+const isNumeric = (n: unknown) => typeof n === 'string' && /^\d+$/.test(n);
+const metaTypes: Record<string, string> = {
+  META_TYPE_JSON: 'json',
+  META_TYPE_OPAQUE: 'opaque',
+};
+
+type RpcPendingAsset = {
+  amount: string;
+  asset_meta: {data: Buffer; meta_hash: Buffer; type: string} | null;
+  asset_type: string;
+  asset_version: string;
+  group_anchor: string;
+  group_internal_key: {raw_key_bytes: Buffer} | null;
+  group_key: Buffer;
+  group_tapscript_root: Buffer;
+  name: string;
+  new_grouped_asset: boolean;
+  script_key: {pub_key: Buffer} | null;
+};
+
+export type RpcMintingBatch = {
+  assets: RpcPendingAsset[];
+  batch_key: Buffer;
+  batch_psbt: Buffer;
+  batch_txid: string;
+  created_at: string;
+  height_hint: number;
+  state: string;
+};
+
+export type RpcVerboseBatch = {
+  batch: RpcMintingBatch | null;
+  unsealed_assets?: {
+    asset: RpcPendingAsset | null;
+    group_virtual_psbt: string;
+    group_virtual_tx: {transaction: Buffer} | null;
+  }[];
+};
+
+export type PendingAsset = {
+  /** Asset Units Numeric String */
+  amount: string;
+  /** Name of the Asset That Anchors a New Group */
+  group_anchor?: string;
+  /** Group Internal Public Key Hex */
+  group_internal_key?: string;
+  /** Group Key Hex */
+  group_key?: string;
+  /** Group Tapscript Root Hex */
+  group_tapscript_root?: string;
+  /** Asset Is Collectible */
+  is_collectible: boolean;
+  /** Asset Starts a New Group */
+  is_new_group: boolean;
+  /** Metadata Hex */
+  metadata?: string;
+  /** Metadata Hash Hex */
+  metadata_hash?: string;
+  /** Metadata Type */
+  metadata_type?: string;
+  /** Asset Name */
+  name: string;
+  /** Script Key Hex */
+  script_key?: string;
+  /** Asset Version */
+  version: number;
+};
+
+export type Batch = {
+  assets: PendingAsset[];
+  /** Created At ISO 8601 Date */
+  created_at: string;
+  /** Block Height When Created */
+  created_height: number;
+  /** Batch Key Hex */
+  id: string;
+  /** Genesis Transaction PSBT Hex */
+  psbt?: string;
+  /** Batch State */
+  state: string;
+  /** Genesis Transaction Id Hex */
+  transaction_id?: string;
+  unsealed_assets: (PendingAsset & {
+    /** Group Virtual Transaction PSBT Hex */
+    group_virtual_psbt?: string;
+    /** Group Virtual Transaction Hex */
+    group_virtual_transaction?: string;
+  })[];
+};
+
+/** Pending asset from an RPC pending asset
+
+  {
+    amount: <Asset Units Numeric String>
+    [asset_meta]: {
+      data: <Metadata Buffer Object>
+      meta_hash: <Metadata Hash Buffer Object>
+      type: <Metadata Type String>
+    }
+    asset_type: <Asset Type String>
+    asset_version: <Asset Version String>
+    group_anchor: <Name of the Asset That Anchors a New Group String>
+    [group_internal_key]: {
+      raw_key_bytes: <Group Internal Public Key Buffer Object>
+    }
+    group_key: <Group Key Buffer Object>
+    group_tapscript_root: <Group Tapscript Root Buffer Object>
+    name: <Asset Name String>
+    new_grouped_asset: <Asset Starts a New Group Bool>
+    [script_key]: {
+      pub_key: <Script Key Buffer Object>
+    }
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  <Pending Asset Object>
+*/
+const pendingAsset = (asset?: RpcPendingAsset | null): PendingAsset => {
+  if (!asset) {
+    throw new Error('ExpectedPendingAssetInRpcMintingBatch');
+  }
+
+  if (!asset.name) {
+    throw new Error('ExpectedAssetNameInRpcPendingAsset');
+  }
+
+  if (!isNumeric(asset.amount)) {
+    throw new Error('ExpectedAmountInRpcPendingAsset');
+  }
+
+  if (assetVersions.indexOf(asset.asset_version) === -1) {
+    throw new Error('ExpectedKnownVersionInRpcPendingAsset');
+  }
+
+  if (!isBuffer(asset.group_key) || !isBuffer(asset.group_tapscript_root)) {
+    throw new Error('ExpectedGroupDetailsInRpcPendingAsset');
+  }
+
+  const meta = asset.asset_meta;
+
+  return {
+    amount: asset.amount,
+    group_anchor: asset.group_anchor || undefined,
+    group_internal_key: hexOf(asset.group_internal_key?.raw_key_bytes),
+    group_key: hexOf(asset.group_key),
+    group_tapscript_root: hexOf(asset.group_tapscript_root),
+    is_collectible: asset.asset_type === 'COLLECTIBLE',
+    is_new_group: asset.new_grouped_asset,
+    metadata: hexOf(meta?.data),
+    metadata_hash: hexOf(meta?.meta_hash),
+    metadata_type: !meta ? undefined : metaTypes[meta.type] || 'unknown',
+    name: asset.name,
+    script_key: hexOf(asset.script_key?.pub_key),
+    version: assetVersions.indexOf(asset.asset_version),
+  };
+};
+
+/** Batch from an RPC minting batch, with the unsealed assets if present
+
+  {
+    batch: {
+      assets: [<RPC Pending Asset Object>]
+      batch_key: <Batch Key Buffer Object>
+      batch_psbt: <Genesis Transaction PSBT Buffer Object>
+      batch_txid: <Genesis Transaction Id Hex String>
+      created_at: <Created At Unix Seconds Numeric String>
+      height_hint: <Block Height When Created Number>
+      state: <Batch State String>
+    }
+    [unsealed_assets]: [{
+      asset: <RPC Pending Asset Object>
+      group_virtual_psbt: <Group Virtual Transaction PSBT Base64 String>
+      [group_virtual_tx]: {
+        transaction: <Group Virtual Transaction Buffer Object>
+      }
+    }]
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    assets: [{
+      amount: <Asset Units Numeric String>
+      [group_anchor]: <Name of the Asset That Anchors a New Group String>
+      [group_internal_key]: <Group Internal Public Key Hex String>
+      [group_key]: <Group Key Hex String>
+      [group_tapscript_root]: <Group Tapscript Root Hex String>
+      is_collectible: <Asset Is Collectible Bool>
+      is_new_group: <Asset Starts a New Group Bool>
+      [metadata]: <Metadata Hex String>
+      [metadata_hash]: <Metadata Hash Hex String>
+      [metadata_type]: <Metadata Type String> // json, opaque
+      name: <Asset Name String>
+      [script_key]: <Script Key Hex String>
+      version: <Asset Version Number>
+    }]
+    created_at: <Created At ISO 8601 Date String>
+    created_height: <Block Height When Created Number>
+    id: <Batch Key Hex String>
+    [psbt]: <Genesis Transaction PSBT Hex String>
+    state: <Batch State String>
+    [transaction_id]: <Genesis Transaction Id Hex String>
+    unsealed_assets: [{
+      amount: <Asset Units Numeric String>
+      [group_anchor]: <Name of the Asset That Anchors a New Group String>
+      [group_internal_key]: <Group Internal Public Key Hex String>
+      [group_key]: <Group Key Hex String>
+      [group_tapscript_root]: <Group Tapscript Root Hex String>
+      [group_virtual_psbt]: <Group Virtual Transaction PSBT Hex String>
+      [group_virtual_transaction]: <Group Virtual Transaction Hex String>
+      is_collectible: <Asset Is Collectible Bool>
+      is_new_group: <Asset Starts a New Group Bool>
+      [metadata]: <Metadata Hex String>
+      [metadata_hash]: <Metadata Hash Hex String>
+      [metadata_type]: <Metadata Type String> // json, opaque
+      name: <Asset Name String>
+      [script_key]: <Script Key Hex String>
+      version: <Asset Version Number>
+    }]
+  }
+*/
+export default ({batch, unsealed_assets}: RpcVerboseBatch): Batch => {
+  if (!batch) {
+    throw new Error('ExpectedRpcMintingBatch');
+  }
+
+  if (!isArray(batch.assets)) {
+    throw new Error('ExpectedArrayOfAssetsInRpcMintingBatch');
+  }
+
+  if (!isBuffer(batch.batch_key) || !batch.batch_key.length) {
+    throw new Error('ExpectedBatchKeyInRpcMintingBatch');
+  }
+
+  if (!isBuffer(batch.batch_psbt)) {
+    throw new Error('ExpectedBatchPsbtInRpcMintingBatch');
+  }
+
+  if (!isNumeric(batch.created_at)) {
+    throw new Error('ExpectedCreatedAtInRpcMintingBatch');
+  }
+
+  if (!states[batch.state]) {
+    throw new Error('ExpectedKnownStateInRpcMintingBatch');
+  }
+
+  if (!!unsealed_assets && !isArray(unsealed_assets)) {
+    throw new Error('ExpectedArrayOfUnsealedAssetsInRpcVerboseBatch');
+  }
+
+  return {
+    assets: batch.assets.map(pendingAsset),
+    created_at: dateFrom(batch.created_at),
+    created_height: batch.height_hint,
+    id: batch.batch_key.toString('hex'),
+    psbt: hexOf(batch.batch_psbt),
+    state: states[batch.state],
+    transaction_id: batch.batch_txid || undefined,
+    unsealed_assets: (unsealed_assets || []).map(unsealed => ({
+      ...pendingAsset(unsealed.asset),
+      group_virtual_psbt: !unsealed.group_virtual_psbt
+        ? undefined
+        : base64AsHex(unsealed.group_virtual_psbt),
+      group_virtual_transaction: hexOf(unsealed.group_virtual_tx?.transaction),
+    })),
+  };
+};

package/src/tapd_responses/rpc_buy_quote_as_quote.ts

@@ -0,0 +1,139 @@
+import fixedPointAsDecimal from './fixed_point_as_decimal.js';
+import type {RpcFixedPoint} from './fixed_point_as_decimal.js';
+import shortChannelIdAsChannel from './short_channel_id_as_channel.js';
+
+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 isPublicKey = (n: unknown) => /^0[23][0-9a-f]{64}$/i.test(String(n));
+const zero = '0';
+
+export type RpcAssetSpec = {
+  group_pub_key: Buffer;
+  id: Buffer;
+} | null;
+
+export type RpcBuyQuote = {
+  accepted_max_amount: string;
+  ask_asset_rate: RpcFixedPoint | null;
+  asset_max_amount: string;
+  asset_spec: RpcAssetSpec;
+  expiry: string;
+  id: Buffer;
+  min_transportable_units: string;
+  peer: string;
+  price_oracle_metadata: string;
+  scid: string;
+};
+
+export type BuyQuote = {
+  /** Accepted Maximum Asset Units Numeric String */
+  accepted_max_amount?: string;
+  /** Asset Id Hex */
+  asset_id?: string;
+  /** Channel To Pay Over Standard Format Channel Id */
+  channel: string;
+  /** Quote Expires At ISO 8601 Date */
+  expires_at: string;
+  /** Asset Group BIP340 Public Key Hex */
+  group_key?: string;
+  /** Quote Request Id Hex */
+  id: string;
+  /** Maximum Asset Units Numeric String */
+  max_amount: string;
+  /** Minimum Asset Units In One HTLC Numeric String */
+  min_transportable_amount: string;
+  /** Peer Public Key Hex */
+  peer_public_key: string;
+  /** Price Oracle Metadata */
+  price_oracle_metadata?: string;
+  /** Ask Rate Asset Units Per BTC Exact Decimal String */
+  rate: string;
+};
+
+/** Buy quote from an RPC peer accepted buy quote
+
+  {
+    accepted_max_amount: <Accepted Maximum Asset Units Numeric String>
+    ask_asset_rate: {
+      coefficient: <Scaled Integer Numeric String>
+      scale: <Decimal Places Number>
+    }
+    asset_max_amount: <Maximum Asset Units Numeric String>
+    [asset_spec]: {
+      group_pub_key: <Asset Group BIP340 Public Key Buffer Object>
+      id: <Asset Id Buffer Object>
+    }
+    expiry: <Expires At Unix Seconds Numeric String>
+    id: <Quote Request Id Buffer Object>
+    min_transportable_units: <Minimum Asset Units In One HTLC Numeric String>
+    peer: <Peer Public Key Hex String>
+    price_oracle_metadata: <Price Oracle Metadata String>
+    scid: <Short Channel Id Numeric String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    [accepted_max_amount]: <Accepted Maximum Asset Units Numeric String>
+    [asset_id]: <Asset Id Hex String>
+    channel: <Channel To Pay Over Standard Format Channel Id String>
+    expires_at: <Quote Expires At ISO 8601 Date String>
+    [group_key]: <Asset Group BIP340 Public Key Hex String>
+    id: <Quote Request Id Hex String>
+    max_amount: <Maximum Asset Units Numeric String>
+    min_transportable_amount: <Minimum Asset Units In One HTLC Numeric String>
+    peer_public_key: <Peer Public Key Hex String>
+    [price_oracle_metadata]: <Price Oracle Metadata String>
+    rate: <Ask Rate Asset Units Per BTC Exact Decimal String>
+  }
+*/
+export default (quote?: RpcBuyQuote | null): BuyQuote => {
+  if (!quote) {
+    throw new Error('ExpectedRpcPeerAcceptedBuyQuote');
+  }
+
+  if (!isNumeric(quote.asset_max_amount)) {
+    throw new Error('ExpectedMaxAmountInRpcBuyQuote');
+  }
+
+  if (!isNumeric(quote.expiry)) {
+    throw new Error('ExpectedExpiryInRpcBuyQuote');
+  }
+
+  if (!isBuffer(quote.id) || !quote.id.length) {
+    throw new Error('ExpectedQuoteIdInRpcBuyQuote');
+  }
+
+  if (!isNumeric(quote.min_transportable_units)) {
+    throw new Error('ExpectedMinTransportableUnitsInRpcBuyQuote');
+  }
+
+  if (!isPublicKey(quote.peer)) {
+    throw new Error('ExpectedPeerPublicKeyInRpcBuyQuote');
+  }
+
+  if (!quote.ask_asset_rate) {
+    throw new Error('ExpectedAskAssetRateInRpcBuyQuote');
+  }
+
+  const accepted = quote.accepted_max_amount;
+
+  return {
+    accepted_max_amount: !!accepted && accepted !== zero ? accepted : undefined,
+    asset_id: hexOf(quote.asset_spec?.id),
+    channel: shortChannelIdAsChannel(quote.scid),
+    expires_at: dateFrom(quote.expiry),
+    group_key: hexOf(quote.asset_spec?.group_pub_key),
+    id: quote.id.toString('hex'),
+    max_amount: quote.asset_max_amount,
+    min_transportable_amount: quote.min_transportable_units,
+    peer_public_key: quote.peer,
+    price_oracle_metadata: quote.price_oracle_metadata || undefined,
+    rate: fixedPointAsDecimal(quote.ask_asset_rate),
+  };
+};