xrpl 2.14.1 → 2.14.2

package/src/sugar/getOrderbook.ts

@@ -1,6 +1,4 @@
-/* eslint-disable max-lines-per-function -- Needs to process orderbooks. */
 import BigNumber from 'bignumber.js'
-import flatMap from 'lodash/flatMap'
 
 import type { Client } from '../client'
 import { ValidationError } from '../errors'
@@ -31,43 +29,40 @@ const getOrderbookOptionsSet = new Set([
 ])
 
 /**
- * Fetch orderbook (buy/sell orders) between two currency pairs. This checks both sides of the orderbook
- * by making two `order_book` requests (with the second reversing takerPays and takerGets). Returned offers are
- * not normalized in this function, so either currency could be takerGets or takerPays.
+ * Represents the options for retrieving the order book.
+ */
+export interface GetOrderBookOptions {
+  /**
+   * The limit on the number of offers to return.
+   */
+  limit?: number
+  /**
+   * The ledger index of the ledger to use.
+   */
+  ledger_index?: LedgerIndex
+  /**
+   * The ledger hash of the ledger to use.
+   */
+  ledger_hash?: string | null
+  /**
+   * The account that takes the offers.
+   */
+  taker?: string | null
+}
+
+/**
+ * Validates the options for retrieving the order book.
  *
- * @param this - Client.
- * @param currency1 - Specification of one currency involved. (With a currency code and optionally an issuer)
- * @param currency2 - Specification of a second currency involved. (With a currency code and optionally an issuer)
- * @param options - Options allowing the client to specify ledger_index,
- * ledger_hash, filter by taker, and/or limit number of orders.
- * @param options.ledger_index - Retrieve the orderbook at a given ledger_index.
- * @param options.ledger_hash - Retrieve the orderbook at the ledger with a
- * given ledger_hash.
- * @param options.taker - Filter orders by taker.
- * @param options.limit - The limit passed into each book_offers request.
- * Can return more than this due to two calls being made. Defaults to 20.
- * @returns An object containing buy and sell objects.
+ * @param options - The options to validate.
+ * @throws {ValidationError} If any validation errors occur.
  */
-// eslint-disable-next-line max-params, complexity -- Once bound to Client, getOrderbook only has 3 parameters.
-async function getOrderbook(
-  this: Client,
-  currency1: BookOfferCurrency,
-  currency2: BookOfferCurrency,
-  options: {
-    limit?: number
-    ledger_index?: LedgerIndex
-    ledger_hash?: string | null
-    taker?: string | null
-  } = {},
-): Promise<{
-  buy: BookOffer[]
-  sell: BookOffer[]
-}> {
-  Object.keys(options).forEach((key) => {
+// eslint-disable-next-line complexity -- Necessary for validation.
+export function validateOrderbookOptions(options: GetOrderBookOptions): void {
+  for (const key of Object.keys(options)) {
     if (!getOrderbookOptionsSet.has(key)) {
       throw new ValidationError(`Unexpected option: ${key}`, options)
     }
-  })
+  }
 
   if (options.limit && typeof options.limit !== 'number') {
     throw new ValidationError('limit must be a number', options.limit)
@@ -101,7 +96,30 @@ async function getOrderbook(
   if (options.taker !== undefined && typeof options.taker !== 'string') {
     throw new ValidationError('taker must be a string', options.taker)
   }
+}
 
+/**
+ * Creates a request object for retrieving book offers.
+ *
+ * @param currency1 - The first currency in the pair.
+ * @param currency2 - The second currency in the pair.
+ * @param options - Additional options for the request.
+ * @param [options.limit] - The maximum number of offers to retrieve.
+ * @param [options.ledger_index] - The ledger index to use for retrieval.
+ * @param [options.ledger_hash] - The ledger hash to use for retrieval.
+ * @param [options.taker] - The taker address for retrieval.
+ * @returns The created request object.
+ */
+export function createBookOffersRequest(
+  currency1: BookOfferCurrency,
+  currency2: BookOfferCurrency,
+  options: {
+    limit?: number
+    ledger_index?: LedgerIndex
+    ledger_hash?: string | null
+    taker?: string | null
+  },
+): BookOffersRequest {
   const request: BookOffersRequest = {
     command: 'book_offers',
     taker_pays: currency1,
@@ -111,25 +129,78 @@ async function getOrderbook(
     limit: options.limit ?? DEFAULT_LIMIT,
     taker: options.taker ? options.taker : undefined,
   }
-  // 2. Make Request
-  const directOfferResults = await this.requestAll(request)
-  request.taker_gets = currency1
-  request.taker_pays = currency2
-  const reverseOfferResults = await this.requestAll(request)
-  // 3. Return Formatted Response
-  const directOffers = flatMap(
-    directOfferResults,
-    (directOfferResult) => directOfferResult.result.offers,
-  )
-  const reverseOffers = flatMap(
-    reverseOfferResults,
-    (reverseOfferResult) => reverseOfferResult.result.offers,
-  )
-
-  const orders = [...directOffers, ...reverseOffers]
-  // separate out the buy and sell orders
+
+  return request
+}
+
+type BookOfferResult = BookOffer[]
+
+/**
+ * Retrieves all book offer results using the given request.
+ *
+ * @param client - The Ripple client.
+ * @param request - The request object.
+ * @returns The array of book offer results.
+ */
+export async function requestAllOffers(
+  client: Client,
+  request: BookOffersRequest,
+): Promise<BookOfferResult[]> {
+  const results = await client.requestAll(request)
+  return results.map((result) => result.result.offers)
+}
+
+/**
+ * Creates a reverse request object by swapping the taker pays and taker gets amounts.
+ *
+ * @param request - The original request object.
+ * @returns The reverse request object.
+ */
+export function reverseRequest(request: BookOffersRequest): BookOffersRequest {
+  return {
+    ...request,
+    taker_pays: request.taker_gets,
+    taker_gets: request.taker_pays,
+  }
+}
+
+/**
+ * Extracts the offers from the book offer results.
+ *
+ * @param offerResults - The array of book offer results.
+ * @returns The extracted offers.
+ */
+export function extractOffers(offerResults: BookOfferResult[]): BookOffer[] {
+  return offerResults.flatMap((offerResult) => offerResult)
+}
+
+/**
+ * Combines the direct and reverse offers into a single array.
+ *
+ * @param directOffers - The direct offers.
+ * @param reverseOffers - The reverse offers.
+ * @returns The combined array of offers.
+ */
+export function combineOrders(
+  directOffers: BookOffer[],
+  reverseOffers: BookOffer[],
+): BookOffer[] {
+  return [...directOffers, ...reverseOffers]
+}
+
+/**
+ * Separates the buy and sell orders from the given array of orders.
+ *
+ * @param orders - The array of orders.
+ * @returns The separated buy and sell orders.
+ */
+export function separateBuySellOrders(orders: BookOffer[]): {
+  buy: BookOffer[]
+  sell: BookOffer[]
+} {
   const buy: BookOffer[] = []
   const sell: BookOffer[] = []
+
   orders.forEach((order) => {
     // eslint-disable-next-line no-bitwise -- necessary for flags check
     if ((order.Flags & OfferFlags.lsfSell) === 0) {
@@ -138,15 +209,21 @@ async function getOrderbook(
       sell.push(order)
     }
   })
-  /*
-   * Sort the orders
-   * for both buys and sells, lowest quality is closest to mid-market
-   * we sort the orders so that earlier orders are closer to mid-market
-   */
-  return {
-    buy: sortOffers(buy).slice(0, options.limit),
-    sell: sortOffers(sell).slice(0, options.limit),
-  }
+
+  return { buy, sell }
 }
 
-export default getOrderbook
+/**
+ * Sorts and limits the given array of offers.
+ *
+ * @param offers - The array of offers to sort and limit.
+ * @param [limit] - The maximum number of offers to include.
+ * @returns The sorted and limited array of offers.
+ */
+export function sortAndLimitOffers(
+  offers: BookOffer[],
+  limit?: number,
+): BookOffer[] {
+  const sortedOffers = sortOffers(offers)
+  return sortedOffers.slice(0, limit)
+}

package/src/sugar/index.ts

@@ -1,11 +1,3 @@
-export { default as autofill } from './autofill'
-
-export { getBalances, getXrpBalance } from './balances'
-
-export { default as getLedgerIndex } from './getLedgerIndex'
-
-export { default as getOrderbook } from './getOrderbook'
-
 export * from './submit'
 
 export * from './utils'

package/src/sugar/submit.ts

@@ -1,12 +1,16 @@
-import { decode, encode } from 'ripple-binary-codec'
-
-import type { Client, SubmitRequest, SubmitResponse, Wallet } from '..'
+import type {
+  Client,
+  SubmitRequest,
+  SubmitResponse,
+  SubmittableTransaction,
+  Transaction,
+  Wallet,
+} from '..'
 import { ValidationError, XrplError } from '../errors'
 import { Signer } from '../models/common'
-import { TxRequest, TxResponse } from '../models/methods'
-import { Transaction } from '../models/transactions'
+import { TxResponse } from '../models/methods'
 import { BaseTransaction } from '../models/transactions/common'
-import { hashes } from '../utils'
+import { decode, encode } from '../utils'
 
 /** Approximate time for a ledger to close, in milliseconds */
 const LEDGER_CLOSE_TIME = 1000
@@ -17,136 +21,37 @@ async function sleep(ms: number): Promise<void> {
   })
 }
 
-/**
- * Submits a signed/unsigned transaction.
- * Steps performed on a transaction:
- *    1. Autofill.
- *    2. Sign & Encode.
- *    3. Submit.
- *
- * @param this - A Client.
- * @param transaction - A transaction to autofill, sign & encode, and submit.
- * @param opts - (Optional) Options used to sign and submit a transaction.
- * @param opts.autofill - If true, autofill a transaction.
- * @param opts.failHard - If true, and the transaction fails locally, do not retry or relay the transaction to other servers.
- * @param opts.wallet - A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.
- * @returns A promise that contains SubmitResponse.
- * @throws RippledError if submit request fails.
- */
-async function submit(
-  this: Client,
-  transaction: Transaction | string,
-  opts?: {
-    // If true, autofill a transaction.
-    autofill?: boolean
-    // If true, and the transaction fails locally, do not retry or relay the transaction to other servers.
-    failHard?: boolean
-    // A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.
-    wallet?: Wallet
-  },
-): Promise<SubmitResponse> {
-  const signedTx = await getSignedTx(this, transaction, opts)
-  return submitRequest(this, signedTx, opts?.failHard)
-}
+// Helper functions
 
 /**
- * Asynchronously submits a transaction and verifies that it has been included in a
- * validated ledger (or has errored/will not be included for some reason).
- * See [Reliable Transaction Submission](https://xrpl.org/reliable-transaction-submission.html).
- *
- * @example
+ * Submits a request to the client with a signed transaction.
  *
- * ```ts
- * const { Client, Wallet } = require('xrpl')
- * const client = new Client('wss://s.altnet.rippletest.net:51233')
- *
- * async function submitTransaction() {
- *   const senderWallet = client.fundWallet()
- *   const recipientWallet = client.fundWallet()
- *
- *   const transaction = {
- *     TransactionType: 'Payment',
- *     Account: senderWallet.address,
- *     Destination: recipientWallet.address,
- *     Amount: '10'
- *   }
- *
- *   try {
- *     await client.submit(signedTransaction, { wallet: senderWallet })
- *     console.log(result)
- *   } catch (error) {
- *     console.error(`Failed to submit transaction: ${error}`)
- *   }
- * }
+ * @param client - The client to submit the request to.
+ * @param signedTransaction - The signed transaction to submit. It can be either a Transaction object or a
+ * string (encode from ripple-binary-codec) representation of the transaction.
+ * @param [failHard=false] - Optional. Determines whether the submission should fail hard (true) or not (false). Default is false.
+ * @returns A promise that resolves with the response from the client.
+ * @throws {ValidationError} If the signed transaction is not valid (not signed).
  *
- * submitTransaction()
- * ```
- *
- * In this example we submit a payment transaction between two newly created testnet accounts.
- *
- * Under the hood, `submit` will call `client.autofill` by default, and because we've passed in a `Wallet` it
- * Will also sign the transaction for us before submitting the signed transaction binary blob to the ledger.
+ * @example
+ * import { Client } from "xrpl"
+ * const client = new Client("wss://s.altnet.rippletest.net:51233");
+ * await client.connect();
+ * const signedTransaction = createSignedTransaction();
+ * // Example 1: Submitting a Transaction object
+ * const response1 = await submitRequest(client, signedTransaction);
  *
- * This is similar to `submitAndWait` which does all of the above, but also waits to see if the transaction has been validated.
- * @param this - A Client.
- * @param transaction - A transaction to autofill, sign & encode, and submit.
- * @param opts - (Optional) Options used to sign and submit a transaction.
- * @param opts.autofill - If true, autofill a transaction.
- * @param opts.failHard - If true, and the transaction fails locally, do not retry or relay the transaction to other servers.
- * @param opts.wallet - A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.
- * @throws Connection errors: If the `Client` object is unable to establish a connection to the specified WebSocket endpoint,
- * an error will be thrown.
- * @throws Transaction errors: If the submitted transaction is invalid or cannot be included in a validated ledger for any
- * reason, the promise returned by `submitAndWait()` will be rejected with an error. This could include issues with insufficient
- * balance, invalid transaction fields, or other issues specific to the transaction being submitted.
- * @throws Ledger errors: If the ledger being used to submit the transaction is undergoing maintenance or otherwise unavailable,
- * an error will be thrown.
- * @throws Timeout errors: If the transaction takes longer than the specified timeout period to be included in a validated
- * ledger, the promise returned by `submitAndWait()` will be rejected with an error.
- * @returns A promise that contains TxResponse, that will return when the transaction has been validated.
+ * // Example 2: Submitting a string representation of the transaction
+ * const signedTransactionString = encode(signedTransaction);
+ * const response2 = await submitRequest(client, signedTransactionString, true);
  */
-async function submitAndWait<T extends Transaction = Transaction>(
-  this: Client,
-  transaction: T | string,
-  opts?: {
-    // If true, autofill a transaction.
-    autofill?: boolean
-    // If true, and the transaction fails locally, do not retry or relay the transaction to other servers.
-    failHard?: boolean
-    // A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.
-    wallet?: Wallet
-  },
-): Promise<TxResponse<T>> {
-  const signedTx = await getSignedTx(this, transaction, opts)
-
-  const lastLedger = getLastLedgerSequence(signedTx)
-  if (lastLedger == null) {
-    throw new ValidationError(
-      'Transaction must contain a LastLedgerSequence value for reliable submission.',
-    )
-  }
-
-  const response = await submitRequest(this, signedTx, opts?.failHard)
-
-  const txHash = hashes.hashSignedTx(signedTx)
-  return waitForFinalTransactionOutcome(
-    this,
-    txHash,
-    lastLedger,
-    response.result.engine_result,
-  )
-}
-
-// Helper functions
-
-// Encodes and submits a signed transaction.
-async function submitRequest(
+export async function submitRequest(
   client: Client,
-  signedTransaction: Transaction | string,
+  signedTransaction: SubmittableTransaction | string,
   failHard = false,
 ): Promise<SubmitResponse> {
   if (!isSigned(signedTransaction)) {
-    throw new ValidationError('Transaction must be signed')
+    throw new ValidationError('Transaction must be signed.')
   }
 
   const signedTxEncoded =
@@ -161,15 +66,50 @@ async function submitRequest(
   return client.request(request)
 }
 
-/*
- * The core logic of reliable submission.  This polls the ledger until the result of the
- * transaction can be considered final, meaning it has either been included in a
- * validated ledger, or the transaction's lastLedgerSequence has been surpassed by the
- * latest ledger sequence (meaning it will never be included in a validated ledger).
+/**
+ * Waits for the final outcome of a transaction by polling the ledger until the result can be considered final,
+ * meaning it has either been included in a validated ledger, or the transaction's lastLedgerSequence has been
+ * surpassed by the latest ledger sequence (meaning it will never be included in a validated ledger).
+ *
+ * @template T - The type of the transaction. Defaults to `Transaction`.
+ * @param client - The client to use for requesting transaction information.
+ * @param txHash - The hash of the transaction to wait for.
+ * @param lastLedger - The last ledger sequence of the transaction.
+ * @param submissionResult - The preliminary result of the transaction.
+ * @returns A promise that resolves with the final transaction response.
+ *
+ * @throws {XrplError} If the latest ledger sequence surpasses the transaction's lastLedgerSequence.
+ *
+ * @example
+ * import { hashes, Client } from "xrpl"
+ * const client = new Client("wss://s.altnet.rippletest.net:51233")
+ * await client.connect()
+ *
+ * const transaction = createTransaction() // your transaction function
+ *
+ * const signedTx = await getSignedTx(this, transaction)
+ *
+ * const lastLedger = getLastLedgerSequence(signedTx)
+ *
+ * if (lastLedger == null) {
+ *   throw new ValidationError(
+ *     'Transaction must contain a LastLedgerSequence value for reliable submission.',
+ *   )
+ * }
+ *
+ * const response = await submitRequest(this, signedTx, opts?.failHard)
+ *
+ * const txHash = hashes.hashSignedTx(signedTx)
+ * return waitForFinalTransactionOutcome(
+ *   this,
+ *   txHash,
+ *   lastLedger,
+ *   response.result.engine_result,
+ * )
  */
 // eslint-disable-next-line max-params, max-lines-per-function -- this function needs to display and do with more information.
-async function waitForFinalTransactionOutcome<
-  T extends BaseTransaction = Transaction,
+export async function waitForFinalTransactionOutcome<
+  T extends BaseTransaction = SubmittableTransaction,
 >(
   client: Client,
   txHash: string,
@@ -188,7 +128,7 @@ async function waitForFinalTransactionOutcome<
   }
 
   const txResponse = await client
-    .request<TxRequest, TxResponse<T>>({
+    .request({
       command: 'tx',
       transaction: txHash,
     })
@@ -212,7 +152,9 @@ async function waitForFinalTransactionOutcome<
     })
 
   if (txResponse.result.validated) {
-    return txResponse
+    // TODO: resolve the type assertion below
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- we know that txResponse is of type TxResponse
+    return txResponse as TxResponse<T>
   }
 
   return waitForFinalTransactionOutcome<T>(
@@ -224,7 +166,7 @@ async function waitForFinalTransactionOutcome<
 }
 
 // checks if the transaction has been signed
-function isSigned(transaction: Transaction | string): boolean {
+function isSigned(transaction: SubmittableTransaction | string): boolean {
   const tx = typeof transaction === 'string' ? decode(transaction) : transaction
   if (typeof tx === 'string') {
     return false
@@ -248,22 +190,52 @@ function isSigned(transaction: Transaction | string): boolean {
   return tx.SigningPubKey != null && tx.TxnSignature != null
 }
 
-// initializes a transaction for a submit request
-async function getSignedTx(
+/**
+ * Updates a transaction with `autofill` then signs it if it is unsigned.
+ *
+ * @param client - The client from which to retrieve the signed transaction.
+ * @param transaction - The transaction to retrieve. It can be either a Transaction object or
+ * a string (encode from ripple-binary-codec) representation of the transaction.
+ * @param [options={}] - Optional. Additional options for retrieving the signed transaction.
+ * @param [options.autofill=true] - Optional. Determines whether the transaction should be autofilled (true)
+ * or not (false). Default is true.
+ * @param [options.wallet] - Optional. A wallet to sign the transaction. It must be provided when submitting
+ * an unsigned transaction. Default is undefined.
+ * @returns A promise that resolves with the signed transaction.
+ *
+ * @throws {ValidationError} If the transaction is not signed and no wallet is provided.
+ *
+ * @example
+ * import { Client } from "xrpl"
+ * import { encode } from "ripple-binary-codec"
+ *
+ * const client = new Client("wss://s.altnet.rippletest.net:51233");
+ * await client.connect():
+ * const transaction = createTransaction(); // createTransaction is your function to create a transaction
+ * const options = {
+ *   autofill: true,
+ *   wallet: myWallet,
+ * };
+ *
+ * // Example 1: Retrieving a signed Transaction object
+ * const signedTx1 = await getSignedTx(client, transaction, options);
+ *
+ * // Example 2: Retrieving a string representation of the signed transaction
+ * const signedTxString = await getSignedTx(client, encode(transaction), options);
+ */
+export async function getSignedTx(
   client: Client,
-  transaction: Transaction | string,
+  transaction: SubmittableTransaction | string,
   {
     autofill = true,
     wallet,
   }: {
     // If true, autofill a transaction.
     autofill?: boolean
-    // If true, and the transaction fails locally, do not retry or relay the transaction to other servers.
-    failHard?: boolean
     // A wallet to sign a transaction. It must be provided when submitting an unsigned transaction.
     wallet?: Wallet
   } = {},
-): Promise<Transaction | string> {
+): Promise<SubmittableTransaction | string> {
   if (isSigned(transaction)) {
     return transaction
   }
@@ -277,7 +249,7 @@ async function getSignedTx(
   let tx =
     typeof transaction === 'string'
       ? // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- converts JsonObject to correct Transaction type
-        (decode(transaction) as unknown as Transaction)
+        (decode(transaction) as unknown as SubmittableTransaction)
       : transaction
 
   if (autofill) {
@@ -288,7 +260,26 @@ async function getSignedTx(
 }
 
 // checks if there is a LastLedgerSequence as a part of the transaction
-function getLastLedgerSequence(
+/**
+ * Retrieves the last ledger sequence from a transaction.
+ *
+ * @param transaction - The transaction to retrieve the last ledger sequence from. It can be either a Transaction object or
+ * a string (encode from ripple-binary-codec) representation of the transaction.
+ * @returns The last ledger sequence of the transaction, or null if not available.
+ *
+ * @example
+ * const transaction = createTransaction(); // your function to create a transaction
+ *
+ * // Example 1: Retrieving the last ledger sequence from a Transaction object
+ * const lastLedgerSequence1 = getLastLedgerSequence(transaction);
+ * console.log(lastLedgerSequence1); // Output: 12345
+ *
+ * // Example 2: Retrieving the last ledger sequence from a string representation of the transaction
+ * const transactionString = encode(transaction);
+ * const lastLedgerSequence2 = getLastLedgerSequence(transactionString);
+ * console.log(lastLedgerSequence2); // Output: 67890
+ */
+export function getLastLedgerSequence(
   transaction: Transaction | string,
 ): number | null {
   const tx = typeof transaction === 'string' ? decode(transaction) : transaction
@@ -301,5 +292,3 @@ function isAccountDelete(transaction: Transaction | string): boolean {
   const tx = typeof transaction === 'string' ? decode(transaction) : transaction
   return tx.TransactionType === 'AccountDelete'
 }
-
-export { submit, submitAndWait }

package/src/utils/collections.ts

@@ -0,0 +1,57 @@
+type ValueOf<T> = T[keyof T]
+
+/**
+ * Creates an object composed of keys generated from the results of running each element of collection thru iteratee.
+ * The order of grouped values is determined by the order they occur in collection.
+ * The corresponding value of each key is an array of elements responsible for generating the key.
+ *
+ * Similar to lodash's groupBy
+ *
+ * @param array - array to iterate over
+ * @param iteratee - function that returns key of the group to place the item
+ *
+ * @returns a map of arrays
+ */
+export function groupBy<T>(
+  array: T[],
+  iteratee: (value: T, index: number, array: T[]) => string | number,
+): Record<string | number, T[]> {
+  // eslint-disable-next-line max-params -- need all the params for the fallback
+  function predicate(
+    acc: Record<string | number, T[]>,
+    value: T,
+    index: number,
+    arrayReference: T[],
+  ): Record<string | number, T[]> {
+    const key = iteratee(value, index, arrayReference) || 0
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Find existing group or create a new one
+    const group = acc[key] || []
+    group.push(value)
+    acc[key] = group
+    return acc
+  }
+
+  return array.reduce(predicate, {})
+}
+
+/**
+ * Creates an object composed of the own and inherited enumerable string keyed properties of object that
+ * predicate doesn't return truthy for.
+ *
+ * @param obj - Object to have properties removed.
+ * @param predicate - function that returns whether the property should be removed from the obj.
+ *
+ * @returns object
+ */
+export function omitBy<T extends object>(
+  obj: T,
+  predicate: (objElement: ValueOf<T>, k: string | number | symbol) => boolean,
+): Partial<T> {
+  // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- We know the keys are properties of T
+  const keys: Array<keyof T> = Object.keys(obj) as Array<keyof T>
+  const keysToKeep = keys.filter((kb) => !predicate(obj[kb], kb))
+  return keysToKeep.reduce((acc: Partial<T>, key: keyof T) => {
+    acc[key] = obj[key]
+    return acc
+  }, {})
+}