@xyo-network/payment-payload-plugins 5.3.1 → 5.3.3

package/src/Discount/Payload/Coupon/Conditions/AppraisalAmountCondition.ts

@@ -1,43 +0,0 @@
-/* eslint-disable unicorn/no-thenable */
-import { SchemaSchema } from '@xyo-network/schema-payload-plugin'
-
-import type { Condition } from '../types/index.ts'
-
-/**
- * Creates a coupon condition that requires an appraisal amount below a certain value
- * @param maximumAppraisalAmount The maximum appraisal amount
- * @returns A condition that requires an appraisal amount below a certain value
- */
-export const createConditionForMaximumAppraisalAmount = (maximumAppraisalAmount: number): Condition => {
-  return {
-    schema: SchemaSchema,
-    definition: {
-      allOf: [
-        {
-          type: 'array',
-          contains: {
-            type: 'object',
-            properties: {
-              schema: { type: 'string', const: 'network.xyo.escrow.terms' },
-              appraisals: { type: 'array', minItems: 1 },
-            },
-            required: ['schema', 'appraisals'],
-          },
-        },
-        {
-          type: 'array',
-          contains: {
-            type: 'object',
-            properties: { schema: { type: 'string', const: 'network.xyo.hash.lease.estimate' } },
-            required: ['schema'],
-          },
-          items: {
-            type: 'object',
-            if: { properties: { schema: { type: 'string', const: 'network.xyo.hash.lease.estimate' } } },
-            then: { properties: { price: { type: 'number', maximum: maximumAppraisalAmount } }, required: ['price'] },
-          },
-        },
-      ],
-    },
-  }
-}

package/src/Discount/Payload/Coupon/Conditions/AssetQuantityCondition.ts

@@ -1,25 +0,0 @@
-import { SchemaSchema } from '@xyo-network/schema-payload-plugin'
-
-import type { Condition } from '../types/index.ts'
-
-/**
- * Returns a coupon condition that requires a minimum quantity of assets
- * @param minimumAssetQuantity The minimum quantity of assets required
- * @returns A condition that requires a minimum quantity of assets
- */
-export const createConditionForMinimumAssetQuantity = (minimumAssetQuantity: number): Condition => {
-  return {
-    schema: SchemaSchema,
-    definition: {
-      type: 'array',
-      contains: {
-        type: 'object',
-        properties: {
-          schema: { type: 'string', const: 'network.xyo.escrow.terms' },
-          assets: { type: 'array', minItems: minimumAssetQuantity },
-        },
-        required: ['schema', 'assets'],
-      },
-    },
-  }
-}

package/src/Discount/Payload/Coupon/Conditions/BuyerCondition.ts

@@ -1,50 +0,0 @@
-import type { Address } from '@xylabs/hex'
-import { SchemaSchema } from '@xyo-network/schema-payload-plugin'
-
-import type { Condition } from '../types/index.ts'
-
-export type BuyerCondition = Condition & {
-  definition: {
-    contains: {
-      properties: {
-        buyer: {
-          items: {
-            const: Address
-            type: 'string'
-          }
-          minItems: 1
-          type: 'array'
-        }
-        schema: { const: 'network.xyo.escrow.terms'; type: 'string' }
-      }
-      required: ['schema', 'buyer']
-      type: 'object'
-    }
-    type: 'array'
-  }
-  schema: SchemaSchema
-}
-
-/**
- * Creates a coupon condition that requires a specific buyer
- * @param buyer The buyer's address
- * @returns A coupon condition that requires a specific buyer
- */
-export const createConditionForRequiredBuyer = (buyer: Address): BuyerCondition => {
-  return {
-    schema: SchemaSchema,
-    definition: {
-      type: 'array',
-      contains: {
-        type: 'object',
-        properties: {
-          schema: { type: 'string', const: 'network.xyo.escrow.terms' },
-          buyer: {
-            type: 'array', items: { type: 'string', const: buyer }, minItems: 1,
-          },
-        },
-        required: ['schema', 'buyer'],
-      },
-    },
-  }
-}

package/src/Discount/Payload/Coupon/Conditions/index.ts

@@ -1,3 +0,0 @@
-export * from './AppraisalAmountCondition.ts'
-export * from './AssetQuantityCondition.ts'
-export * from './BuyerCondition.ts'

package/src/Discount/Payload/Coupon/Coupons/FixedAmount.ts

@@ -1,35 +0,0 @@
-import { AsObjectFactory } from '@xylabs/object'
-import type { Payload, WithSources } from '@xyo-network/payload-model'
-import {
-  asSchema,
-  isPayloadOfSchemaType,
-  isPayloadOfSchemaTypeWithSources,
-} from '@xyo-network/payload-model'
-
-import type { AmountFields } from '../../../../Amount/index.ts'
-import { CouponSchema } from '../Schema.ts'
-import type { CouponFields } from '../types/index.ts'
-
-export const FixedAmountCouponSchema = asSchema(`${CouponSchema}.fixed.amount`, true)
-export type FixedAmountCouponSchema = typeof FixedAmountCouponSchema
-
-export interface FixedAmountCouponFields extends CouponFields, AmountFields {}
-
-/**
- * A coupon that provides a fixed discount amount
- */
-export type FixedAmountCoupon = Payload<FixedAmountCouponFields, FixedAmountCouponSchema>
-
-/**
- * Identity function for determining if an object is an FixedAmountCoupon
- */
-export const isFixedAmountCoupon = isPayloadOfSchemaType<FixedAmountCoupon>(FixedAmountCouponSchema)
-export const asFixedAmountCoupon = AsObjectFactory.create<FixedAmountCoupon>(isFixedAmountCoupon)
-export const asOptionalFixedAmountCoupon = AsObjectFactory.createOptional<FixedAmountCoupon>(isFixedAmountCoupon)
-
-/**
- * Identity function for determining if an object is an FixedAmountCoupon with sources
-*/
-export const isFixedAmountCouponWithSources = isPayloadOfSchemaTypeWithSources<WithSources<FixedAmountCoupon>>(FixedAmountCouponSchema)
-export const asFixedAmountCouponWithSources = AsObjectFactory.create<WithSources<FixedAmountCoupon>>(isFixedAmountCouponWithSources)
-export const asOptionalFixedAmountCouponWithSources = AsObjectFactory.createOptional<WithSources<FixedAmountCoupon>>(isFixedAmountCouponWithSources)

package/src/Discount/Payload/Coupon/Coupons/FixedPercentage.ts

@@ -1,36 +0,0 @@
-import { AsObjectFactory } from '@xylabs/object'
-import type { Payload, WithSources } from '@xyo-network/payload-model'
-import {
-  asSchema,
-  isPayloadOfSchemaType,
-  isPayloadOfSchemaTypeWithSources,
-} from '@xyo-network/payload-model'
-
-import { CouponSchema } from '../Schema.ts'
-import type { CouponFields } from '../types/index.ts'
-
-export const FixedPercentageCouponSchema = asSchema(`${CouponSchema}.fixed.percentage`, true)
-export type FixedPercentageCouponSchema = typeof FixedPercentageCouponSchema
-
-export interface FixedPercentageCouponFields extends CouponFields {
-  percentage: number
-}
-
-/**
- * A coupon that provides a fixed discount amount
- */
-export type FixedPercentageCoupon = Payload<FixedPercentageCouponFields, FixedPercentageCouponSchema>
-
-/**
- * Identity function for determining if an object is an FixedPercentageCoupon
- */
-export const isFixedPercentageCoupon = isPayloadOfSchemaType<FixedPercentageCoupon>(FixedPercentageCouponSchema)
-export const asFixedPercentageCoupon = AsObjectFactory.create<FixedPercentageCoupon>(isFixedPercentageCoupon)
-export const asOptionalFixedPercentageCoupon = AsObjectFactory.createOptional<FixedPercentageCoupon>(isFixedPercentageCoupon)
-
-/**
- * Identity function for determining if an object is an FixedPercentageCoupon with sources
-*/
-export const isFixedPercentageCouponWithSources = isPayloadOfSchemaTypeWithSources<WithSources<FixedPercentageCoupon>>(FixedPercentageCouponSchema)
-export const asFixedPercentageCouponWithSources = AsObjectFactory.create<WithSources<FixedPercentageCoupon>>(isFixedPercentageCouponWithSources)
-export const asOptionalFixedPercentageCouponWithSources = AsObjectFactory.createOptional<WithSources<FixedPercentageCoupon>>(isFixedPercentageCouponWithSources)

package/src/Discount/Payload/Coupon/Coupons/FixedPrice.ts

@@ -1,35 +0,0 @@
-import { AsObjectFactory } from '@xylabs/object'
-import type { Payload, WithSources } from '@xyo-network/payload-model'
-import {
-  asSchema,
-  isPayloadOfSchemaType,
-  isPayloadOfSchemaTypeWithSources,
-} from '@xyo-network/payload-model'
-
-import type { AmountFields } from '../../../../Amount/index.ts'
-import { CouponSchema } from '../Schema.ts'
-import type { CouponFields } from '../types/index.ts'
-
-export const FixedPriceCouponSchema = asSchema(`${CouponSchema}.fixed.price`, true)
-export type FixedPriceCouponSchema = typeof FixedPriceCouponSchema
-
-export interface FixedPriceCouponFields extends CouponFields, AmountFields { }
-
-/**
- * A coupon that provides a fixed total price
- */
-export type FixedPriceCoupon = Payload<FixedPriceCouponFields, FixedPriceCouponSchema>
-
-/**
- * Identity function for determining if an object is an FixedPriceCoupon
- */
-export const isFixedPriceCoupon = isPayloadOfSchemaType<FixedPriceCoupon>(FixedPriceCouponSchema)
-export const asFixedPriceCoupon = AsObjectFactory.create<FixedPriceCoupon>(isFixedPriceCoupon)
-export const asOptionalFixedPriceCoupon = AsObjectFactory.createOptional<FixedPriceCoupon>(isFixedPriceCoupon)
-
-/**
- * Identity function for determining if an object is an FixedPriceCoupon with sources
-*/
-export const isFixedPriceCouponWithSources = isPayloadOfSchemaTypeWithSources<WithSources<FixedPriceCoupon>>(FixedPriceCouponSchema)
-export const asFixedPriceCouponWithSources = AsObjectFactory.create<WithSources<FixedPriceCoupon>>(isFixedPriceCouponWithSources)
-export const asOptionalFixedPriceCouponWithSources = AsObjectFactory.createOptional<WithSources<FixedPriceCoupon>>(isFixedPriceCouponWithSources)

package/src/Discount/Payload/Coupon/Coupons/index.ts

@@ -1,3 +0,0 @@
-export * from './FixedAmount.ts'
-export * from './FixedPercentage.ts'
-export * from './FixedPrice.ts'

package/src/Discount/Payload/Coupon/Payload.ts

@@ -1,37 +0,0 @@
-import { AsObjectFactory } from '@xylabs/object'
-
-import type {
-  FixedAmountCoupon, FixedPercentageCoupon, FixedPriceCoupon,
-} from './Coupons/index.ts'
-import {
-  isFixedAmountCoupon, isFixedAmountCouponWithSources, isFixedPercentageCoupon,
-  isFixedPercentageCouponWithSources,
-  isFixedPriceCoupon,
-  isFixedPriceCouponWithSources,
-} from './Coupons/index.ts'
-
-/**
- * The type of coupons
- */
-export type Coupon
-  = FixedAmountCoupon
-    | FixedPercentageCoupon
-    | FixedPriceCoupon
-
-/**
- * Identity function for determining if an object is an Coupon
- */
-export const isCoupon = (x?: unknown | null) =>
-  isFixedAmountCoupon(x)
-  || isFixedPercentageCoupon(x)
-  || isFixedPriceCoupon(x)
-export const asCoupon = AsObjectFactory.create(isCoupon)
-
-/**
- * Identity function for determining if an object is an Coupon with sources
- */
-export const isCouponWithSources = (x?: unknown | null) =>
-  isFixedAmountCouponWithSources(x)
-  || isFixedPercentageCouponWithSources(x)
-  || isFixedPriceCouponWithSources(x)
-export const asCouponWithSources = AsObjectFactory.create(isCouponWithSources)

package/src/Discount/Payload/Coupon/Schema.ts

@@ -1,4 +0,0 @@
-import { asSchema } from '@xyo-network/payload-model'
-
-export const CouponSchema = asSchema('network.xyo.payments.coupon', true)
-export type CouponSchema = typeof CouponSchema

package/src/Discount/Payload/Coupon/index.ts

@@ -1,5 +0,0 @@
-export * from './Conditions/index.ts'
-export * from './Coupons/index.ts'
-export * from './Payload.ts'
-export * from './Schema.ts'
-export * from './types/index.ts'

package/src/Discount/Payload/Coupon/types/Condition.ts

@@ -1,21 +0,0 @@
-import { AsObjectFactory } from '@xylabs/object'
-import { isPayloadOfSchemaType, isPayloadOfSchemaTypeWithSources } from '@xyo-network/payload-model'
-import type { SchemaPayload } from '@xyo-network/schema-payload-plugin'
-import { SchemaSchema } from '@xyo-network/schema-payload-plugin'
-
-/**
- * The payloads that can be used as conditions for a coupon
- */
-export type Condition = SchemaPayload
-
-/**
- * Identity function for determining if an object is a Condition payload
- */
-export const isCondition = isPayloadOfSchemaType<Condition>(SchemaSchema)
-export const asCondition = AsObjectFactory.create(isCondition)
-
-/**
- * Identity function for determining if an object is a Condition payload with sources
-*/
-export const isConditionWithSources = isPayloadOfSchemaTypeWithSources<Condition>(SchemaSchema)
-export const asConditionWithSources = AsObjectFactory.create(isConditionWithSources)

package/src/Discount/Payload/Coupon/types/CouponFields.ts

@@ -1,16 +0,0 @@
-import type { Hash } from '@xylabs/hex'
-import type { DurationFields } from '@xyo-network/xns-record-payload-plugins'
-
-/**
- * The fields that are common across all coupons
- */
-export interface CouponFields extends DurationFields {
-  /**
-   * The conditions that must be met in order for this coupon to be applied
-   */
-  conditions?: Hash[]
-  /**
-   * Whether or not this discount can be stacked with other discounts
-   */
-  stackable?: boolean
-}

package/src/Discount/Payload/Coupon/types/index.ts

@@ -1,3 +0,0 @@
-export * from './Condition.ts'
-export * from './CouponFields.ts'
-export * from './isStackable.ts'

package/src/Discount/Payload/Coupon/types/isStackable.ts

@@ -1,6 +0,0 @@
-import type { CouponFields } from './CouponFields.ts'
-
-/**
- * Identity function for determining if coupon is stackable
- */
-export const isStackable = (x?: unknown | null) => (x as CouponFields ?? { stackable: false })?.stackable

package/src/Discount/Payload/Discount.ts

@@ -1,33 +0,0 @@
-import { AsObjectFactory } from '@xylabs/object'
-import type { Payload, WithSources } from '@xyo-network/payload-model'
-import {
-  asSchema,
-  isPayloadOfSchemaType,
-  isPayloadOfSchemaTypeWithSources,
-} from '@xyo-network/payload-model'
-
-import type { AmountFields } from '../../Amount/index.ts'
-
-export const DiscountSchema = asSchema('network.xyo.payments.discount', true)
-export type DiscountSchema = typeof DiscountSchema
-
-export interface DiscountFields extends AmountFields { }
-
-/**
- * The result of a discount
- */
-export type Discount = Payload<DiscountFields, DiscountSchema>
-
-/**
- * Identity function for determining if an object is an Discount
- */
-export const isDiscount = isPayloadOfSchemaType<Discount>(DiscountSchema)
-export const asDiscount = AsObjectFactory.create<Discount>(isDiscount)
-export const asOptionalDiscount = AsObjectFactory.createOptional<Discount>(isDiscount)
-
-/**
- * Identity function for determining if an object is an Discount with sources
- */
-export const isDiscountWithSources = isPayloadOfSchemaTypeWithSources<Discount>(DiscountSchema)
-export const asDiscountWithSources = AsObjectFactory.create<WithSources<Discount>>(isDiscountWithSources)
-export const asOptionalDiscountWithSources = AsObjectFactory.createOptional<WithSources<Discount>>(isDiscountWithSources)

package/src/Discount/Payload/NoDiscount.ts

@@ -1,8 +0,0 @@
-import type { Discount } from './Discount.ts'
-import { DiscountSchema } from './Discount.ts'
-
-export const NO_DISCOUNT: Discount = {
-  schema: DiscountSchema,
-  amount: 0,
-  currency: 'USD',
-}

package/src/Discount/Payload/index.ts

@@ -1,3 +0,0 @@
-export * from './Coupon/index.ts'
-export * from './Discount.ts'
-export * from './NoDiscount.ts'

package/src/Discount/index.ts

@@ -1,3 +0,0 @@
-export * from './Config.ts'
-export * from './Params.ts'
-export * from './Payload/index.ts'

package/src/Escrow/Outcome.ts

@@ -1,42 +0,0 @@
-import type { Hash } from '@xylabs/hex'
-import { AsObjectFactory } from '@xylabs/object'
-import type { PayloadWithSources, WithSources } from '@xyo-network/payload-model'
-import {
-  asSchema,
-  isPayloadOfSchemaType,
-  isPayloadOfSchemaTypeWithSources,
-} from '@xyo-network/payload-model'
-
-import { EscrowSchema } from './Schema.ts'
-
-export const EscrowOutcomeSchema = asSchema(`${EscrowSchema}.outcome`, true)
-export type EscrowOutcomeSchema = typeof EscrowOutcomeSchema
-
-/**
- * The possible outcomes for an escrow
- */
-export type EscrowOutcomes = 'fulfilled' | 'expired' // TODO: More outcomes
-
-export interface EscrowOutcomeFields {
-  outcome: EscrowOutcomes
-  terms: Hash
-}
-
-/**
- * The terms of an escrow
- */
-export type EscrowOutcome = PayloadWithSources<EscrowOutcomeFields, EscrowOutcomeSchema>
-
-/**
- * Identity function for determining if an object is an EscrowOutcome
- */
-export const isEscrowOutcome = isPayloadOfSchemaType<EscrowOutcome>(EscrowOutcomeSchema)
-export const asEscrowOutcome = AsObjectFactory.create<EscrowOutcome>(isEscrowOutcome)
-export const asOptionalEscrowOutcome = AsObjectFactory.createOptional<EscrowOutcome>(isEscrowOutcome)
-
-/**
- * Identity function for determining if an object is an EscrowOutcome with sources
- */
-export const isEscrowOutcomeWithSources = isPayloadOfSchemaTypeWithSources<EscrowOutcome>(EscrowOutcomeSchema)
-export const asEscrowOutcomeWithSources = AsObjectFactory.createOptional<WithSources<EscrowOutcome>>(isEscrowOutcomeWithSources)
-export const asOptionalEscrowOutcomeWithSources = AsObjectFactory.createOptional<WithSources<EscrowOutcome>>(isEscrowOutcomeWithSources)

package/src/Escrow/Schema.ts

@@ -1,4 +0,0 @@
-import { asSchema } from '@xyo-network/payload-model'
-
-export const EscrowSchema = asSchema('network.xyo.escrow', true)
-export type EscrowSchema = typeof EscrowSchema

package/src/Escrow/Terms/Party.ts

@@ -1,6 +0,0 @@
-import type { EscrowTermsFields } from './Terms.ts'
-
-/**
- * The party in an escrow transaction
- */
-export type EscrowParty = keyof Pick<EscrowTermsFields, 'buyer' | 'seller'>

package/src/Escrow/Terms/PartySecret.ts

@@ -1,6 +0,0 @@
-import type { EscrowTermsFields } from './Terms.ts'
-
-/**
- * The party's secret in an escrow transaction
- */
-export type EscrowPartySecret = keyof Pick<EscrowTermsFields, 'buyerSecret' | 'sellerSecret'>

package/src/Escrow/Terms/Terms.ts

@@ -1,82 +0,0 @@
-import type { Address, Hash } from '@xylabs/hex'
-import { AsObjectFactory } from '@xylabs/object'
-import type { Payload } from '@xyo-network/payload-model'
-import {
-  asSchema, isPayloadOfSchemaType, isPayloadOfSchemaTypeWithSources,
-} from '@xyo-network/payload-model'
-
-import { EscrowSchema } from '../Schema.ts'
-
-export const EscrowTermsSchema = asSchema(`${EscrowSchema}.terms`, true)
-export type EscrowTermsSchema = typeof EscrowTermsSchema
-
-// TODO: Include escrow agent in escrow terms
-export interface EscrowTermsFields {
-  /**
-   * The trusted estimators for the worth of the things being sold
-   */
-  appraisalAuthorities: Address[]
-  /**
-   * The estimated worths of the things being sold
-   */
-  appraisals: Hash[]
-  /**
-   * The things being sold
-   */
-  assets: Hash[]
-  /**
-   * The buyer
-   */
-  buyer: Address[]
-  /**
-   * The buyer
-   */
-  buyerSecret: Hash
-  /**
-   * Any discounts (coupons, vouchers, credits, etc.) to be applied to the escrow
-   */
-  discounts: Hash[]
-  /**
-   * The escrow agent responsible for the escrow
-   */
-  escrowAgent: Address
-  /**
-   * The time the escrow expires
-   */
-  exp: number
-  /**
-   * The time the escrow starts
-   */
-  nbf: number
-  /**
-   * The trusted payment authorities
-   */
-  paymentAuthorities: Address[]
-  /**
-   * The seller
-   */
-  seller: Address[]
-  /**
-   * The seller
-   */
-  sellerSecret: Hash
-}
-
-/**
- * The terms of an escrow
- */
-export type EscrowTerms = Payload<Partial<EscrowTermsFields>, EscrowTermsSchema>
-
-/**
- * Identity function for determining if an object is an EscrowTerms
- */
-export const isEscrowTerms = isPayloadOfSchemaType<EscrowTerms>(EscrowTermsSchema)
-export const asEscrowTerms = AsObjectFactory.create<EscrowTerms>(isEscrowTerms)
-export const asOptionalEscrowTerms = AsObjectFactory.createOptional<EscrowTerms>(isEscrowTerms)
-
-/**
- * Identity function for determining if an object is an EscrowTerms with sources
- */
-export const isEscrowTermsWithSources = isPayloadOfSchemaTypeWithSources<EscrowTerms>(EscrowTermsSchema)
-export const asEscrowTermsWithSources = AsObjectFactory.create<EscrowTerms>(isEscrowTermsWithSources)
-export const asOptionalEscrowTermsWithSources = AsObjectFactory.createOptional<EscrowTerms>(isEscrowTermsWithSources)

package/src/Escrow/Terms/index.ts

@@ -1,3 +0,0 @@
-export * from './Party.ts'
-export * from './PartySecret.ts'
-export * from './Terms.ts'

package/src/Escrow/index.ts

@@ -1,5 +0,0 @@
-export * from './Outcome.ts'
-export * from './Schema.ts'
-export * from './Terms/index.ts'
-export * from './util/index.ts'
-export * from './validators/index.ts'

package/src/Escrow/util/appraisal/getAppraisalsByAsset.ts

@@ -1,32 +0,0 @@
-import type { Hash } from '@xylabs/hex'
-import type { HashLeaseEstimate } from '@xyo-network/diviner-hash-lease'
-import { isHashLeaseEstimateWithSources } from '@xyo-network/diviner-hash-lease'
-import type { Payload, WithSources } from '@xyo-network/payload-model'
-
-import type { EscrowTerms } from '../../Terms/index.ts'
-
-/**
- * Returns a dictionary of asset hashes and their associated appraisals
- * @param terms The escrow terms
- * @param dictionary The dictionary of payloads associated with the escrow terms
- * @returns A dictionary of asset hashes and their associated appraisals
- */
-export const getAppraisalsByAsset = (terms: EscrowTerms, dictionary: Record<Hash, Payload>): Record<Hash, WithSources<HashLeaseEstimate>[]> => {
-  const assets = terms.assets
-  if (!assets || assets.length === 0) return {}
-  const appraisals = Object.values(dictionary).filter(isHashLeaseEstimateWithSources) as unknown as WithSources<HashLeaseEstimate>[]
-  const appraisalsByAsset: Record<Hash, WithSources<HashLeaseEstimate>[]> = {}
-  for (const estimate of appraisals) {
-    const { $sources } = estimate
-    if ($sources === undefined || $sources.length === 0) {
-      continue
-    }
-    for (const asset of assets) {
-      if ($sources.includes(asset)) {
-        if (!appraisalsByAsset[asset]) appraisalsByAsset[asset] = []
-        appraisalsByAsset[asset].push(estimate)
-      }
-    }
-  }
-  return appraisalsByAsset
-}

package/src/Escrow/util/appraisal/getSignaturesByAppraisal.ts

@@ -1,40 +0,0 @@
-import type { Hash } from '@xylabs/hex'
-import type { BoundWitness } from '@xyo-network/boundwitness-model'
-import { isBoundWitness } from '@xyo-network/boundwitness-model'
-import type { Payload } from '@xyo-network/payload-model'
-
-import type { EscrowTerms } from '../../Terms/index.ts'
-
-/**
- * Returns a dictionary of appraisals and their associated bound witnesses which are signed by
- * valid appraisal authorities from the escrow terms
- * @param terms The escrow terms
- * @param dictionary The diction of payloads associated with the escrow terms
- * @returns A dictionary of appraisals and their associated bound witnesses
- */
-export const getSignaturesByAppraisal = (
-  terms: EscrowTerms,
-  dictionary: Record<Hash, Payload>,
-): Record<Hash, BoundWitness[]> => {
-  // Validate inputs
-  const appraisals = terms.appraisals
-  if (!appraisals || appraisals.length === 0) return {}
-  const appraisalAuthorities = terms.appraisalAuthorities
-  if (!appraisalAuthorities || appraisalAuthorities.length === 0) return {}
-
-  // Validate the appraisals are signed by valid appraisal authorities. Validation criteria:
-  // - The bw includes the appraisal hash from the escrow terms appraisal
-  // - The bw is signed by an approved appraisal authority from the escrow terms appraisalAuthorities
-  const appraisalBWsValid: Record<Hash, BoundWitness[]> = Object.fromEntries(
-    appraisals.map<[Hash, BoundWitness[]]>(hash => [hash, []]),
-  )
-  for (const bw of Object.values(dictionary).filter(isBoundWitness)) {
-    for (const appraisal of appraisals) {
-      if (bw.payload_hashes.includes(appraisal) && bw.addresses.some(address => appraisalAuthorities.includes(address))) {
-        appraisalBWsValid[appraisal].push(bw)
-      }
-    }
-  }
-
-  return appraisalBWsValid
-}

package/src/Escrow/util/appraisal/index.ts

@@ -1,2 +0,0 @@
-export * from './getAppraisalsByAsset.ts'
-export * from './getSignaturesByAppraisal.ts'

package/src/Escrow/util/index.ts

@@ -1,2 +0,0 @@
-export * from './appraisal/index.ts'
-export * from './secret/index.ts'

package/src/Escrow/util/secret/createEscrowIntent.ts

@@ -1,17 +0,0 @@
-import type { AccountInstance } from '@xyo-network/account-model'
-import { BoundWitnessBuilder } from '@xyo-network/boundwitness-builder'
-import type { Id } from '@xyo-network/id-payload-plugin'
-
-import type { EscrowTerms } from '../../Terms/index.ts'
-
-/**
- * Creates an escrow intent (for a buyer or seller) using the supplied secret
- * @param terms The payload describing the terms for the escrow
- * @param secret The secret for the escrow principal party to use for the escrow
- * @param account The account to create the escrow intent with
- * @returns The escrow intent
- */
-export const createEscrowIntentWithSecret = async (terms: EscrowTerms, secret: Id, account: AccountInstance) => {
-  const result = await new BoundWitnessBuilder().signers([account]).payloads([terms, secret]).build()
-  return result
-}