@xyo-network/payment-payload-plugins 2.91.5 → 2.91.7

package/src/Escrow/validators/common/TemporalValidators/validateWithinWindow.ts

@@ -0,0 +1,7 @@
+export type Windowed = { exp?: number; nbf?: number }
+
+export const validateWithinWindow = (value: Windowed, exp: number, nbf: number = Date.now()): boolean => {
+  if (value.nbf === undefined || value.nbf > nbf) return false
+  if (value.exp === undefined || value.exp < exp) return false
+  return true
+}

package/src/Escrow/validators/common/index.ts

@@ -0,0 +1,2 @@
+export * from './ModuleInstanceValidators'
+export * from './TemporalValidators'

package/src/Escrow/validators/escrow/agent.ts

@@ -0,0 +1,17 @@
+import { ModuleIdentifier } from '@xyo-network/module-model'
+
+import { EscrowTerms } from '../../Terms'
+import { moduleIdentifiersContainsOneOf } from '../common'
+import { EscrowTermsValidationFunction } from '../types'
+
+const name = 'EscrowTerms.escrowAgent'
+
+export const getEscrowAgentAllowedValidator = (allowedEscrowAgent: ModuleIdentifier): EscrowTermsValidationFunction => {
+  return (terms: EscrowTerms) => {
+    const result = moduleIdentifiersContainsOneOf(terms, (t) => t.escrowAgent, [allowedEscrowAgent], true)
+    if (!result) {
+      console.log(`${name}: Escrow agent not allowed: ${terms.escrowAgent}`)
+    }
+    return result
+  }
+}

package/src/Escrow/validators/escrow/appraisal.ts

@@ -0,0 +1,129 @@
+import { assertEx } from '@xylabs/assert'
+import { Hash } from '@xylabs/hex'
+import { BoundWitness, isBoundWitnessWithMeta } from '@xyo-network/boundwitness-model'
+import { HashLeaseEstimate, isHashLeaseEstimateWithSources } from '@xyo-network/diviner-hash-lease'
+import { Payload, WithMeta, WithSources } from '@xyo-network/payload-model'
+
+import { EscrowTerms } from '../../Terms'
+import { validateWithinWindow } from '../common'
+import { EscrowTermsValidationFunction } from '../types'
+
+const name = 'EscrowTerms.appraisal'
+
+/**
+ * A function that validates the escrow terms for tbe existence of appraisals
+ * @returns True if the escrow terms contain appraisals, false otherwise
+ */
+export const appraisalsExistValidator: EscrowTermsValidationFunction = (terms: EscrowTerms) => {
+  // Validate we have appraisals
+  const appraisals = terms.appraisals
+  if (!appraisals || appraisals.length === 0) {
+    console.log(`${name}: No appraisals: ${terms.appraisals}`)
+    return false
+  }
+  return true
+}
+
+/**
+ * Returns a function that validates the escrow terms for appraisals which are from valid authorities
+ * @param dictionary Payload dictionary of the escrow terms
+ * @returns A function that validates the escrow terms for appraisals which are from valid authorities
+ */
+export const getAppraisalsFromValidAuthoritiesValidator = (dictionary: Record<Hash, WithMeta<Payload>>): EscrowTermsValidationFunction => {
+  return (terms: EscrowTerms) => {
+    const appraisals = assertEx(terms.appraisals, () => `${name}: No appraisals: ${terms.appraisals}`)
+    const appraisalAuthorities = assertEx(terms.appraisalAuthorities, () => `${name}: No appraisalAuthorities: ${terms.appraisalAuthorities}`)
+
+    // Validate the appraisals are signed by valid appraisal authorities. Validation criteria:
+    // - We have a bw for each of the appraisal
+    // - The bw is signed by an approved appraisal authority
+    const appraisalBWsValid: Record<Hash, WithMeta<BoundWitness>[]> = Object.fromEntries(
+      appraisals.map<[Hash, WithMeta<BoundWitness>[]]>((hash) => [hash, []]),
+    )
+    for (const bw of Object.values(dictionary).filter(isBoundWitnessWithMeta)) {
+      for (const appraisal of appraisals) {
+        if (bw.payload_hashes.includes(appraisal) && bw.addresses.some((address) => appraisalAuthorities.includes(address))) {
+          appraisalBWsValid[appraisal].push(bw)
+        }
+      }
+    }
+    for (const [appraisal, bws] of Object.entries(appraisalBWsValid)) {
+      if (bws.length === 0) {
+        console.log(`${name}: No valid appraisals for ${appraisal}`)
+        return false
+      }
+    }
+    return true
+  }
+}
+
+/**
+ * Returns a function that validates the escrow terms for appraisals which are valid
+ * @param dictionary Payload dictionary of the escrow terms
+ * @param minimumExp The minium amount of time an estimate needs to be valid
+ * for in the future (so as not to expire before the escrow is complete)
+ * @returns A function that validates the escrow terms for appraisals which are valid
+ */
+export const getAppraisalsValidValidator = (dictionary: Record<Hash, WithMeta<Payload>>, minimumExp: number): EscrowTermsValidationFunction => {
+  return (terms: EscrowTerms) => {
+    // Verify we have an estimate for each of the assets
+    const estimatesByAsset = getEstimatesByAsset(terms, dictionary)
+    // Validate each of the estimates are valid (time, price, etc)
+    const now = Date.now()
+    const exp = now + minimumExp
+    for (const [asset, estimates] of Object.entries(estimatesByAsset)) {
+      for (const estimate of estimates) {
+        if (!validateEstimate(estimate, exp)) {
+          console.log(`${name}: Invalid estimate for asset ${asset}: ${estimate}`)
+          return false
+        }
+      }
+    }
+    return true
+  }
+}
+
+/**
+ * Returns a function that validates the escrow terms to ensure that they contain an appraisal for each asset
+ * @param dictionary Payload dictionary of the escrow terms
+ * @returns A function that validates the escrow terms for appraisals
+ */
+export const getAppraisalsForAllAssetsValidator = (dictionary: Record<Hash, WithMeta<Payload>>): EscrowTermsValidationFunction => {
+  return (terms: EscrowTerms) => {
+    // Verify we have an estimate for each of the assets
+    const estimatesByAsset = getEstimatesByAsset(terms, dictionary)
+    const assets = assertEx(terms.assets, () => `${name}: No assets: ${terms.assets}`)
+    if (Object.keys(estimatesByAsset).length !== assets.length) {
+      console.log(`${name}: Missing appraisals for all assets: ${assets}`)
+      return false
+    }
+    return true
+  }
+}
+
+const validateEstimate = (estimate: WithSources<HashLeaseEstimate>, exp: number): boolean => {
+  if (!validateWithinWindow(estimate, exp)) return false
+  if (estimate.currency !== 'USD') return false
+  if (estimate.price <= 0) return false
+  return true
+}
+
+const getEstimatesByAsset = (terms: EscrowTerms, dictionary: Record<Hash, WithMeta<Payload>>): Record<Hash, WithSources<HashLeaseEstimate>[]> => {
+  const assets = assertEx(terms.assets, () => `${name}: No assets: ${terms.assets}`)
+  const estimates = Object.values(dictionary).filter(isHashLeaseEstimateWithSources) as unknown as WithSources<HashLeaseEstimate>[]
+  const estimatesByAsset: Record<Hash, WithSources<HashLeaseEstimate>[]> = {}
+  for (const estimate of estimates) {
+    const { sources } = estimate
+    if (sources === undefined || sources.length === 0) {
+      console.log(`${name}: No sources: ${estimate}`)
+      continue
+    }
+    for (const asset of assets) {
+      if (sources.includes(asset)) {
+        if (!estimatesByAsset[asset]) estimatesByAsset[asset] = []
+        estimatesByAsset[asset].push(estimate)
+      }
+    }
+  }
+  return estimatesByAsset
+}

package/src/Escrow/validators/escrow/appraisalAuthorities.ts

@@ -0,0 +1,37 @@
+import { asAddress } from '@xylabs/hex'
+import { ModuleIdentifier } from '@xyo-network/module-model'
+
+import { EscrowTerms } from '../../Terms'
+import { moduleIdentifiersContainsAllOf } from '../common'
+import { EscrowTermsValidationFunction } from '../types'
+
+const name = 'EscrowTerms.appraisalAuthorities'
+
+/**
+ * A function that validates the escrow terms for appraisalAuthorities
+ * @returns True if the escrow terms contain appraisalAuthorities, false otherwise
+ */
+export const appraisalAuthoritiesExistValidator: EscrowTermsValidationFunction = (terms: EscrowTerms) => {
+  // Validate we have appraisalAuthorities
+  const appraisalAuthorities = terms.appraisalAuthorities
+  if (!appraisalAuthorities || appraisalAuthorities.length === 0) {
+    console.log(`${name}: No appraisalAuthorities: ${terms.appraisalAuthorities}`)
+    return false
+  }
+  // Validate the authorities are addresses
+  if (appraisalAuthorities.map((x) => asAddress(x)).length !== appraisalAuthorities.length) {
+    console.log(`${name}: Invalid address: ${terms.appraisalAuthorities}`)
+    return false
+  }
+  return true
+}
+
+export const getAppraisalAuthoritiesAllowedValidator = (allowed: ModuleIdentifier[]): EscrowTermsValidationFunction => {
+  return (terms: EscrowTerms) => {
+    const result = moduleIdentifiersContainsAllOf(terms, (t) => t.appraisalAuthorities, allowed, true)
+    if (!result) {
+      console.log(`${name}: Appraisal authority not allowed: ${terms.appraisalAuthorities}`)
+    }
+    return result
+  }
+}

package/src/Escrow/validators/escrow/assets.ts

@@ -0,0 +1,18 @@
+import { EscrowTerms } from '../../Terms'
+import { EscrowTermsValidationFunction } from '../types'
+
+const name = 'EscrowTerms.assets'
+
+/**
+ * Returns a function that validates the escrow terms for assets
+ * @returns A function that validates the escrow terms for assets
+ */
+export const assetsExistValidator: EscrowTermsValidationFunction = (terms: EscrowTerms) => {
+  // Validate we have assets
+  const assets = terms.assets
+  if (!assets || assets.length === 0) {
+    console.log(`${name}: No assets: ${terms.assets}`)
+    return false
+  }
+  return true
+}

package/src/Escrow/validators/escrow/buyer.ts

@@ -0,0 +1,25 @@
+import { asAddress } from '@xylabs/hex'
+
+import { EscrowTerms } from '../../Terms'
+import { EscrowTermsValidationFunction } from '../types'
+
+const name = 'EscrowTerms.buyer'
+
+/**
+ * A function that validates the escrow terms for buyer
+ * @returns True if the escrow terms contain buyer, false otherwise
+ */
+export const buyerExistsValidator: EscrowTermsValidationFunction = (terms: EscrowTerms) => {
+  // Validate we have buyer
+  const buyer = terms.buyer
+  if (!buyer || buyer.length === 0) {
+    console.log(`${name}: No buyer: ${terms.buyer}`)
+    return false
+  }
+  // Validate the authorities are addresses
+  if (buyer.map((x) => asAddress(x)).length !== buyer.length) {
+    console.log(`${name}: Invalid address: ${terms.buyer}`)
+    return false
+  }
+  return true
+}

package/src/Escrow/validators/escrow/buyerSecret.ts

@@ -0,0 +1,75 @@
+import { assertEx } from '@xylabs/assert'
+import { Hash } from '@xylabs/hex'
+import { isBoundWitnessWithMeta } from '@xyo-network/boundwitness-model'
+import { BoundWitnessValidator } from '@xyo-network/boundwitness-validator'
+import { Payload, WithMeta } from '@xyo-network/payload-model'
+
+import { EscrowTerms } from '../../Terms'
+import { EscrowTermsValidationFunction } from '../types'
+
+const name = 'EscrowTerms.buyerSecret'
+
+/**
+ * Returns a function that validates the escrow terms for buyerSecret
+ * @returns A function that validates the escrow terms for buyerSecret
+ */
+export const buyerSecretExistsValidator: EscrowTermsValidationFunction = (terms: EscrowTerms) => {
+  // Validate we have buyerSecret
+  const buyerSecret = terms.buyerSecret
+  if (!buyerSecret || buyerSecret.length === 0) {
+    console.log(`${name}: No buyerSecret: ${terms.buyerSecret}`)
+    return false
+  }
+  return true
+}
+
+/**
+ * Returns a function that validates the escrow terms for the existence of the buyerSecret in the dictionary
+ * @param dictionary Payload dictionary of the escrow terms
+ * @returns A function that validates the escrow terms for the existence of the buyerSecret in the dictionary
+ */
+export const getBuyerSecretSuppliedValidator = (dictionary: Record<Hash, WithMeta<Payload>>): EscrowTermsValidationFunction => {
+  return (terms: EscrowTerms) => {
+    const buyerSecret = assertEx(terms.buyerSecret, () => `${name}: No buyerSecret: ${terms.buyerSecret}`)
+    if (!dictionary[buyerSecret]) {
+      console.log(`${name}: Payload not supplied for buyerSecret: ${buyerSecret}`)
+      return false
+    }
+    return true
+  }
+}
+
+/**
+ * Returns a function that validates the escrow terms for the existence of the buyerSecret signed by the buyer
+ * @param dictionary Payload dictionary of the escrow terms
+ * @returns A function that validates the escrow terms for the existence of the buyerSecret signed by the buyer
+ */
+export const getBuyerSecretSignedValidator = (dictionary: Record<Hash, WithMeta<Payload>>): EscrowTermsValidationFunction => {
+  return async (terms: EscrowTerms) => {
+    const buyer = assertEx(terms.buyer, () => `${name}: No buyer: ${terms.buyer}`)
+    const buyerSecret = assertEx(terms.buyerSecret, () => `${name}: No buyerSecret: ${terms.buyerSecret}`)
+    // Buyer-signed buyer secrets
+    const buyerSecretBWs = Object.values(dictionary)
+      // Find all BoundWitnesses
+      .filter(isBoundWitnessWithMeta)
+      // That contain the buyer secret
+      .filter((bw) => bw.payload_hashes.includes(buyerSecret))
+      // That are signed by all the buyers
+      .filter((bw) => buyer.every((buyerAddress) => bw.addresses.includes(buyerAddress)))
+
+    // If there are no buyerSecret BWs, return false
+    if (buyerSecretBWs.length === 0) {
+      console.log(`${name}: No BoundWitnesses supplied for buyerSecret: ${buyerSecret}`)
+      return false
+    }
+
+    // Ensure each BW supplied for the buyerSecret is valid
+    const errors = await Promise.all(buyerSecretBWs.map((bw) => new BoundWitnessValidator(bw).validate()))
+    const validBoundWitnesses = errors.every((errors) => errors.length === 0)
+    if (!validBoundWitnesses) {
+      console.log(`${name}: Invalid BoundWitnesses supplied for buyerSecret: ${buyerSecret}`)
+      return false
+    }
+    return true
+  }
+}

package/src/Escrow/validators/escrow/index.ts

@@ -0,0 +1,10 @@
+export * from './agent'
+export * from './appraisal'
+export * from './appraisalAuthorities'
+export * from './assets'
+export * from './buyer'
+export * from './buyerSecret'
+export * from './nbfExp'
+export * from './paymentAuthorities'
+export * from './seller'
+export * from './sellerSecret'

package/src/Escrow/validators/escrow/nbfExp.ts

@@ -0,0 +1,18 @@
+import { EscrowTerms } from '../../Terms'
+import { EscrowTermsValidationFunction } from '../types'
+
+export const getNbfExpValidator = (now: number, minRequiredDuration: number): EscrowTermsValidationFunction => {
+  const minExp = now + minRequiredDuration
+  return (terms: EscrowTerms) => {
+    const { exp, nbf } = terms
+    if (nbf === undefined || nbf < now) {
+      console.log(`EscrowTerms.nbf: invalid nbf ${terms.nbf}`)
+      return false
+    }
+    if (exp === undefined || exp < minExp || nbf > exp) {
+      console.log(`EscrowTerms.exp: invalid exp ${terms.exp}`)
+      return false
+    }
+    return true
+  }
+}

package/src/Escrow/validators/escrow/paymentAuthorities.ts

@@ -0,0 +1,17 @@
+import { ModuleIdentifier } from '@xyo-network/module-model'
+
+import { EscrowTerms } from '../../Terms'
+import { moduleIdentifiersContainsAllOf } from '../common'
+import { EscrowTermsValidationFunction } from '../types'
+
+const name = 'EscrowTerms.paymentAuthorities'
+
+export const getPaymentAuthoritiesAllowedValidator = (allowed: ModuleIdentifier[]): EscrowTermsValidationFunction => {
+  return (terms: EscrowTerms) => {
+    const result = moduleIdentifiersContainsAllOf(terms, (t) => t.paymentAuthorities, allowed, true)
+    if (!result) {
+      console.log(`${name}: Payment authority not allowed: ${terms.paymentAuthorities}`)
+    }
+    return result
+  }
+}

package/src/Escrow/validators/escrow/seller.ts

@@ -0,0 +1,25 @@
+import { asAddress } from '@xylabs/hex'
+
+import { EscrowTerms } from '../../Terms'
+import { EscrowTermsValidationFunction } from '../types'
+
+const name = 'EscrowTerms.seller'
+
+/**
+ * A function that validates the escrow terms for seller
+ * @returns True if the escrow terms contain seller, false otherwise
+ */
+export const sellerExistsValidator: EscrowTermsValidationFunction = (terms: EscrowTerms) => {
+  // Validate we have seller
+  const seller = terms.seller
+  if (!seller || seller.length === 0) {
+    console.log(`${name}: No seller: ${terms.seller}`)
+    return false
+  }
+  // Validate the authorities are addresses
+  if (seller.map((x) => asAddress(x)).length !== seller.length) {
+    console.log(`${name}: Invalid address: ${terms.seller}`)
+    return false
+  }
+  return true
+}

package/src/Escrow/validators/escrow/sellerSecret.ts

@@ -0,0 +1,75 @@
+import { assertEx } from '@xylabs/assert'
+import { Hash } from '@xylabs/hex'
+import { isBoundWitnessWithMeta } from '@xyo-network/boundwitness-model'
+import { BoundWitnessValidator } from '@xyo-network/boundwitness-validator'
+import { Payload, WithMeta } from '@xyo-network/payload-model'
+
+import { EscrowTerms } from '../../Terms'
+import { EscrowTermsValidationFunction } from '../types'
+
+const name = 'EscrowTerms.sellerSecret'
+
+/**
+ * Returns a function that validates the escrow terms for sellerSecret
+ * @returns A function that validates the escrow terms for sellerSecret
+ */
+export const sellerSecretExistsValidator: EscrowTermsValidationFunction = (terms: EscrowTerms) => {
+  // Validate we have sellerSecret
+  const sellerSecret = terms.sellerSecret
+  if (!sellerSecret || sellerSecret.length === 0) {
+    console.log(`${name}: No sellerSecret: ${terms.sellerSecret}`)
+    return false
+  }
+  return true
+}
+
+/**
+ * Returns a function that validates the escrow terms for the existence of the sellerSecret in the dictionary
+ * @param dictionary Payload dictionary of the escrow terms
+ * @returns A function that validates the escrow terms for the existence of the sellerSecret in the dictionary
+ */
+export const getSellerSecretSuppliedValidator = (dictionary: Record<Hash, WithMeta<Payload>>): EscrowTermsValidationFunction => {
+  return (terms: EscrowTerms) => {
+    const sellerSecret = assertEx(terms.sellerSecret, () => `${name}: No sellerSecret: ${terms.sellerSecret}`)
+    if (!dictionary[sellerSecret]) {
+      console.log(`${name}: Payload not supplied for sellerSecret: ${sellerSecret}`)
+      return false
+    }
+    return true
+  }
+}
+
+/**
+ * Returns a function that validates the escrow terms for the existence of the sellerSecret signed by the seller
+ * @param dictionary Payload dictionary of the escrow terms
+ * @returns A function that validates the escrow terms for the existence of the sellerSecret signed by the seller
+ */
+export const getSellerSecretSignedValidator = (dictionary: Record<Hash, WithMeta<Payload>>): EscrowTermsValidationFunction => {
+  return async (terms: EscrowTerms) => {
+    const seller = assertEx(terms.seller, () => `${name}: No seller: ${terms.seller}`)
+    const sellerSecret = assertEx(terms.sellerSecret, () => `${name}: No sellerSecret: ${terms.sellerSecret}`)
+    // Seller-signed seller secrets
+    const sellerSecretBWs = Object.values(dictionary)
+      // Find all BoundWitnesses
+      .filter(isBoundWitnessWithMeta)
+      // That contain the seller secret
+      .filter((bw) => bw.payload_hashes.includes(sellerSecret))
+      // That are signed by all the sellers
+      .filter((bw) => seller.every((sellerAddress) => bw.addresses.includes(sellerAddress)))
+
+    // If there are no sellerSecret BWs, return false
+    if (sellerSecretBWs.length === 0) {
+      console.log(`${name}: No BoundWitnesses supplied for sellerSecret: ${sellerSecret}`)
+      return false
+    }
+
+    // Ensure each BW supplied for the sellerSecret is valid
+    const errors = await Promise.all(sellerSecretBWs.map((bw) => new BoundWitnessValidator(bw).validate()))
+    const validBoundWitnesses = errors.every((errors) => errors.length === 0)
+    if (!validBoundWitnesses) {
+      console.log(`${name}: Invalid BoundWitnesses supplied for sellerSecret: ${sellerSecret}`)
+      return false
+    }
+    return true
+  }
+}

package/src/Escrow/validators/index.ts

@@ -0,0 +1,3 @@
+export * from './common'
+export * from './escrow'
+export * from './types'

package/src/Escrow/validators/types/escrowValidation.ts

@@ -0,0 +1,30 @@
+import { EscrowTerms } from '../../Terms'
+
+/**
+ * Type corresponding to the escrow terms properties
+ */
+export type EscrowTermsProperty = keyof EscrowTerms
+
+/**
+ * Type corresponding to the escrow terms property value
+ */
+export type EscrowTermsValue<K extends EscrowTermsProperty> = EscrowTerms[K]
+
+/**
+ * An expressions that selects a property value from the escrow terms
+ */
+export type EscrowTermsValueExpression<
+  /**
+   * The property of the escrow terms to select
+   */
+  K extends EscrowTermsProperty,
+  /**
+   * The type of the selected property's value
+   */
+  V = EscrowTermsValue<K>,
+> = (escrowTerms: EscrowTerms) => V
+
+/**
+ * A function that validates the supplied escrow terms
+ */
+export type EscrowTermsValidationFunction = (escrowTerms: EscrowTerms) => boolean | Promise<boolean>

package/src/Escrow/validators/types/index.ts

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