@xyo-network/payment-plugin 5.3.2 → 5.3.3

package/src/Discount/Diviner.ts

@@ -1,205 +0,0 @@
-import {
-  Address, assertEx, exists, filterAs, Hash,
-} from '@xylabs/sdk-js'
-import { ArchivistInstance, asArchivistInstance } from '@xyo-network/archivist-model'
-import { AbstractDiviner } from '@xyo-network/diviner-abstract'
-import { BoundWitnessDivinerQueryPayload, BoundWitnessDivinerQuerySchema } from '@xyo-network/diviner-boundwitness-model'
-import {
-  HashLeaseEstimate,
-  isHashLeaseEstimate,
-} from '@xyo-network/diviner-hash-lease'
-import {
-  asDivinerInstance, DivinerInstance, DivinerModuleEventData,
-} from '@xyo-network/diviner-model'
-import { creatableModule } from '@xyo-network/module-model'
-import { Payload } from '@xyo-network/payload-model'
-import {
-  asCondition,
-  asCoupon,
-  Condition,
-  Coupon,
-  Discount,
-  EscrowTerms, isCondition, isCoupon,
-  isEscrowTerms, NO_DISCOUNT, PaymentDiscountDivinerConfigSchema, PaymentDiscountDivinerParams,
-} from '@xyo-network/payment-payload-plugins'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-
-import { applyCoupons, areConditionsFulfilled } from './lib/index.ts'
-
-const DEFAULT_BOUND_WITNESS_DIVINER_QUERY_PROPS: Readonly<BoundWitnessDivinerQueryPayload> = {
-  limit: 1,
-  order: 'desc',
-  schema: BoundWitnessDivinerQuerySchema,
-}
-
-export type PaymentDiscountDivinerInputType = EscrowTerms | Coupon | HashLeaseEstimate | Payload
-
-@creatableModule()
-export class PaymentDiscountDiviner<
-  TParams extends PaymentDiscountDivinerParams = PaymentDiscountDivinerParams,
-  TIn extends PaymentDiscountDivinerInputType = PaymentDiscountDivinerInputType,
-  TOut extends Discount = Discount,
-  TEventData extends DivinerModuleEventData<DivinerInstance<TParams, TIn, TOut>, TIn, TOut> = DivinerModuleEventData<
-    DivinerInstance<TParams, TIn, TOut>,
-    TIn,
-    TOut
-  >,
-> extends AbstractDiviner<TParams, TIn, TOut, TEventData> {
-  static override readonly configSchemas = [PaymentDiscountDivinerConfigSchema]
-  static override readonly defaultConfigSchema = PaymentDiscountDivinerConfigSchema
-
-  protected get couponAuthorities(): Address[] {
-    return [...(this.config.couponAuthorities ?? []), ...(this.params.couponAuthorities ?? [])]
-  }
-
-  protected async divineHandler(payloads: TIn[] = []): Promise<TOut[]> {
-    const $sources: Hash[] = []
-
-    // Parse terms
-    const terms = payloads.find(isEscrowTerms) as EscrowTerms | undefined
-    if (!terms) return [{ ...NO_DISCOUNT, $sources }] as TOut[]
-    $sources.push(await PayloadBuilder.hash(terms))
-
-    // Parse appraisals
-    const termsAppraisals = terms?.appraisals
-    // If the escrow terms do not have appraisals, return no discount
-    if (!termsAppraisals || termsAppraisals.length === 0) return [{ ...NO_DISCOUNT, $sources }] as TOut[]
-    const hashMap = await PayloadBuilder.toAllHashMap(payloads) as Record<Hash, Payload>
-    const appraisals = this.getEscrowAppraisals(terms, hashMap)
-    // Add the appraisals that were found to the sources
-    $sources.push(...termsAppraisals)
-    // If not all appraisals are found, return no discount
-    if (appraisals.length !== termsAppraisals.length) return [{ ...NO_DISCOUNT, $sources }] as TOut[]
-
-    // Parse coupons
-    const [coupons, conditions] = await this.getEscrowDiscounts(terms, hashMap)
-    // Add the coupons that were found to the sources
-    // TODO: Should we throw if not all coupons are found?
-    const couponHashes = await PayloadBuilder.hashes(coupons)
-    $sources.push(...couponHashes)
-
-    const currentCoupons = coupons.filter(this.isCouponCurrent)
-    const conditionsMetCoupons = (
-      await Promise.all(currentCoupons.map(async coupon => await areConditionsFulfilled(coupon, conditions, payloads) ? coupon : undefined))).filter(exists)
-
-    const validCoupons = await this.filterToSigned(conditionsMetCoupons)
-    // TODO: Should we throw if not all coupons are valid?
-    if (validCoupons.length === 0) return [{ ...NO_DISCOUNT, $sources }] as TOut[]
-
-    // TODO: Call paymentSubtotalDiviner to get the subtotal to centralize the logic
-    const discount = applyCoupons(appraisals, validCoupons)
-    return [{ ...discount, $sources }] as TOut[]
-  }
-
-  /**
-   * Filters the supplied list of coupons to only those that are signed by
-   * addresses specified in the couponAuthorities
-   * @param coupons The list of coupons to filter
-   * @returns The filtered list of coupons that are signed by the couponAuthorities
-   */
-  protected async filterToSigned(coupons: Coupon[]): Promise<Coupon[]> {
-    const signed: Coupon[] = []
-    const dataHashMap = await PayloadBuilder.toDataHashMap(coupons)
-    const boundWitnessDiviner = await this.getDiscountsBoundWitnessDiviner()
-    const hashes = Object.keys(dataHashMap)
-    const addresses = this.couponAuthorities
-    // TODO: Keep an in memory cache of the hashes queried and their results
-    // to avoid querying the same hash multiple times
-    await Promise.all(hashes.map((h) => {
-      const hash = h as Hash
-      return Promise.all(addresses.map(async (address) => {
-        const query: BoundWitnessDivinerQueryPayload = {
-          ...DEFAULT_BOUND_WITNESS_DIVINER_QUERY_PROPS, addresses: [address], payload_hashes: [hash],
-        }
-        const result = await boundWitnessDiviner.divine([query])
-        if (result.length > 0) signed.push(dataHashMap[hash])
-      }))
-    }))
-    return signed
-  }
-
-  protected async getDiscountsArchivist(): Promise<ArchivistInstance> {
-    const name = assertEx(this.config.archivist, () => 'Missing archivist in config')
-    const mod = assertEx(await this.resolve(name), () => `Error resolving archivist: ${name}`)
-    return assertEx(asArchivistInstance(mod), () => `Resolved module ${mod.address} not a valid Archivist`)
-  }
-
-  protected async getDiscountsBoundWitnessDiviner(): Promise<DivinerInstance> {
-    const name = assertEx(this.config.boundWitnessDiviner, () => 'Missing boundWitnessDiviner in config')
-    const mod = assertEx(await this.resolve(name), () => `Error resolving boundWitnessDiviner: ${name}`)
-    return assertEx(asDivinerInstance(mod), () => `Resolved module ${mod.address} not a valid Diviner`)
-  }
-
-  /**
-   * Finds the appraisals specified by the escrow terms from the supplied payloads
-   * @param terms The escrow terms
-   * @param payloads The payloads to search for the appraisals
-   * @returns The appraisals found in the payloads
-   */
-  protected getEscrowAppraisals(terms: EscrowTerms, hashMap: Record<Hash, Payload>): HashLeaseEstimate[] {
-    const hashes = terms?.appraisals ?? []
-    if (hashes.length === 0) return []
-    return hashes.map(hash => hashMap[hash]).filter(exists).filter(isHashLeaseEstimate)
-  }
-
-  /**
-   * Finds the discounts specified by the escrow terms from the supplied payloads
-   * @param terms The escrow terms
-   * @param hashMap The payloads to search for the discounts
-   * @returns A tuple containing all the escrow coupons and conditions referenced in those coupons
-   * that were found in the either the supplied payloads or the archivist
-   */
-  protected async getEscrowDiscounts(terms: EscrowTerms, hashMap: Record<Hash, Payload>): Promise<[Coupon[], Condition[]]> {
-    // Parse discounts
-    const discountsHashes = terms.discounts ?? []
-    if (discountsHashes.length === 0) return [[], []]
-
-    // Use the supplied payloads to find the discounts
-    const discounts: Coupon[] = discountsHashes.map(hash => hashMap[hash]).filter(exists).filter(isCoupon)
-    const missingDiscounts = discountsHashes.filter(hash => !hashMap[hash])
-    // If not all discounts are found
-    if (missingDiscounts.length > 0) {
-      // Find any remaining from discounts archivist
-      const discountsArchivist = await this.getDiscountsArchivist()
-      const payloads = await discountsArchivist.get(missingDiscounts)
-      discounts.push(...filterAs(payloads, asCoupon))
-    }
-    // If not all discounts are found
-    if (discounts.length !== discountsHashes.length) {
-      const termsHash = await PayloadBuilder.hash(terms)
-      const foundHashes = await PayloadBuilder.hashes(discounts)
-      // Log individual discounts that were not found
-      for (const hash of discountsHashes) {
-        if (!foundHashes.includes(hash)) console.warn(`Discount ${hash} not found for terms ${termsHash}`)
-      }
-    }
-
-    const conditionsHashes: Hash[] = discounts.flatMap(discount => discount.conditions ?? [])
-    const conditions: Condition[] = conditionsHashes.map(hash => hashMap[hash]).filter(exists).filter(isCondition)
-    const missingConditions = conditionsHashes.filter(hash => !hashMap[hash])
-
-    // If not all conditions are found
-    if (missingConditions.length > 0) {
-      // Find any remaining from discounts archivist
-      const discountsArchivist = await this.getDiscountsArchivist()
-      const payloads = await discountsArchivist.get(missingConditions)
-      conditions.push(...filterAs(payloads, asCondition))
-    }
-    // If not all conditions are found
-    if (conditions.length !== conditionsHashes.length) {
-      const termsHash = await PayloadBuilder.hash(terms)
-      const foundHashes = await PayloadBuilder.hashes(conditions)
-      // Log individual conditions that were not found
-      for (const hash of discountsHashes) {
-        if (!foundHashes.includes(hash)) console.warn(`Coupon condition ${hash} not found for terms ${termsHash}`)
-      }
-    }
-
-    return [discounts, conditions]
-  }
-
-  protected isCouponCurrent(coupon: Coupon): boolean {
-    const now = Date.now()
-    return coupon.exp > now && coupon.nbf < now
-  }
-}

package/src/Discount/index.ts

@@ -1,2 +0,0 @@
-export * from './Diviner.ts'
-export * from './lib/index.ts'

package/src/Discount/lib/applyCoupons.ts

@@ -1,95 +0,0 @@
-import { assertEx, exists } from '@xylabs/sdk-js'
-import type { HashLeaseEstimate } from '@xyo-network/diviner-hash-lease'
-import type {
-  AmountFields,
-  Coupon, Discount, FixedAmountCoupon,
-  FixedPercentageCoupon,
-  FixedPriceCoupon,
-} from '@xyo-network/payment-payload-plugins'
-import {
-  DiscountSchema,
-  isFixedAmountCoupon, isFixedPercentageCoupon,
-  isFixedPriceCoupon,
-  isStackable,
-} from '@xyo-network/payment-payload-plugins'
-
-export const applyCoupons = (appraisals: HashLeaseEstimate[], coupons: Coupon[]): Discount => {
-  // Ensure all appraisals and coupons are in USD
-  const allAppraisalsAreUSD = appraisals.every(appraisal => appraisal.currency === 'USD')
-  assertEx(allAppraisalsAreUSD, () => 'All appraisals must be in USD')
-  const allCouponsAreUSD = coupons.map(coupon => (coupon as Partial<AmountFields>)?.currency).filter(exists).every(currency => currency === 'USD')
-  assertEx(allCouponsAreUSD, () => 'All coupons must be in USD')
-  const total = appraisals.reduce((acc, appraisal) => acc + appraisal.price, 0)
-
-  // Calculated non-stackable discount coupons
-  const singularFixedDiscount = Math.max(...coupons
-    .filter(coupon => isFixedAmountCoupon(coupon) && !isStackable(coupon))
-    .map(coupon => (coupon as FixedAmountCoupon).amount), 0)
-  const singularPercentageDiscount = (Math.max(...coupons
-    .filter(coupon => isFixedPercentageCoupon(coupon) && !isStackable(coupon))
-    .map(coupon => (coupon as FixedPercentageCoupon).percentage), 0)) * total
-  const singularFixedPriceDiscount = calculateSingularFixedPriceDiscount(total, appraisals, coupons, false)
-
-  // Calculate stackable discount coupons
-  // First calculate the total discount from fixed amount coupons
-  const stackedFixedDiscount = coupons
-    .filter(coupon => isFixedAmountCoupon(coupon) && isStackable(coupon))
-    .reduce((acc, coupon) => acc + (coupon as FixedAmountCoupon).amount, 0)
-  // Then calculate the total discount from percentage coupons and apply
-  // the percentage discount to the remaining total after fixed discounts
-  const stackedPercentageDiscount = coupons
-    .filter(coupon => isFixedPercentageCoupon(coupon) && isStackable(coupon))
-    .reduce((acc, coupon) => acc + (coupon as FixedPercentageCoupon).percentage, 0) * (total - stackedFixedDiscount)
-  // Then calculate the total discount from fixed price coupons
-  const stackedFixedPriceDiscount = calculateSingularFixedPriceDiscount(total, appraisals, coupons, true)
-
-  // Sum all stackable discounts
-  const stackedDiscount = stackedFixedDiscount + stackedPercentageDiscount + stackedFixedPriceDiscount
-
-  // Find the best coupon(s) to apply
-  const maxDiscount = Math.max(
-    singularFixedDiscount,
-    singularFixedPriceDiscount,
-    singularPercentageDiscount,
-    stackedDiscount,
-    0,
-  )
-
-  // Ensure discount is not more than the total
-  const amount = Math.min(maxDiscount, total)
-
-  // Return single discount payload
-  return {
-    amount, schema: DiscountSchema, currency: 'USD',
-  }
-}
-
-const calculateSingularFixedPriceDiscount = (total: number, appraisals: HashLeaseEstimate[], coupons: Coupon[], stackable = false): number => {
-  // Find all singular fixed price discounts
-  const singularFixedPriceDiscounts = coupons
-    .filter(isFixedPriceCoupon)
-    .filter(coupon => stackable ? isStackable(coupon) : !isStackable(coupon))
-    .map(coupon => (coupon as FixedPriceCoupon).amount)
-    // Ensure all fixed price discounts are positive
-    .filter(amount => amount > 0)
-
-  // If there are no singular fixed price discounts, return no discount
-  if (singularFixedPriceDiscounts.length === 0) return 0
-
-  // Find the maximum discount (the lowest fixed price)
-  const lowestFixedPrice = Math.min(...singularFixedPriceDiscounts)
-
-  // Apply the fixed price to all appraisals to get the reduced prices
-  const reducedPrices = appraisals.map(appraisal =>
-  // If the appraisal price is less than the fixed price
-    Math.min(appraisal.price, lowestFixedPrice))
-
-  // Calculate the reduced total using the reduced prices
-  const reducedTotal = reducedPrices.reduce((acc, price) => acc + price, 0)
-
-  // Calculate the discount
-  const discount = total - reducedTotal
-
-  // Return the discount or 0 if the discount would have resulted in a negative value
-  return Math.max(discount, 0)
-}

package/src/Discount/lib/findUnfulfilledConditions.ts

@@ -1,72 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import type { Payload } from '@xyo-network/payload-model'
-import type { Condition, Coupon } from '@xyo-network/payment-payload-plugins'
-import { isCondition } from '@xyo-network/payment-payload-plugins'
-import type { SchemaPayload } from '@xyo-network/schema-payload-plugin'
-import { isSchemaPayload } from '@xyo-network/schema-payload-plugin'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-import type { ValidateFunction } from 'ajv'
-import { Ajv } from 'ajv'
-
-// TODO: Use our schema cache
-const ajv = new Ajv({ strict: false }) // Create the Ajv instance once
-const schemaCache = new Map() // Cache to store compiled validators
-
-/**
- * Validates the conditions of a coupon against the provided payloads
- * @param coupon The coupon to check
- * @param conditions The conditions associated with the coupon
- * @param payloads The associated payloads (containing the conditions and data to validate the conditions against)
- * @returns True if all conditions are fulfilled, false otherwise
- */
-export const areConditionsFulfilled = async (coupon: Coupon, conditions: Condition[] = [], payloads: Payload[] = []): Promise<boolean> =>
-  (await findUnfulfilledConditions(coupon, conditions, payloads)).length === 0
-
-/**
- * Validates the conditions of a coupon against the provided payloads
- * @param coupon The coupon to check
- * @param conditions The conditions associated with the coupon
- * @param payloads The associated payloads (containing the conditions and data to validate the conditions against)
- * @returns The unfulfilled condition hashes
- */
-export const findUnfulfilledConditions = async (coupon: Coupon, conditions: Condition[] = [], payloads: Payload[] = []): Promise<Hash[]> => {
-  const unfulfilledConditions: Hash[] = []
-  // If there are no conditions, then they are fulfilled
-  if (!coupon.conditions || coupon.conditions.length === 0) return unfulfilledConditions
-  const hashMap = await PayloadBuilder.toAllHashMap([...conditions, ...payloads])
-  // Find all the conditions
-  const foundConditions = coupon.conditions.map(hash => hashMap[hash]).filter(isCondition)
-  // Not all conditions were found
-  if (foundConditions.length !== coupon.conditions.length) {
-    const missing = coupon.conditions.filter(hash => !hashMap[hash])
-    unfulfilledConditions.push(...missing)
-    return unfulfilledConditions
-  }
-
-  // Test each condition
-  for (const hash of coupon.conditions) {
-    let validator: ValidateFunction
-
-    // Check if the schema is already cached
-    if (schemaCache.has(hash)) {
-      validator = schemaCache.get(hash)
-    } else {
-      const payload = hashMap[hash]
-      const definition = isSchemaPayload(payload) ? (payload as SchemaPayload).definition : undefined
-      if (definition) {
-        // Compile and cache the validator
-        validator = ajv.compile(definition)
-        schemaCache.set(hash, validator)
-
-        // Validate the payload
-      } else {
-        unfulfilledConditions.push(hash)
-        continue
-      }
-    }
-    if (!validator(payloads)) unfulfilledConditions.push(hash)
-  }
-
-  // All conditions passed
-  return unfulfilledConditions
-}

package/src/Discount/lib/index.ts

@@ -1,2 +0,0 @@
-export * from './applyCoupons.ts'
-export * from './findUnfulfilledConditions.ts'

package/src/Invoice/getInvoiceForEscrow.ts

@@ -1,40 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import type { DivinerInstance } from '@xyo-network/diviner-model'
-import type { Payload } from '@xyo-network/payload-model'
-import type {
-  Discount, EscrowTerms, Invoice, Payment,
-  Subtotal, Total,
-} from '@xyo-network/payment-payload-plugins'
-import {
-  isDiscount, isSubtotal, isTotal, PaymentSchema,
-} from '@xyo-network/payment-payload-plugins'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-
-/**
- * Validates the escrow terms to ensure they are valid for a purchase
- * @returns A payment if the terms are valid for a purchase, undefined otherwise
- */
-export const getInvoiceForEscrow = async (
-  terms: EscrowTerms,
-  dataHashMap: Record<Hash, Payload>,
-  paymentTotalDiviner: DivinerInstance,
-): Promise<Invoice | undefined> => {
-  const payloads = Object.values(dataHashMap)
-  const results = await paymentTotalDiviner.divine([terms, ...payloads])
-  const subtotal = results.find(isSubtotal) as Subtotal | undefined
-  const discount = results.find(isDiscount) as Discount | undefined
-  const total = results.find(isTotal) as Total | undefined
-  if (!subtotal || !total) return undefined
-  const { amount, currency } = total
-  if (currency !== 'USD') return undefined
-  const $sources = await getSources(terms, subtotal, total, discount)
-  const payment: Payment = {
-    amount, currency, schema: PaymentSchema, $sources,
-  }
-  return discount ? [subtotal, total, payment, discount] : [subtotal, total, payment]
-}
-
-const getSources = async (terms: EscrowTerms, subtotal: Subtotal, total: Total, discount?: Discount): Promise<Hash[]> => {
-  const sources = discount ? [terms, subtotal, total, discount] : [terms, subtotal, total]
-  return await Promise.all(sources.map(p => PayloadBuilder.dataHash(p)))
-}

package/src/Invoice/index.ts

@@ -1 +0,0 @@
-export * from './getInvoiceForEscrow.ts'

package/src/Subtotal/Diviner.ts

@@ -1,65 +0,0 @@
-import { AbstractDiviner } from '@xyo-network/diviner-abstract'
-import { HashLeaseEstimate, isHashLeaseEstimate } from '@xyo-network/diviner-hash-lease'
-import { DivinerInstance, DivinerModuleEventData } from '@xyo-network/diviner-model'
-import { creatableModule } from '@xyo-network/module-model'
-import { Payload } from '@xyo-network/payload-model'
-import {
-  EscrowTerms, isEscrowTerms, PaymentSubtotalDivinerConfigSchema, PaymentSubtotalDivinerParams, Subtotal, SubtotalSchema,
-} from '@xyo-network/payment-payload-plugins'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-
-import {
-  appraisalValidators, termsValidators, ValidEscrowTerms,
-} from './lib/index.ts'
-
-const currency = 'USD'
-
-/**
- * Escrow terms that contain all the valid fields for calculating a subtotal
- */
-export type PaymentSubtotalDivinerInputType = EscrowTerms | HashLeaseEstimate | Payload
-
-@creatableModule()
-export class PaymentSubtotalDiviner<
-  TParams extends PaymentSubtotalDivinerParams = PaymentSubtotalDivinerParams,
-  TIn extends PaymentSubtotalDivinerInputType = PaymentSubtotalDivinerInputType,
-  TOut extends Subtotal = Subtotal,
-  TEventData extends DivinerModuleEventData<DivinerInstance<TParams, TIn, TOut>, TIn, TOut> = DivinerModuleEventData<
-    DivinerInstance<TParams, TIn, TOut>,
-    TIn,
-    TOut
-  >,
-> extends AbstractDiviner<TParams, TIn, TOut, TEventData> {
-  static override readonly configSchemas = [PaymentSubtotalDivinerConfigSchema]
-  static override readonly defaultConfigSchema = PaymentSubtotalDivinerConfigSchema
-
-  protected async divineHandler(payloads: TIn[] = []): Promise<TOut[]> {
-    // Find the escrow terms
-    const terms = payloads.find(isEscrowTerms) as EscrowTerms | undefined
-    if (!terms) return []
-
-    // Run all terms validations
-    if (!termsValidators.every(validator => validator(terms))) return []
-    const validTerms = terms as ValidEscrowTerms
-
-    // Retrieve all appraisals from terms
-    const hashMap = await PayloadBuilder.toAllHashMap(payloads)
-    const appraisals = validTerms.appraisals.map(appraisal => hashMap[appraisal]).filter(isHashLeaseEstimate) as unknown as HashLeaseEstimate[]
-
-    // Ensure all appraisals are present
-    if (appraisals.length !== validTerms.appraisals.length) return []
-
-    // Run all appraisal validations
-    if (!appraisalValidators.every(validator => validator(appraisals))) return []
-    const amount = calculateSubtotal(appraisals)
-    const $sources = [await PayloadBuilder.dataHash(validTerms), ...validTerms.appraisals]
-    return [{
-      amount, currency, schema: SubtotalSchema, $sources,
-    }] as TOut[]
-  }
-}
-
-// TODO: Add support for other currencies
-const calculateSubtotal = (appraisals: HashLeaseEstimate[]): number => {
-  return appraisals.reduce((sum, appraisal) => sum + appraisal.price, 0)
-}

package/src/Subtotal/index.ts

@@ -1 +0,0 @@
-export * from './Diviner.ts'

package/src/Subtotal/lib/appraisalValidators.ts

@@ -1,40 +0,0 @@
-import type { HashLeaseEstimate } from '@xyo-network/diviner-hash-lease'
-import { isIso4217CurrencyCode } from '@xyo-network/payment-payload-plugins'
-
-import { validateDuration } from './durationValidators.ts'
-
-const validateAppraisalAmount = (appraisals: HashLeaseEstimate[]): boolean => {
-  // Ensure all appraisals are numeric
-  if (appraisals.some(appraisal => typeof appraisal.price !== 'number')) return false
-  // Ensure all appraisals are positive numbers
-  return !(appraisals.some(appraisal => appraisal.price < 0))
-}
-
-const validateAppraisalCurrency = (appraisals: HashLeaseEstimate[]): boolean => {
-  // Only supporting USD for now, the remaining checks are for future-proofing.
-  if (!appraisals.every(appraisal => appraisal.currency == 'USD')) return false
-
-  // Check every object in the array to ensure they all are in a supported currency.
-  return (appraisals.every(appraisal => isIso4217CurrencyCode(appraisal.currency)))
-}
-
-const validateAppraisalConsistentCurrency = (appraisals: HashLeaseEstimate[]): boolean => {
-  // Check if the array is empty or contains only one element, no need to compare.
-  if (appraisals.length <= 1) return true
-
-  // Get the currency of the first element to compare with others.
-  const { currency } = appraisals[0]
-  if (!currency) return false
-
-  // Check every object in the array to ensure they all have the same currency.
-  return (appraisals.every(item => item.currency === currency))
-}
-
-const validateAppraisalWindow = (appraisals: HashLeaseEstimate[]): boolean => appraisals.every(validateDuration)
-
-export const appraisalValidators = [
-  validateAppraisalAmount,
-  validateAppraisalCurrency,
-  validateAppraisalConsistentCurrency,
-  validateAppraisalWindow,
-]

package/src/Subtotal/lib/durationValidators.ts

@@ -1,17 +0,0 @@
-import type { DurationFields } from '@xyo-network/xns-record-payload-plugins'
-
-const FIVE_MINUTES = 1000 * 60 * 5
-
-/**
- * Validates that the current time is within the duration window, within a configurable a buffer
- * @param value The duration value
- * @param windowMs The window in milliseconds to allow for a buffer
- * @returns True if the duration is valid, false otherwise
- */
-export const validateDuration = (value: Partial<DurationFields>, windowMs = FIVE_MINUTES): boolean => {
-  const now = Date.now()
-  if (!value.nbf || value.nbf > now) return false
-  // If already expired (include for a 5 minute buffer to allow for a reasonable
-  // minimum amount of time for the transaction to be processed)
-  return !(!value.exp || value.exp - now < windowMs)
-}

package/src/Subtotal/lib/index.ts

@@ -1,2 +0,0 @@
-export * from './appraisalValidators.ts'
-export * from './termsValidators.ts'

package/src/Subtotal/lib/termsValidators.ts

@@ -1,17 +0,0 @@
-import type { Hash } from '@xylabs/sdk-js'
-import type { EscrowTerms } from '@xyo-network/payment-payload-plugins'
-
-import { validateDuration } from './durationValidators.ts'
-
-export type ValidEscrowTerms = Required<EscrowTerms>
-
-const validateTermsAppraisals = (terms: EscrowTerms): terms is Required<EscrowTerms & { appraisals: Hash[] }> => {
-  if (!terms.appraisals) return false
-  return terms.appraisals.length > 0
-}
-const validateTermsWindow = (terms: EscrowTerms): boolean => validateDuration(terms)
-
-export const termsValidators = [
-  validateTermsAppraisals,
-  validateTermsWindow,
-]

package/src/Total/Diviner.ts

@@ -1,67 +0,0 @@
-import { assertEx, Hash } from '@xylabs/sdk-js'
-import { AbstractDiviner } from '@xyo-network/diviner-abstract'
-import {
-  asDivinerInstance, DivinerInstance, DivinerModuleEventData,
-} from '@xyo-network/diviner-model'
-import { creatableModule } from '@xyo-network/module-model'
-import {
-  Discount,
-  isDiscount,
-  isSubtotal,
-  PaymentTotalDivinerConfigSchema, PaymentTotalDivinerParams, Subtotal, Total, TotalSchema,
-} from '@xyo-network/payment-payload-plugins'
-import { PayloadBuilder } from '@xyo-network/sdk-js'
-
-import { PaymentDiscountDiviner, PaymentDiscountDivinerInputType } from '../Discount/index.ts'
-import { PaymentSubtotalDiviner, PaymentSubtotalDivinerInputType } from '../Subtotal/index.ts'
-
-type InputType = PaymentDiscountDivinerInputType | PaymentSubtotalDivinerInputType
-type OutputType = Subtotal | Discount | Total
-
-@creatableModule()
-export class PaymentTotalDiviner<
-  TParams extends PaymentTotalDivinerParams = PaymentTotalDivinerParams,
-  TIn extends InputType = InputType,
-  TOut extends OutputType = OutputType,
-  TEventData extends DivinerModuleEventData<DivinerInstance<TParams, TIn, TOut>, TIn, TOut> = DivinerModuleEventData<
-    DivinerInstance<TParams, TIn, TOut>,
-    TIn,
-    TOut
-  >,
-> extends AbstractDiviner<TParams, TIn, TOut, TEventData> {
-  static override readonly configSchemas = [PaymentTotalDivinerConfigSchema]
-  static override readonly defaultConfigSchema: PaymentTotalDivinerConfigSchema = PaymentTotalDivinerConfigSchema
-
-  protected async divineHandler(payloads: TIn[] = []): Promise<TOut[]> {
-    const subtotalDiviner = await this.getPaymentSubtotalDiviner()
-    const subtotalResult = await subtotalDiviner.divine(payloads)
-    const subtotal = subtotalResult.find(isSubtotal)
-    if (!subtotal) return []
-    const discountDiviner = await this.getPaymentDiscountsDiviner()
-    const discountResult = await discountDiviner.divine(payloads)
-    const discount = discountResult.find(isDiscount)
-    if (!discount) return []
-    const { currency: subtotalCurrency } = subtotal
-    const { currency: discountCurrency } = discount
-    assertEx(subtotalCurrency === discountCurrency, () => `Subtotal currency ${subtotalCurrency} does not match discount currency ${discountCurrency}`)
-    const amount = Math.max(0, subtotal.amount - discount.amount)
-    const currency = subtotalCurrency
-    const $sources = [await PayloadBuilder.dataHash(subtotal), await PayloadBuilder.dataHash(discount)] as Hash[]
-    const total: Total = {
-      amount, currency, $sources, schema: TotalSchema,
-    }
-    return [subtotal, discount, total] as TOut[]
-  }
-
-  protected async getPaymentDiscountsDiviner(): Promise<PaymentDiscountDiviner> {
-    const name = assertEx(this.config.paymentDiscountDiviner, () => 'Missing paymentDiscountDiviner in config')
-    const mod = assertEx(await this.resolve(name), () => `Error resolving paymentDiscountDiviner: ${name}`)
-    return assertEx(asDivinerInstance(mod), () => `Resolved module ${mod.address} not a valid Diviner`) as PaymentDiscountDiviner
-  }
-
-  protected async getPaymentSubtotalDiviner(): Promise<PaymentSubtotalDiviner> {
-    const name = assertEx(this.config.paymentSubtotalDiviner, () => 'Missing paymentSubtotalDiviner in config')
-    const mod = assertEx(await this.resolve(name), () => `Error resolving paymentSubtotalDiviner: ${name}`)
-    return assertEx(asDivinerInstance(mod), () => `Resolved module ${mod.address} not a valid Diviner`) as PaymentSubtotalDiviner
-  }
-}

package/src/Total/index.ts

@@ -1 +0,0 @@
-export * from './Diviner.ts'

package/src/index.ts

@@ -1,4 +0,0 @@
-export * from './Discount/index.ts'
-export * from './Invoice/index.ts'
-export * from './Subtotal/index.ts'
-export * from './Total/index.ts'