tapass 0.0.0-stage → 0.2.0

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

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