@hyperscale0/hsx 3.3.0 → 4.0.0

package/src/version.ts

@@ -1,2 +1,2 @@
-export const HSX_VERSION = "3.3.0";
-export const HSX_TARGET_UDL_VERSION = 3;
+export const HSX_VERSION = "4.0.0";
+export const HSX_TARGET_UDL_VERSION = 4;

package/std/approvals.hsx

@@ -1,17 +1,17 @@
 header approvals
 
-instrument decision(for: ref, approved_by: party, action: text = "approve") {
+instrument decision(for: ref, approved_by: approval, action: text = "approve", protected_request: text = "self.target") {
   summary: "One authenticated decision bound to an immutable target and expiry."
   fields { target: ref<for>, expiresAt: date }
   lifecycle { states: [pending, approved, declined, expired], initial: pending }
   action create {}
   action approve {
     from: pending, to: approved, actor: { party: approved_by }, deadline: { at: self.expiresAt }
-    approval: { target: self.target, action: action, party: approved_by, expires: self.expiresAt, input: "material", decision: "approved" }
+    approval: { protectedRequest: protected_request, target: self.target, action: action, party: approved_by, expires: self.expiresAt, input: "material", decision: "approved" }
   }
   action decline {
     from: pending, to: declined, actor: { party: approved_by }, deadline: { at: self.expiresAt }
-    approval: { target: self.target, action: action, party: approved_by, expires: self.expiresAt, input: "material", decision: "declined" }
+    approval: { protectedRequest: protected_request, target: self.target, action: action, party: approved_by, expires: self.expiresAt, input: "material", decision: "declined" }
   }
   action expire { from: pending, to: expired, actor: clock, due: { at: self.expiresAt } }
 }

package/std/escrow.hsx

@@ -1,27 +1,26 @@
 header escrow
 
-instrument hold(payer: party, payee: party, for: ref<marketplace.order>, accept_within: duration = 48h, fee: fee = { seller: 0%, tax: 0% }, dispute: policy = { refund_after: return_verified }) {
+instrument hold(payer: party = party(person), payee: party = programOperator, accept_within: duration = 48h, fee: fee = { seller: 0%, tax: 0% }, dispute: policy = { refund_after: return_verified }) {
   revisioned: true
-  summary: "Hold an order's price through delivery, acceptance and verified return."
-  fields { payer: account of payer, payee: account of payee, order: ref<for>, price: money, held: account of self, deliveredAt: date?, buyerTopUp: money? }
+  summary: "Hold the subject price through delivery, acceptance and verified return."
+  fields {
+    payer: account of payer, payee: account of payee
+    held: account of self, deliveredAt: date?
+    price: money = subject.price
+  }
   lifecycle { states: [pending, funded, delivered, disputed, return_verified, released, refunded, cancelled], initial: pending }
   action create {
-    requires self.payer == self.order.buyer; requires self.payee == self.order.listing.seller; requires self.price == self.order.price
+    subject { price: money }
+    actor: { party: payer }
   }
   action fund {
     from: pending, to: funded, actor: { party: payer }
-    requires self.order in [quoted, placed]
-    invoke: [{ reference: self.order, action: commit, input: {} }, { selection: { instrument: all(marketplace.reservation), reference: "listing", anchor: self.order.listing, states: [active], limit: 1, where: { buyer: { field: self.payer } } }, action: credit, input: { funds: { field: self.id }, contribution: { field: self.price } } }, { reference: self.id, action: fund_remainder, input: {} }]
-  }
-  action fund_remainder {
-    from: funded, to: funded, actor: { parent: current() }
-    calculate: [{ target: buyerTopUp, op: subtract, base: { field: self.price }, subtract: [{ field: self.held.balance }] }]
-    moves self.buyerTopUp from payer to self.held
+    subject { price: money }
+    moves subject.price from payer to self.held
   }
   action confirm {
     from: pending, to: funded
     requires self.held.balance == self.price
-    invoke: [{ reference: self.order, action: commit, input: {} }]
   }
   action deliver {
     from: funded, to: delivered, actor: { party: payee }
@@ -29,7 +28,7 @@ instrument hold(payer: party, payee: party, for: ref<marketplace.order>, accept_
   }
   action accept {
     from: delivered, to: released, actor: { party: payer }
-    input { acceptanceReference: text, titleReference: text, coverReference: text }
+    input { acceptanceReference: text }
     deadline: { at: self.deliveredAt, offset: accept_within }
     moves self.price from self.held to payee fee fee
   }
@@ -41,7 +40,10 @@ instrument hold(payer: party, payee: party, for: ref<marketplace.order>, accept_
     from: delivered, to: disputed, actor: { party: payer }
     deadline: { at: self.deliveredAt, offset: accept_within }
   }
-  action verify_return { from: disputed, to: return_verified, input { returnReference: text } }
+  action verify_return {
+    from: disputed, to: return_verified
+    input { returnEvidence: text }
+  }
   action refund {
     from: dispute.refund_after, to: refunded
     moves self.price from self.held to payer

package/std/financing.hsx

@@ -1,12 +1,13 @@
 header financing
 
-instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3, profit: percent, disburse_to: enum(funds, borrower) = funds, profit_earned: enum(on_payment, by_schedule, at_disbursement) = on_payment, apply: enum(fines_profit_principal, principal_profit, pro_rata) = fines_profit_principal, payoff_rebate: percent = 100%, write_off_after: duration = 90d, max_extension: duration = 90d, max_amendments: integer(0, 366) = 2, waiver_limit: percent = 100%, amendment_expiry: duration = 7d, payoff_quote_expiry: duration = 1h, allow_overdue: enum(allowed, blocked) = allowed, assessed_fines: enum(carry, require_waiver) = carry, down_payment: percent = 0%, funds: ref, approval: approval, borrower: party = party(person), capital: party = programOperator, profit_to: party = programOperator, limits: ref<financing.limits> = object(financing.limits)) {
+instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3, profit: percent, disburse_to: enum(funds, borrower) = funds, profit_earned: enum(on_payment, by_schedule, at_disbursement) = on_payment, apply: enum(fines_profit_principal, principal_profit, pro_rata) = fines_profit_principal, payoff_rebate: percent = 100%, write_off_after: duration = 90d, max_extension: duration = 90d, max_amendments: integer(0, 366) = 2, waiver_limit: percent = 100%, amendment_expiry: duration = 7d, payoff_quote_expiry: duration = 1h, allow_overdue: enum(allowed, blocked) = allowed, assessed_fines: enum(carry, require_waiver) = carry, down_payment: percent = 0%, funds: ref = object(escrow.hold), approval: approval = programOperator, borrower: party = party(person), capital: party = programOperator, share: percent = 0%, limits: ref<financing.limits> = object(financing.limits)) {
   revisioned: true
+  familyRevision: 1
   summary: "Funding, profit recognition and payment order chosen by the program."
   fields {
     funds: ref<funds>, borrower: account of borrower, settlementIdentity: text, borrowerLimit: ref<limits>, portfolioLimit: ref<limits.portfolio>
     months: integer = months, dates: list(date, months)
-    capital: account(capital, cash, "capital"), profitIncome: account(profit_to, cash, "profitIncome"), loss: account(capital, claim, "loss")
+    allocatedPayable: account(capital, cash, "allocatedProfitPayable"), capital: account(capital, cash, "capital"), profitIncome: account(capital, cash, "profitIncome"), loss: account(capital, claim, "loss")
     downPaymentRemaining: money?, downPaymentCredit: money?, principalReturned: money?, profitReturned: money?, lossRecorded: money?
     price: money = self.funds.price
     downPayment: money = rate(self.price, down_payment)
@@ -25,16 +26,14 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
   action sign {
     from: quoted, to: signed, actor: { party: borrower }, input { signedOffer: text, affordabilityReference: text }
     requires count of { instrument: slice, reference: "plan", anchor: self.id, states: [draft], limit: 366 } == self.months
-    when funds has order { invoke: [{ reference: self.funds.order, action: commit, input: {} }] }
   }
   action disburse {
     from: signed, to: active
-    requires approval by approval
+    requires approval by approval protectedRequest self differentFromInitiator true
     requires self.borrowerLimit in [approved]
     requires self.portfolioLimit in [approved]
     when disburse_to is funds {
       requires self.funds in [pending]
-      when funds has order { invoke: [{ selection: { instrument: all(marketplace.reservation), reference: "listing", anchor: self.funds.order.listing, states: [active], limit: 1, where: { buyer: { field: self.borrower } } }, action: credit, input: { funds: { field: self.funds }, contribution: { field: self.downPayment } } }] }
       invoke: [{ reference: self.id, action: fund_down_payment, input: {} }]
     }
     when disburse_to is borrower { moves self.principal from self.capital to self.borrower }
@@ -71,11 +70,11 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
     invoke: [{ instrument: settlement, action: create, input: { plan: { field: self.id }, identity: { field: self.settlementIdentity }, principal: { field: self.principalReturned }, profit: { field: self.profitReturned }, loss: { literal: "0" }, kind: { literal: "cash" } } }]
   }
   action write_off {
-    from: active, to: written_off
+    from: active, to: written_off, actor: { parent: write_off_request }
     input { overdueSlice: ref<slice> }
     calculate: [{ target: "lossRecorded", op: "aggregate", selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: 366 }, measure: { sum: "principalReceivable.balance" } }]
     due: { at: input.overdueSlice.lossEligibleAt }
-    requires approval by approval; requires input.overdueSlice.plan == self.id; requires input.overdueSlice.principalReceivable.balance > "0"
+    requires input.overdueSlice.plan == self.id; requires input.overdueSlice.principalReceivable.balance > "0"
     invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.id, states: [pending, due], limit: 366, order: [position] }, action: write_off, input: {} }, { instrument: settlement, action: create, input: { plan: { field: self.id }, identity: { field: self.settlementIdentity }, principal: { literal: "0" }, profit: { literal: "0" }, loss: { field: self.lossRecorded }, kind: { literal: "loss" } } }]
   }
   action record_payment {
@@ -86,6 +85,17 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
   action cancel { from: quoted, to: cancelled }
   action void { from: signed, to: cancelled, actor: { party: borrower } }
   records {
+    write_off_request: {
+      fields { plan: ref<parent>, overdueSlice: ref<slice> }
+      lifecycle { states: [requested, applied, cancelled], initial: requested }
+      action create { requires self.overdueSlice.plan == self.plan; requires self.plan in [active] }
+      action apply {
+        from: requested, to: applied
+        requires approval by approval protectedRequest self differentFromInitiator true
+        invoke: [{ reference: self.plan, action: write_off, input: { overdueSlice: { field: self.overdueSlice } } }]
+      }
+      action cancel { from: requested, to: cancelled }
+    }
     payoff_quote: {
       fields {
         plan: ref<parent>, revision: text?, effectiveAt: date?, expiresAt: date = after(self.createdAt, payoff_quote_expiry)
@@ -146,7 +156,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
       action accept {
         from: proposed, to: applied, actor: { party: borrower }, deadline: { at: self.expiresAt }
         requires self.plan in [active]; requires self.revision == self.productRevision
-        requires approval by approval
+        requires approval by approval protectedRequest self differentFromInitiator true
         requires count of { instrument: current(), reference: "plan", anchor: self.plan, states: [applied], limit: 366 } < self.maximum
         set: { acceptedAt: { field: self.now } }
         when assessed_fines is require_waiver { requires self.waiverPercent == 10000 }
@@ -172,13 +182,19 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
       action create { actor: { parent: slice }, input { amendment: ref<amendment>, slice: ref<slice>, oldDate: date, newDate: date }, requires unique "amended_slice" on [self.amendment, self.slice] }
     }
     settlement: {
-      fields { plan: ref<parent>, identity: text, principal: money, profit: money, loss: money, kind: enum(cash, loss)
-        capital: account(capital, cash, "capital"), profitIncome: account(profit_to, cash, "profitIncome"), lossAccount: account(capital, claim, "loss") }
-      lifecycle { states: [recorded], initial: recorded }
+      fields { plan: ref<parent>, identity: text, principal: money, profit: money, loss: money, kind: enum(cash, loss), share: money?, retainedProfit: money?
+        allocatedPayable: account(capital, cash, "allocatedProfitPayable"), capital: account(capital, cash, "capital"), profitIncome: account(capital, cash, "profitIncome"), lossAccount: account(capital, claim, "loss") }
+      lifecycle { states: [recorded, refunded], initial: recorded }
       action create {
         actor: { parent: parent }
         input { plan: ref<parent>, identity: text, principal: money, profit: money, loss: money, kind: enum(cash, loss) }
         requires unique "settlement_identity" on [self.plan, self.identity]
+        calculate: [{ target: "share", op: "rate", base: { field: self.profit }, bps: { literal: share }, rounding: "floor" }, { target: retainedProfit, op: "subtract", base: { field: self.profit }, subtract: [{ field: self.share }] }]
+        moves self.share from self.profitIncome to self.allocatedPayable
+      }
+      action refund {
+        from: recorded, to: refunded, actor: { parent: payment }
+        moves self.share from self.allocatedPayable to self.profitIncome
       }
     }
     slice: {
@@ -332,12 +348,10 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
     payment: {
       revisioned: true
       fields { plan: ref<parent>, amount: money, paymentIdentity: text, held: account of self
-        capital: account(capital, cash, "capital"), profitIncome: account(profit_to, cash, "profitIncome"), loss: account(capital, claim, "loss")
         outstandingPrincipal: money?, outstandingProfit: money?, outstandingFines: money?, outstandingCosts: money?, outstandingTotal: money?, principalReturned: money?, profitReturned: money?, lossRecorded: money? }
 
       lifecycle { states: [pending, paid, refunded], initial: pending }
       action create { input { plan: ref<parent>, amount: money, paymentIdentity: text } requires self.plan in [active]; requires unique "payment_identity" on [self.plan, self.paymentIdentity] }
-      // 366 slices * (1 + 3 fines * 3 + 3 costs * 3 + 2 pieces + 1 completion), plus recording.
       action pay {
         expansionLimit: 8192
         from: pending, to: paid
@@ -372,6 +386,8 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
       action refund {
         from: paid, to: refunded
         requires unique "settlement_consumption" on [self.plan, self.paymentIdentity]; requires self.plan in [active, paid]
+        requires count of { instrument: settlement, reference: "plan", anchor: self.plan, states: [recorded], limit: 366, where: { identity: { field: self.paymentIdentity } } } == 1
+        invoke: [{ selection: { instrument: settlement, reference: "plan", anchor: self.plan, states: [recorded], limit: 366, where: { identity: { field: self.paymentIdentity } } }, action: refund, input: {} }]
         when apply is fines_profit_principal {
           invoke: [{ selection: { instrument: all(financing.late_charge), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366, order: [overdueAt] }, action: refund, input: { payment: { field: self.id } } }, { selection: { instrument: all(financing.late_charge.cost), reference: "plan", anchor: self.plan, states: [assessed, collected], limit: 366, order: [overdueAt] }, action: refund, input: { payment: { field: self.id } } }]
         }
@@ -419,6 +435,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
 
 instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d, fine: money = 50 SAR, cap: money = 25 SAR, fines_to: party = programOperator, costs_to: party = programOperator, approval: approval = programOperator, borrower: party = party(person)) {
   revisioned: true
+  familyRevision: 1
   summary: "Separate approved fine and evidenced recovery claims on an overdue installment."
   fields {
     plan: ref<on>, slice: ref<on.slice>, borrower: account of borrower, fine: money = fine, overdueAt: date?
@@ -428,7 +445,7 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
   action create { calculate: [{ target: overdueAt, op: shift, date: { field: self.slice.dueAt }, milliseconds: { literal: grace }, direction: after }], requires unique "late_assessment" on [self.slice, self.overdueAt]; requires self.borrower == self.slice.plan.borrower; requires self.plan == self.slice.plan }
   action assess {
     from: proposed, to: assessed, due: { at: self.overdueAt }
-    requires self.slice.principalReceivable.balance > "0"; requires approval by approval
+    requires self.slice.principalReceivable.balance > "0"; requires approval by approval protectedRequest self differentFromInitiator true
     moves self.fine from self.debt to self.receivable
   }
   action collect {
@@ -450,7 +467,7 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
     requires input.amendment.plan == self.plan; requires input.amendment in [applied]
     invoke: [{ instrument: waiver, action: create, input: { assessment: { field: self.id }, amendment: { field: input.amendment } } }]
   }
-  action waive { from: [assessed, collected], to: waived, input { reason: text, evidence: text }, requires approval by approval, moves self.receivable.balance from self.receivable to self.debt }
+  action waive { from: [assessed, collected], to: waived, actor: { parent: waiver_request }, input { reason: text, evidence: text }, moves self.receivable.balance from self.receivable to self.debt }
   action refund {
     from: [assessed, collected], to: assessed, input { payment: ref<on.payment> }
     requires input.payment in [paid, refunded]
@@ -458,6 +475,17 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
     invoke: [{ selection: { instrument: receipt, reference: "payment", anchor: input.payment, states: [paid], limit: 1, where: { assessment: { field: self.id } } }, action: refund, input: {} }, { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 1, where: { id: { field: self.id }, receivable.balance: { literal: "0" } } }, action: finish, input: {} }]
   }
   records {
+    waiver_request: {
+      fields { assessment: ref<parent>, reason: text, evidence: text }
+      lifecycle { states: [requested, applied, cancelled], initial: requested }
+      action create { requires self.assessment in [assessed, collected] }
+      action apply {
+        from: requested, to: applied, input { reason: text, evidence: text }
+        requires approval by approval protectedRequest self differentFromInitiator true
+        invoke: [{ reference: self.assessment, action: waive, input: { reason: { field: input.reason }, evidence: { field: input.evidence } } }]
+      }
+      action cancel { from: requested, to: cancelled }
+    }
     waiver: {
       fields { assessment: ref<parent>, amendment: ref<on.amendment>, amount: money? }
       lifecycle { states: [recorded], initial: recorded }
@@ -485,7 +513,7 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
       action create { calculate: [{ target: overdueAt, op: shift, date: { field: self.assessment.overdueAt }, milliseconds: { literal: 0 }, direction: after }], requires unique "recovery_assessment" on [self.assessment]; requires self.plan == self.assessment.plan }
       action assess {
         from: proposed, to: assessed, due: { at: self.assessment.overdueAt }
-        requires self.assessment.slice.principalReceivable.balance > "0"; requires approval by approval
+        requires self.assessment.slice.principalReceivable.balance > "0"; requires approval by approval protectedRequest self differentFromInitiator true
         moves self.amount from self.debt to self.receivable
       }
       action collect {
@@ -507,7 +535,7 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
         requires input.amendment.plan == self.plan; requires input.amendment in [applied]
         invoke: [{ instrument: waiver, action: create, input: { assessment: { field: self.id }, amendment: { field: input.amendment } } }]
       }
-      action waive { from: [assessed, collected], to: waived, input { reason: text, evidence: text }, requires approval by approval, moves self.receivable.balance from self.receivable to self.debt }
+      action waive { from: [assessed, collected], to: waived, actor: { parent: waiver_request }, input { reason: text, evidence: text }, moves self.receivable.balance from self.receivable to self.debt }
       action refund {
         from: [assessed, collected], to: assessed, input { payment: ref<on.payment> }
         requires input.payment in [paid, refunded]
@@ -515,6 +543,17 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
         invoke: [{ selection: { instrument: receipt, reference: "payment", anchor: input.payment, states: [paid], limit: 1, where: { assessment: { field: self.id } } }, action: refund, input: {} }, { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 1, where: { id: { field: self.id }, receivable.balance: { literal: "0" } } }, action: finish, input: {} }]
       }
       records {
+        waiver_request: {
+          fields { assessment: ref<parent>, reason: text, evidence: text }
+          lifecycle { states: [requested, applied, cancelled], initial: requested }
+          action create { requires self.assessment in [assessed, collected] }
+          action apply {
+            from: requested, to: applied, input { reason: text, evidence: text }
+            requires approval by approval protectedRequest self differentFromInitiator true
+            invoke: [{ reference: self.assessment, action: waive, input: { reason: { field: input.reason }, evidence: { field: input.evidence } } }]
+          }
+          action cancel { from: requested, to: cancelled }
+        }
         waiver: {
           fields { assessment: ref<parent>, amendment: ref<on.amendment>, amount: money? }
           lifecycle { states: [recorded], initial: recorded }
@@ -537,6 +576,7 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
 }
 
 instrument limits(per_borrower: money, portfolio: money, borrower: party = party(person), active_plans: integer = 1) {
+  familyRevision: 1
   summary: "One borrower ceiling and one shared portfolio ceiling."
   fields { borrower: account of borrower, limit: money = per_borrower, activePlans: integer = active_plans }
   lifecycle { states: [pending, approved], initial: pending }
@@ -553,6 +593,7 @@ instrument limits(per_borrower: money, portfolio: money, borrower: party = party
 }
 
 instrument credit_line(borrower: party, lender: party, limit: money, expires: date) {
+  familyRevision: 1
   summary: "A revolving facility; each draw is a separate immutable advance."
   fields { borrower: account of borrower, lender: account of lender, debt: account(borrower, claim, contra, "debt"), limit: money = limit, expiresAt: date = expires }
   lifecycle { states: [pending, active, suspended, closed], initial: pending }
@@ -564,6 +605,7 @@ instrument credit_line(borrower: party, lender: party, limit: money, expires: da
 }
 
 instrument advance(line: ref<financing.credit_line>, amount: money = runtime) {
+  familyRevision: 1
   summary: "A single facility draw with an immutable principal and full repayment."
   fields { line: ref<line>, amount: money = amount, principalReceivable: account(self, claim) }
   lifecycle { states: [pending, drawn, repaid, cancelled], initial: pending }

package/std/insurance.hsx

@@ -1,11 +1,11 @@
 header insurance
 
-instrument cover(holder: party, insurer: party, commission: percent = 0%, covers: ref, premium: money = runtime) {
+instrument cover(holder: party, insurer: party, approval: approval = programOperator, commission: percent = 0%, covers: ref, premium: money = runtime) {
   summary: "Recurring cover with separate premium slices and commission clawback."
   fields { covers: ref<covers>, holder: account of holder, insurer: account of insurer, expiresAt: date }
   lifecycle { states: [pending, active, cancelled, expired], initial: pending }
   action create {}
-  action activate { from: pending, to: active, actor: { party: insurer } }
+  action activate { from: pending, to: active, requires approval by approval protectedRequest self differentFromInitiator true }
   action cancel {
     from: active, to: cancelled
     invoke: [{ selection: { instrument: slice, reference: "cover", anchor: self.id, states: [paid], limit: 366 }, action: refund, input: {} }]
@@ -17,7 +17,6 @@ instrument cover(holder: party, insurer: party, commission: percent = 0%, covers
       fields {
         cover: ref<parent>, covers: ref<covers>, premium: money = premium, startsAt: date, endsAt: date
         commission: money = rate(self.premium, commission)
-        carrierNet: money = subtract(self.premium, self.commission)
       }
       lifecycle { states: [pending, paid, active, expired, refunded], initial: pending }
       action create {
@@ -43,12 +42,12 @@ instrument cover(holder: party, insurer: party, commission: percent = 0%, covers
 }
 
 instrument claim(cover: ref<insurance.cover>, approved_by: approval) {
-  summary: "A carrier decision reserves one claim payment before settlement."
+  summary: "A claim decision reserves one claim payment before settlement."
   fields { cover: ref<cover>, amount: money, expiresAt: date, evidence: text, reservation: text? }
   lifecycle { states: [submitted, approved, paid, denied, expired], initial: submitted }
   action create { requires self.cover in [active] }
   action approve {
-    from: submitted, to: approved, actor: { party: approved_by }
+    from: submitted, to: approved
     requires approval by approved_by
     deadline: { at: self.expiresAt }
     moves reserve self.amount from self.cover.insurer to self.cover.holder capture "reservation"

package/std/lending.hsx

@@ -1,15 +1,14 @@
 header lending
 
-instrument round(borrower: party, capital: party, plan: ref<financing.installments> = object(financing.installments), months: integer(1, 366) = 3, profit: percent = 3%, minimum_ticket: money = 100 SAR, investor_cap: percent = 20%, commitments: ref<lending.commitment> = object(lending.commitment)) {
+instrument round(borrower: party, plan: ref<financing.installments> = object(financing.installments), minimum_ticket: money = 100 SAR, investor_cap: percent = 20%, commitments: ref<lending.commitment> = object(lending.commitment)) {
   summary: "A threshold funding round; failed rounds return each original wallet contribution."
   fields {
-    borrower: account of borrower, capital: account(capital, cash, "capital"), plan: ref<plan>, price: money, closesAt: date
-    months: integer = months, profit: money = rate(self.price, profit)
+    borrower: account of borrower, plan: ref<plan>, price: money = self.plan.principal, closesAt: date
     minimumTicket: money = minimum_ticket, maximumTicket: money = rate(self.price, investor_cap)
     held: account of self
   }
   lifecycle { states: [open, funded, failed], initial: open }
-  action create { requires unique "funding_plan" on [self.plan]; requires self.months == self.plan.months; requires self.profit == self.plan.profit; requires self.price == self.plan.principal; requires self.borrower == self.plan.funds.payer }
+  action create { requires unique "funding_plan" on [self.plan]; requires self.borrower == self.plan.funds.payer }
   action close {
     from: open, to: funded
     requires sum "amount" of { instrument: commitments, reference: "round", anchor: self.id, states: [committed], limit: 366 } == self.price
@@ -58,13 +57,13 @@ instrument distribution(round: ref<lending.round>, receipt: ref, commitments: re
     held: account of self, losses: account(self, claim), residualLoss: account(residual_to, claim, "loss")
   }
   lifecycle { states: [pending, cash_ready, loss_ready, distributed], initial: pending }
-  action create { requires self.round in [funded]; requires self.source.plan == self.round.plan; requires unique "settlement_consumption" on [self.source.plan, self.source.identity] }
+  action create { requires self.round in [funded]; requires self.source in [recorded]; requires self.source.plan == self.round.plan; requires unique "settlement_consumption" on [self.source.plan, self.source.identity] }
   action prepare_cash {
     from: pending, to: cash_ready
-    requires self.mode == "cash"; requires self.source.kind == "cash"
+    requires self.mode == "cash"; requires self.source.kind == "cash"; requires self.source in [recorded]
     calculate: [
       { target: "principal", op: "sum", values: [{ field: self.source.principal }] }
-      { target: "profit", op: "sum", values: [{ field: self.source.profit }] }
+      { target: "profit", op: "sum", values: [{ field: self.source.retainedProfit }] }
       { target: "charge", op: "rate", base: { field: self.profit }, bps: { literal: fee }, rounding: "floor" }
       { target: "vat", op: "rate", base: { field: self.charge }, bps: { literal: tax }, rounding: "floor" }
       { target: "grossTotal", op: "sum", values: [{ field: self.principal }, { field: self.profit }] }
@@ -73,7 +72,7 @@ instrument distribution(round: ref<lending.round>, receipt: ref, commitments: re
   }
   action prepare_loss {
     from: pending, to: loss_ready
-    requires self.mode == "loss"; requires self.source.kind == "loss"
+    requires self.mode == "loss"; requires self.source.kind == "loss"; requires self.source in [recorded]
     calculate: [{ target: "net", op: "sum", values: [{ field: self.source.loss }] }]
   }
   action distribute_cash {

package/std/marketplace.hsx

@@ -1,6 +1,6 @@
 header marketplace
 
-instrument listing(seller: party, vehicle_facts: enum(optional, required) = optional) {
+instrument listing(seller: party) {
   revisioned: true
   summary: "A seller's offer and its asking price."
   fields { seller: account of seller, title: text, price: money }
@@ -8,8 +8,6 @@ instrument listing(seller: party, vehicle_facts: enum(optional, required) = opti
   action create { actor: { party: seller } }
   action publish {
     from: draft, to: active, actor: { party: seller }
-    when vehicle_facts is required { requires count of { instrument: all(vehicles.vehicle), reference: "listing", anchor: self.id, states: [draft], limit: 1 } == 1 }
-    invoke: [{ selection: { instrument: all(vehicles.vehicle), reference: "listing", anchor: self.id, states: [draft], limit: 1 }, action: publish, input: {} }]
   }
   action withdraw { from: active, to: withdrawn, actor: { party: seller }, requires count of { instrument: all(marketplace.reservation), reference: "listing", anchor: self.id, states: [active], limit: 366 } == 0 }
   action sell { from: active, to: sold, actor: { party: seller }, requires count of { instrument: all(marketplace.reservation), reference: "listing", anchor: self.id, states: [active], limit: 366 } == 0 }
@@ -76,13 +74,12 @@ instrument reservation(listing: ref<marketplace.listing>, funds: ref<escrow.hold
   action credit {
     from: active, to: converted, actor: { parent: converters }, deadline: { at: self.expiresAt }
     input { funds: ref<funds>, contribution: money }
-    requires input.funds == self.funds; requires input.funds in [pending, funded]; requires input.funds.order.listing == self.listing; requires input.funds.payer == self.buyer; requires input.funds.price == self.price
+    requires input.funds == self.funds; requires input.funds in [pending, funded]; requires input.funds.payer == self.buyer; requires input.funds.price == self.price
     requires input.contribution <= self.price
     calculate: [{ target: credit, op: minimum, values: [{ field: self.held.balance }, { field: input.contribution }] }, { target: refund, op: subtract, base: { field: self.held.balance }, subtract: [{ field: self.credit }] }]
     set: { dispositionAt: { field: self.now } }
     moves self.credit from self.held to input.funds.held
     moves self.refund from self.held to self.buyer
-    invoke: [{ reference: input.funds.order, action: commit, input: {} }]
   }
   action cancel {
     from: active, to: cancelled, actor: { party: buyer }, input { reason: text }

package/std/money.hsx

@@ -130,23 +130,24 @@ instrument deposit(payer: party, payee: party, amount: money, expires: date, app
   action cancel { from: pending, to: cancelled }
 }
 
-instrument payout(payer: party, payee: party, amount: money = runtime, reconcile_within: duration = 3d) {
-  summary: "A bank-linked transfer with confirmation bound to its captured identity."
-  fields { amount: money = amount, bank: account(payee, cash, external, "bank"), receipt: text?, expectedAt: date = after(self.createdAt, reconcile_within) }
-  lifecycle { states: [pending, instructed, settled, exception, reversed], initial: pending }
+instrument payout(payer: party, payee: party, adapter: text, max_age: duration, amount: money = runtime) {
+  summary: "Reserve funds until matching terminal boundary evidence permits posting."
+  fields { amount: money = amount, receipt: text? }
+  lifecycle { states: [pending, instructed, settled, rejected], initial: pending }
   action create {}
-  action instruct { from: pending, to: instructed, actor: { party: payer }, humanApproval: "distinct_member", moves self.amount from payer to self.bank capture "receipt" }
-  action confirm {
-    from: [instructed, exception], to: settled
-    requires self.receipt.status == "settled"
+  action instruct {
+    from: pending, to: instructed, actor: { party: payer }, humanApproval: "distinct_member"
+    moves reserve self.amount from payer to payee capture "receipt" boundary adapter
   }
-  action expire {
-    from: instructed, to: exception, actor: clock, due: { at: self.expectedAt }
-    requires self.receipt.status != "settled"
+  action confirm {
+    from: instructed, to: settled
+    requires evidence self.id family boundary check outcome result confirmed maxAge max_age instruction self.receipt
+    moves post self.receipt
   }
-  action reverse {
-    from: [instructed, exception], to: reversed
-    requires self.receipt.status == "reversed"
+  action reject {
+    from: instructed, to: rejected
+    requires evidence self.id family boundary check outcome result rejected maxAge max_age instruction self.receipt
+    moves void self.receipt
   }
 }
 
@@ -158,38 +159,3 @@ instrument metered(payer: party, payee: party, unit_price: money, units: integer
   action bill { from: recorded, to: billed, moves self.amount from payer to payee fee fee }
   action cancel { from: recorded, to: cancelled }
 }
-
-instrument batch(payer: party, payee: party, closes: date, approval: approval, reconcile_within: duration = 3d) {
-  summary: "A frozen positive net of credit and debit entries, paid once."
-  fields { closesAt: date = closes, credits: money, debits: money, amount: money = subtract(self.credits, self.debits), bank: account(payee, cash, external, "bank"), receipt: text?, instructedAt: date?, expectedAt: date? }
-  lifecycle { states: [open, closed, approved, instructed, exception, paid, reversed], initial: open }
-  action create {}
-  action close {
-    from: open, to: closed, actor: clock, due: { at: self.closesAt }
-    requires sum "amount" of { instrument: credit, reference: "batch", anchor: self.id, states: [recorded], limit: 366 } == self.credits
-    requires sum "amount" of { instrument: debit, reference: "batch", anchor: self.id, states: [recorded], limit: 366 } == self.debits
-    requires self.amount > "0"
-  }
-  action approve { from: closed, to: approved, requires approval by approval }
-  action pay {
-    from: approved, to: instructed
-    set: { instructedAt: { field: self.now } }
-    calculate: [{ target: "expectedAt", op: "shift", date: { field: self.now }, milliseconds: { literal: reconcile_within }, direction: "after" }]
-    moves self.amount from payer to self.bank capture "receipt"
-  }
-  action confirm { from: [instructed, exception], to: paid, requires self.receipt.status == "settled" }
-  action expire { from: instructed, to: exception, actor: clock, due: { at: self.expectedAt }, requires self.receipt.status != "settled" }
-  action reverse { from: [instructed, exception], to: reversed, requires self.receipt.status == "reversed" }
-  records {
-    credit: {
-      fields { batch: ref<parent>, identity: text, amount: money }
-      lifecycle { states: [recorded], initial: recorded }
-      action create { requires self.batch in [open]; requires unique "batch_credit" on [self.identity] }
-    }
-    debit: {
-      fields { batch: ref<parent>, identity: text, amount: money }
-      lifecycle { states: [recorded], initial: recorded }
-      action create { requires self.batch in [open]; requires unique "batch_debit" on [self.identity] }
-    }
-  }
-}

package/std/travel.hsx

@@ -10,11 +10,11 @@ instrument package(price: money, supplier_cost: money, departure: date) {
   action close { from: published, to: closed, actor: clock, due: { at: self.departure } }
 }
 
-instrument booking(package: ref<travel.package>, buyer: party, supplier: approval, cover: ref<insurance.cover>, deposit: percent = 30%, balance_before: duration = 14d, confirm_within: duration = 24h, tax: percent = 15%, early_before: duration = 30d, middle_before: duration = 15d, middle_penalty: percent = 10%, late_penalty: percent = 30%) {
+instrument booking(package: ref<travel.package>, buyer: party, supplier: party, approval: approval = programOperator, cover: ref<insurance.cover>, deposit: percent = 30%, balance_before: duration = 14d, confirm_within: duration = 24h, tax: percent = 15%, early_before: duration = 30d, middle_before: duration = 15d, middle_penalty: percent = 10%, late_penalty: percent = 30%) {
   constraints { early_before: greater_than(middle_before) }
-  summary: "A deposited booking with three cancellation bands and supplier confirmation."
+  summary: "A deposited booking with three cancellation bands and confirmation."
   fields {
-    package: ref<package>, bookingReference: text, buyer: account of buyer, supplier: account of supplier
+    package: ref<package>, buyer: account of buyer, supplier: account of supplier
     price: money = self.package.price, supplierCost: money = self.package.supplierCost
     deposit: money = rate(self.price, deposit), balance: money = subtract(self.price, self.deposit)
     margin: money = subtract(self.price, self.supplierCost)
@@ -32,7 +32,6 @@ instrument booking(package: ref<travel.package>, buyer: party, supplier: approva
   lifecycle { states: [created, deposit_paid, paid, completed, cancelled, refunded], initial: created }
   action create {
     requires self.package in [published]
-    requires unique "booking_reference" on [self.bookingReference]
   }
   action deposit {
     from: created, to: deposit_paid, actor: { party: buyer }, deadline: { at: self.balanceAt }
@@ -45,9 +44,9 @@ instrument booking(package: ref<travel.package>, buyer: party, supplier: approva
     moves self.balance from buyer to self.held
   }
   action confirm {
-    from: paid, to: completed, actor: { party: supplier }
+    from: paid, to: completed
     due: { at: self.package.departure }, deadline: { at: self.confirmBy }
-    requires approval by supplier
+    requires approval by approval protectedRequest self differentFromInitiator true
     moves self.supplierCost from self.held to supplier
     moves self.tax from self.held to programTax
     moves self.operatorNet from self.held to programOperator

package/std/vehicles.hsx

@@ -1,34 +0,0 @@
-header vehicles
-
-instrument vehicle(listing: ref<marketplace.listing>, seller: party) {
-  summary: "Seller-declared vehicle identity and kilometre odometer, corrected only before publication."
-  fields {
-    listing: ref<listing>, seller: account of seller
-    vin: text(17, 17, "^[A-HJ-NPR-Z0-9]{17}$"), make: text(1, 80), model: text(1, 80)
-    year: integer(1886, 2200), odometer: integer(0, 10000000), odometerUnit: enum(kilometres) = kilometres
-    correctedAt: date?, correctionEvidence: text?
-  }
-  lifecycle { states: [draft, published], initial: draft }
-  action create {
-    actor: { party: seller }
-    requires self.listing in [draft]; requires self.seller == self.listing.seller
-    requires unique "listing_vehicle" on [self.listing]
-  }
-  action publish {
-    from: draft, to: published, actor: { parent: listing }
-    requires self.listing in [active]
-    requires unique "vehicle_identity" on [self.vin]
-  }
-  action correct {
-    from: draft, to: draft, actor: { party: seller }
-    input { make: text(1, 80), model: text(1, 80), year: integer(1886, 2200), odometer: integer(0, 10000000), evidence: text }
-    requires self.listing in [draft]; requires self.seller == self.listing.seller
-    set: { make: { field: input.make }, model: { field: input.model }, year: { field: input.year }, odometer: { field: input.odometer }, correctionEvidence: { field: input.evidence }, correctedAt: { field: self.now } }
-  }
-  action correct_identity {
-    from: draft, to: draft, actor: { party: seller }
-    input { vin: text(17, 17, "^[A-HJ-NPR-Z0-9]{17}$"), evidence: text }
-    requires self.listing in [draft]; requires self.seller == self.listing.seller
-    set: { vin: { field: input.vin }, correctionEvidence: { field: input.evidence }, correctedAt: { field: self.now } }
-  }
-}