tapass 0.0.0-stage → 0.2.0

package/src/tapd_methods/send/register_asset_transfer.ts

@@ -0,0 +1,219 @@
+import {auto as asyncAuto} from 'async';
+import {returnResult} from 'asyncjs-util';
+
+import {isConnectionFailure} from '../../tapd_requests/index.js';
+import {isPermissionDenied} from '../../tapd_requests/index.js';
+import {isTapd} from '../../tapd_requests/index.js';
+import {rpcAssetAsAsset} from '../../tapd_responses/index.js';
+import type {Asset} from '../../tapd_responses/index.js';
+import type {AuthenticatedTapdArgs} from '../../typescript/index.js';
+import type {TapdCallback} from '../../typescript/index.js';
+import type {TapdError} from '../../typescript/index.js';
+import type {TapdMethod} from '../../typescript/index.js';
+
+const existsError = 'proof already exists for this transfer';
+const {from} = Buffer;
+const isAssetId = (n: string) => /^[0-9A-F]{64}$/i.test(n);
+const isPublicKey = (n: string) => /^0[23][0-9A-F]{64}$/i.test(n);
+const {isSafeInteger} = Number;
+const isTransactionId = (n: string) => /^[0-9A-F]{64}$/i.test(n);
+const method = 'registerTransfer';
+const proofNotFoundError = 'error fetching full proof';
+const scriptKeyNotFoundError = 'error fetching script key';
+const parseErrors = ['error parsing script key', 'error parsing group key'];
+const type = 'default';
+
+export type RegisterAssetTransferArgs = AuthenticatedTapdArgs<{
+  /** Asset Id Hex String */
+  asset_id: string;
+  /** Asset Group Key Hex String */
+  group_key?: string;
+  /** Script Key Hex String */
+  script_key: string;
+  /** Anchor Transaction Id Hex String */
+  transaction_id: string;
+  /** Anchor Transaction Output Index Number */
+  transaction_vout: number;
+}>;
+
+export type RegisterAssetTransferResult = Asset;
+
+type Tasks = {
+  register: RegisterAssetTransferResult;
+  validate: undefined;
+};
+
+/** Register an inbound asset transfer that has no Taproot Assets address
+
+  Use this for an interactive transfer, when the sender sent the proof by a
+  different way. The proof must already be in the local universe, and the
+  script key must already be known to this node.
+
+  Requires `assets:write` permission
+
+  {
+    asset_id: <Asset Id Hex String>
+    [group_key]: <Asset Group Key Hex String>
+    script_key: <Script Key Hex String>
+    tapd: <Authenticated tapd API Object>
+    transaction_id: <Anchor Transaction Id Hex String>
+    transaction_vout: <Anchor Transaction Output Index Number>
+  }
+
+  @returns via cbk or Promise
+  {
+    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>
+  }
+*/
+const registerAssetTransfer: TapdMethod<
+  RegisterAssetTransferArgs,
+  RegisterAssetTransferResult
+> = (
+  args: RegisterAssetTransferArgs,
+  cbk?: TapdCallback<RegisterAssetTransferResult>,
+) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto<Tasks, TapdError>(
+      {
+        // Check arguments
+        validate: cbk => {
+          if (!args.asset_id || !isAssetId(args.asset_id)) {
+            return cbk([400, 'ExpectedAssetIdToRegisterAssetTransfer']);
+          }
+
+          if (!!args.group_key && !isPublicKey(args.group_key)) {
+            return cbk([400, 'ExpectedGroupKeyHexToRegisterAssetTransfer']);
+          }
+
+          if (!args.script_key || !isPublicKey(args.script_key)) {
+            return cbk([400, 'ExpectedScriptKeyToRegisterAssetTransfer']);
+          }
+
+          if (!isTapd({method, type, tapd: args.tapd})) {
+            return cbk([
+              400,
+              'ExpectedAuthenticatedTapdToRegisterAssetTransfer',
+            ]);
+          }
+
+          if (!args.transaction_id || !isTransactionId(args.transaction_id)) {
+            return cbk([400, 'ExpectedTransactionIdToRegisterAssetTransfer']);
+          }
+
+          const vout = args.transaction_vout;
+
+          if (!isSafeInteger(vout) || vout < 0) {
+            return cbk([400, 'ExpectedOutputIndexToRegisterAssetTransfer']);
+          }
+
+          return cbk();
+        },
+
+        // Register the transfer
+        register: [
+          'validate',
+          ({}, cbk) => {
+            // tapd reads the outpoint transaction id in internal byte order
+            const request = {
+              asset_id: from(args.asset_id, 'hex'),
+              group_key: from(args.group_key || '', 'hex'),
+              outpoint: {
+                output_index: args.transaction_vout,
+                txid: from(args.transaction_id, 'hex').reverse(),
+              },
+              script_key: from(args.script_key, 'hex'),
+            };
+
+            return args.tapd[type][method](request, (err: any, res: any) => {
+              if (isConnectionFailure({err})) {
+                return cbk([
+                  503,
+                  'FailedToConnectToTapdToRegisterAssetTransfer',
+                ]);
+              }
+
+              if (isPermissionDenied({err})) {
+                return cbk([403, 'PermissionDeniedToRegisterAssetTransfer']);
+              }
+
+              const details = String(err?.details);
+
+              if (!!err && parseErrors.some(n => details.includes(n))) {
+                return cbk([400, 'ExpectedValidKeysToRegisterAssetTransfer']);
+              }
+
+              if (!!err && details.includes(scriptKeyNotFoundError)) {
+                return cbk([404, 'ScriptKeyNotFoundToRegisterAssetTransfer']);
+              }
+
+              if (!!err && details.includes(existsError)) {
+                return cbk([409, 'AssetTransferIsAlreadyRegistered']);
+              }
+
+              if (!!err && details.includes(proofNotFoundError)) {
+                return cbk([404, 'ProofNotFoundToRegisterAssetTransfer']);
+              }
+
+              if (!!err) {
+                return cbk([
+                  503,
+                  'UnexpectedErrorRegisteringAssetTransfer',
+                  {err},
+                ]);
+              }
+
+              if (!res) {
+                return cbk([503, 'ExpectedResponseToRegisterAssetTransfer']);
+              }
+
+              try {
+                return cbk(null, rpcAssetAsAsset(res.registered_asset));
+              } catch (err: any) {
+                return cbk([503, err.message]);
+              }
+            });
+          },
+        ],
+      },
+      returnResult({reject, resolve, of: 'register'}, cbk),
+    );
+  });
+};
+
+export default registerAssetTransfer;

package/src/tapd_methods/send/send_asset.ts

@@ -0,0 +1,223 @@
+import {auto as asyncAuto} from 'async';
+import {returnResult} from 'asyncjs-util';
+
+import {feeRateAsTokensPerKw} from '../../tapd_requests/index.js';
+import {isConnectionFailure} from '../../tapd_requests/index.js';
+import {isPermissionDenied} from '../../tapd_requests/index.js';
+import {isTapd} from '../../tapd_requests/index.js';
+import {rpcTransferAsTransfer} from '../../tapd_responses/index.js';
+import type {Transfer} from '../../tapd_responses/index.js';
+import type {AuthenticatedTapdArgs} from '../../typescript/index.js';
+import type {TapdCallback} from '../../typescript/index.js';
+import type {TapdError} from '../../typescript/index.js';
+import type {TapdMethod} from '../../typescript/index.js';
+
+const addressParseError = 'error parsing addresses';
+const feeRateErrors = [
+  'manual fee rate below floor',
+  'does not meet minrelayfee',
+];
+const insufficientError =
+  'failed to find coin(s) that satisfy given constraints';
+const {isArray} = Array;
+const isNumeric = (n: unknown) => typeof n === 'string' && /^\d+$/.test(n);
+const method = 'sendAsset';
+const type = 'default';
+
+export type SendAssetArgs = AuthenticatedTapdArgs<{
+  addresses: {
+    /** Taproot Assets Address String */
+    address: string;
+    /** Asset Units To Send Numeric String */
+    amount?: string;
+  }[];
+  /** Chain Fee Tokens Per Virtual Byte Number */
+  fee_tokens_per_vbyte?: number;
+  /** Skip the Proof Courier Ping Check Bool */
+  is_courier_ping_skipped?: boolean;
+  /** Transfer Label String */
+  label?: string;
+}>;
+
+export type SendAssetResult = Transfer;
+
+type Tasks = {
+  send: SendAssetResult;
+  validate: undefined;
+};
+
+/** Send assets to Taproot Assets addresses
+
+  Requires `assets:write` permission
+
+  All addresses must be for the same asset id or asset group
+
+  An `amount` is only for an address without an amount, for example a V2
+  address. When an address has an `amount`, tapd v0.8.0 or later is
+  necessary.
+
+  A fee rate below 253 tokens per thousand weight units (about 1.012 tokens
+  per virtual byte) is raised to 253, because tapd rejects a lower rate
+
+  {
+    addresses: [{
+      address: <Taproot Assets Address String>
+      [amount]: <Asset Units To Send Numeric String>
+    }]
+    [fee_tokens_per_vbyte]: <Chain Fee Tokens Per Virtual Byte Number>
+    [is_courier_ping_skipped]: <Skip the Proof Courier Ping Check Bool>
+    [label]: <Transfer Label String>
+    tapd: <Authenticated tapd API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    [block_hash]: <Anchor Block Hash Hex String>
+    [block_height]: <Anchor Block Height Number>
+    created_at: <Transfer Created At ISO 8601 Date String>
+    fee: <Anchor Transaction Chain Fee Tokens Number>
+    height_hint: <Anchor Transaction Confirmation Height Hint Number>
+    inputs: [{
+      amount: <Asset Units Numeric String>
+      asset_id: <Asset Id Hex String>
+      [group_key]: <Asset Group Key Hex String>
+      is_collectible: <Asset Is Collectible Bool>
+      script_key: <Script Key Hex String>
+      transaction_id: <Spent Anchor Transaction Id Hex String>
+      transaction_vout: <Spent Anchor Transaction Output Index Number>
+    }]
+    [label]: <Transfer Label String>
+    outputs: [{
+      [address]: <Taproot Assets Address Of the Recipient String>
+      amount: <Asset Units Numeric String>
+      anchor: {
+        internal_key: <Anchor Internal Key Hex String>
+        merkle_root: <Anchor Taproot Merkle Root Hex String>
+        output_script: <Output Script Hex String>
+        passive_assets_count: <Count Of Passive Assets In the Anchor Number>
+        taproot_asset_root: <Taproot Asset Root Commitment Hex String>
+        [tapscript_sibling]: <Tapscript Sibling Preimage Hex String>
+        tokens: <Anchor Output Tokens Number>
+        transaction_id: <Anchor Transaction Id Hex String>
+        transaction_vout: <Anchor Transaction Output Index Number>
+      }
+      [asset_id]: <Asset Id Hex String>
+      asset_version: <Asset Version Number>
+      [group_key]: <Asset Group Key Hex String>
+      is_collectible: <Asset Is Collectible Bool>
+      is_local: <Script Key Belongs To This Node Bool>
+      is_split_root: <Output Is the Split Root Bool>
+      [lock_time]: <Lock Time Number>
+      [proof]: <Proof File Hex String>
+      [proof_courier]: <Proof Courier Address String>
+      [proof_delivery]: <Proof Delivery State String> // complete, pending
+      [relative_lock_time]: <Relative Lock Time Number>
+      script_key: <Script Key Hex String>
+      [split_root_hash]: <Split Commitment Root Hash Hex String>
+    }]
+    [transaction]: <Raw Anchor Transaction Hex String>
+    transaction_id: <Anchor Transaction Id Hex String>
+  }
+*/
+const sendAsset: TapdMethod<SendAssetArgs, SendAssetResult> = (
+  args: SendAssetArgs,
+  cbk?: TapdCallback<SendAssetResult>,
+) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto<Tasks, TapdError>(
+      {
+        // Check arguments
+        validate: cbk => {
+          if (!isArray(args.addresses) || !args.addresses.length) {
+            return cbk([400, 'ExpectedAddressesToSendAsset']);
+          }
+
+          if (args.addresses.some(n => !n?.address)) {
+            return cbk([400, 'ExpectedAddressForEachSendAssetRecipient']);
+          }
+
+          const amounts = args.addresses.map(n => n.amount);
+
+          if (amounts.some(n => n !== undefined && !isNumeric(n))) {
+            return cbk([400, 'ExpectedNumericAmountToSendAsset']);
+          }
+
+          const feeRate = args.fee_tokens_per_vbyte;
+
+          if (feeRate !== undefined && !(feeRate > 0)) {
+            return cbk([400, 'ExpectedPositiveFeeRateToSendAsset']);
+          }
+
+          if (!isTapd({method, type, tapd: args.tapd})) {
+            return cbk([400, 'ExpectedAuthenticatedTapdToSendAsset']);
+          }
+
+          return cbk();
+        },
+
+        // Send the assets
+        send: [
+          'validate',
+          ({}, cbk) => {
+            const hasAmounts = args.addresses.some(n => !!n.amount);
+
+            // Older tapd versions only know the addresses without amounts
+            const request = {
+              addresses_with_amounts: !hasAmounts
+                ? []
+                : args.addresses.map(n => ({
+                    amount: n.amount || '0',
+                    tap_addr: n.address,
+                  })),
+              fee_rate: feeRateAsTokensPerKw(args.fee_tokens_per_vbyte),
+              label: args.label || '',
+              skip_proof_courier_ping_check: !!args.is_courier_ping_skipped,
+              tap_addrs: hasAmounts ? [] : args.addresses.map(n => n.address),
+            };
+
+            return args.tapd[type][method](request, (err: any, res: any) => {
+              if (isConnectionFailure({err})) {
+                return cbk([503, 'FailedToConnectToTapdToSendAsset']);
+              }
+
+              if (isPermissionDenied({err})) {
+                return cbk([403, 'PermissionDeniedToSendAsset']);
+              }
+
+              const details = String(err?.details);
+
+              if (!!err && details.includes(addressParseError)) {
+                return cbk([400, 'ExpectedValidAddressesToSendAsset', {err}]);
+              }
+
+              if (!!err && feeRateErrors.some(n => details.includes(n))) {
+                return cbk([400, 'ExpectedHigherFeeRateToSendAsset', {err}]);
+              }
+
+              if (!!err && details.includes(insufficientError)) {
+                return cbk([400, 'InsufficientAssetsToSendAsset']);
+              }
+
+              if (!!err) {
+                return cbk([503, 'UnexpectedErrorSendingAsset', {err}]);
+              }
+
+              if (!res) {
+                return cbk([503, 'ExpectedResponseToSendAssetRequest']);
+              }
+
+              try {
+                return cbk(null, rpcTransferAsTransfer(res.transfer));
+              } catch (err: any) {
+                return cbk([503, err.message]);
+              }
+            });
+          },
+        ],
+      },
+      returnResult({reject, resolve, of: 'send'}, cbk),
+    );
+  });
+};
+
+export default sendAsset;

package/src/tapd_methods/send/subscribe_to_asset_sends.ts

@@ -0,0 +1,181 @@
+import {EventEmitter} from 'node:events';
+
+import {emitSubscriptionError} from '../../grpc/index.js';
+import {handleRemoveListener} from '../../grpc/index.js';
+import {isTapd} from '../../tapd_requests/index.js';
+import {rpcSendEventAsSendEvent} from '../../tapd_responses/index.js';
+import type {AuthenticatedTapdArgs} from '../../typescript/index.js';
+
+const events = ['send'];
+const {from} = Buffer;
+const isDate = (n: string) => Date.parse(n) > 0;
+const isPublicKey = (n: string) => /^0[23][0-9A-F]{64}$/i.test(n);
+const method = 'subscribeSendEvents';
+const microsPerMs = 1e3;
+const type = 'default';
+
+export type SubscribeToAssetSendsArgs = AuthenticatedTapdArgs<{
+  /** Transfer Label String */
+  label?: string;
+  /** Recipient Script Key Hex String */
+  script_key?: string;
+  /** Replay Events From ISO 8601 Date String */
+  start_at?: string;
+}>;
+
+/** Subscribe to the state changes of outbound asset sends
+
+  Requires `assets:read` permission
+
+  A `start_at` date in the past replays the events from that date. Without a
+  `start_at`, the events start now.
+
+  {
+    [label]: <Transfer Label String>
+    [script_key]: <Recipient Script Key Hex String>
+    [start_at]: <Replay Events From ISO 8601 Date String>
+    tapd: <Authenticated tapd API Object>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  <EventEmitter Object>
+
+  @event 'send'
+  {
+    addresses: [{
+      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>
+    }]
+    [anchor]: {
+      [change_output_index]: <Change Output Index Number>
+      fee: <Chain Fee Tokens Number>
+      fee_tokens_per_vbyte: <Target Fee Tokens Per Virtual Byte Number>
+      locked_utxos: [{
+        transaction_id: <Locked Transaction Id Hex String>
+        transaction_vout: <Locked Transaction Output Index Number>
+      }]
+      psbt: <Anchor Transaction PSBT Hex String>
+      [transaction]: <Signed Anchor Transaction Hex String>
+    }
+    at: <Event At ISO 8601 Date String>
+    [error]: <Send State Error String>
+    [label]: <Transfer Label String>
+    [next_state]: <Next Send State String>
+    parcel_type: <Parcel Type String> // address, pending, pre_anchored, ...
+    passive_virtual_packets: [<Passive Virtual Packet Hex String>]
+    state: <Executed Send State String> // for example anchor_sign, complete
+    [transfer]: {
+      [block_hash]: <Anchor Block Hash Hex String>
+      [block_height]: <Anchor Block Height Number>
+      created_at: <Transfer Created At ISO 8601 Date String>
+      fee: <Anchor Transaction Chain Fee Tokens Number>
+      height_hint: <Anchor Transaction Confirmation Height Hint Number>
+      inputs: [{
+        amount: <Asset Units Numeric String>
+        asset_id: <Asset Id Hex String>
+        [group_key]: <Asset Group Key Hex String>
+        is_collectible: <Asset Is Collectible Bool>
+        script_key: <Script Key Hex String>
+        transaction_id: <Spent Anchor Transaction Id Hex String>
+        transaction_vout: <Spent Anchor Transaction Output Index Number>
+      }]
+      [label]: <Transfer Label String>
+      outputs: [{
+        [address]: <Taproot Assets Address Of the Recipient String>
+        amount: <Asset Units Numeric String>
+        anchor: {
+          internal_key: <Anchor Internal Key Hex String>
+          merkle_root: <Anchor Taproot Merkle Root Hex String>
+          output_script: <Output Script Hex String>
+          passive_assets_count: <Count Of Passive Assets In the Anchor Number>
+          taproot_asset_root: <Taproot Asset Root Commitment Hex String>
+          [tapscript_sibling]: <Tapscript Sibling Preimage Hex String>
+          tokens: <Anchor Output Tokens Number>
+          transaction_id: <Anchor Transaction Id Hex String>
+          transaction_vout: <Anchor Transaction Output Index Number>
+        }
+        [asset_id]: <Asset Id Hex String>
+        asset_version: <Asset Version Number>
+        [group_key]: <Asset Group Key Hex String>
+        is_collectible: <Asset Is Collectible Bool>
+        is_local: <Script Key Belongs To This Node Bool>
+        is_split_root: <Output Is the Split Root Bool>
+        [lock_time]: <Lock Time Number>
+        [proof]: <Proof File Hex String>
+        [proof_courier]: <Proof Courier Address String>
+        [proof_delivery]: <Proof Delivery State String> // complete, pending
+        [relative_lock_time]: <Relative Lock Time Number>
+        script_key: <Script Key Hex String>
+        [split_root_hash]: <Split Commitment Root Hash Hex String>
+      }]
+      [transaction]: <Raw Anchor Transaction Hex String>
+      transaction_id: <Anchor Transaction Id Hex String>
+    }
+    virtual_packets: [<Virtual Packet Hex String>]
+  }
+*/
+export default (args: SubscribeToAssetSendsArgs) => {
+  if (!isTapd({method, type, tapd: args.tapd})) {
+    throw new Error('ExpectedAuthenticatedTapdToSubscribeToAssetSends');
+  }
+
+  if (!!args.script_key && !isPublicKey(args.script_key)) {
+    throw new Error('ExpectedScriptKeyHexToSubscribeToAssetSends');
+  }
+
+  if (args.start_at !== undefined && !isDate(args.start_at)) {
+    throw new Error('ExpectedValidStartDateToSubscribeToAssetSends');
+  }
+
+  if (!!args.start_at && Date.parse(args.start_at) > Date.now()) {
+    throw new Error('ExpectedPastStartDateToSubscribeToAssetSends');
+  }
+
+  const emitter = new EventEmitter();
+  const start = !args.start_at ? 0 : Date.parse(args.start_at) * microsPerMs;
+
+  const subscription = args.tapd[type][method]({
+    filter_label: args.label || '',
+    filter_script_key: from(args.script_key || '', 'hex'),
+    start_timestamp: String(start),
+  });
+
+  const errored = emitSubscriptionError({emitter, subscription});
+
+  // Terminate the subscription when all listeners are removed
+  handleRemoveListener({emitter, events, subscription});
+
+  subscription.on('end', () => emitter.emit('end'));
+  subscription.on('error', (err: any) => errored(err));
+  subscription.on('status', (n: unknown) => emitter.emit('status', n));
+
+  // Emit a mapper error only when there is an error listener
+  const emitMapError = (err: Error) => {
+    if (!!emitter.listenerCount('error')) {
+      emitter.emit('error', [503, err.message]);
+    }
+  };
+
+  subscription.on('data', (event: any) => {
+    try {
+      emitter.emit('send', rpcSendEventAsSendEvent(event));
+    } catch (err: any) {
+      emitMapError(err);
+    }
+  });
+
+  return emitter;
+};

package/src/tapd_requests/decimal_as_fixed_point.ts

@@ -0,0 +1,36 @@
+const isDecimal = (n: unknown): n is string =>
+  typeof n === 'string' && /^\d+(\.\d+)?$/.test(n);
+const maxScale = 255;
+
+/** RPC fixed point number from an exact decimal string
+
+  The scale is the number of decimal places in the string
+
+  For example, "123.45" is coefficient 12345 with scale 2
+
+  <Exact Decimal String>
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    coefficient: <Scaled Integer Numeric String>
+    scale: <Decimal Places Number>
+  }
+*/
+export default (decimal: string) => {
+  if (!isDecimal(decimal)) {
+    throw new Error('ExpectedDecimalStringForFixedPoint');
+  }
+
+  const [whole, fraction = ''] = decimal.split('.');
+
+  if (fraction.length > maxScale) {
+    throw new Error('ExpectedFewerDecimalPlacesForFixedPoint');
+  }
+
+  const coefficient = `${whole}${fraction}`.replace(/^0+(?=\d)/, '');
+
+  return {coefficient, scale: fraction.length};
+};

package/src/tapd_requests/fee_rate_as_tokens_per_kw.ts

@@ -0,0 +1,23 @@
+const feeRateFloor = 253;
+const vbytesPerKiloWeight = 250;
+
+/** Chain fee rate in tokens per kiloweight from tokens per vbyte
+
+  tapd rejects a rate below 253 tokens per kiloweight, so a positive rate is
+  never below that floor. litcli and tapcli use the same floor.
+
+  [fee_tokens_per_vbyte]: <Fee Tokens Per Virtual Byte Number>
+
+  @returns
+  <Fee Tokens Per Kiloweight Number> // 0 selects the tapd default
+*/
+export default (feeTokensPerVbyte?: number) => {
+  // Exit early when there is no rate, so that tapd uses its default
+  if (!feeTokensPerVbyte) {
+    return 0;
+  }
+
+  const feeRate = Math.ceil(feeTokensPerVbyte * vbytesPerKiloWeight);
+
+  return Math.max(feeRateFloor, feeRate);
+};

package/src/tapd_requests/index.ts

@@ -0,0 +1,8 @@
+export {default as feeRateAsTokensPerKw} from './fee_rate_as_tokens_per_kw.js';
+export {default as decimalAsFixedPoint} from './decimal_as_fixed_point.js';
+export {default as isConnectionFailure} from './is_connection_failure.js';
+export {default as isMethodUnsupported} from './is_method_unsupported.js';
+export {default as isPermissionDenied} from './is_permission_denied.js';
+export {default as isTapd} from './is_tapd.js';
+export {default as mintFundingRequest} from './mint_funding_request.js';
+export {default as scriptKeyTypeQuery} from './script_key_type_query.js';