@hyperscale0/hsx 4.0.1 → 4.1.1

package/std/cards.hsx

@@ -20,7 +20,7 @@ instrument card(holder: ref<cards.cardholder>, spend_limit: money) {
   action cancel { from: [issued, active, frozen], to: cancelled }
 }
 
-instrument authorization(card: ref<cards.card>, merchant: party, approval: approval) {
+instrument authorization(card: ref<cards.card>, merchant: party, issuer: party = programOperator) {
   fields { card: ref<card>, merchant: account of merchant, amount: money, expiresAt: date, reservation: text? }
   lifecycle { states: [pending, approved, captured, declined, reversed, expired], initial: pending }
   action create {
@@ -28,13 +28,13 @@ instrument authorization(card: ref<cards.card>, merchant: party, approval: appro
     requires self.amount <= self.card.spendLimit
   }
   action approve {
-    from: pending, to: approved, deadline: { at: self.expiresAt }
-    requires approval by approval; requires self.card in [active]
+    from: pending, to: approved, actor: { party: issuer }, deadline: { at: self.expiresAt }
+    requires self.card in [active]
     moves reserve self.amount from self.card.holder.holder to merchant capture "reservation"
   }
-  action capture { from: approved, to: captured, deadline: { at: self.expiresAt }, moves post self.reservation }
-  action reverse { from: approved, to: reversed, moves void self.reservation }
-  action decline { from: pending, to: declined, requires approval by approval for "approve" is "declined" }
+  action capture { from: approved, to: captured, actor: { party: merchant }, deadline: { at: self.expiresAt }, moves post self.reservation }
+  action reverse { from: approved, to: reversed, actor: { party: merchant }, moves void self.reservation }
+  action decline { from: pending, to: declined, actor: { party: issuer } }
   action expire { from: approved, to: expired, actor: clock, due: { at: self.expiresAt }, moves void self.reservation }
   action abandon { from: pending, to: expired, actor: clock, due: { at: self.expiresAt } }
 }
@@ -44,19 +44,18 @@ instrument transaction(authorization: ref<cards.authorization>) {
   lifecycle { states: [posted, refunded], initial: posted }
   action create { requires self.authorization in [captured]; requires unique "captured_authorization" on [self.authorization] }
   action refund {
-    from: posted, to: refunded, input { reason: text }
+    from: posted, to: refunded, actor: { party: programOperator }, input { reason: text }
     moves self.amount from self.authorization.merchant to self.authorization.card.holder.holder
   }
 }
 
-instrument dispute(transaction: ref<cards.transaction>, approved_by: approval, within: duration = 90d) {
+instrument dispute(transaction: ref<cards.transaction>, issuer: party = programOperator, within: duration = 90d) {
   fields { transaction: ref<transaction>, evidence: text, expiresAt: date = after(self.createdAt, within) }
   lifecycle { states: [filed, reviewing, won, lost], initial: filed }
   action create { requires self.transaction in [posted]; requires unique "disputed_transaction" on [self.transaction] }
-  action review { from: filed, to: reviewing }
+  action review { from: filed, to: reviewing, actor: { party: issuer } }
   action win {
-    from: reviewing, to: won, deadline: { at: self.expiresAt }
-    requires approval by approved_by
+    from: reviewing, to: won, actor: { party: issuer }, deadline: { at: self.expiresAt }
     invoke: [{ reference: self.transaction, action: refund, input: { reason: { field: self.evidence } } }]
   }
   action lose { from: [filed, reviewing], to: lost, actor: clock, due: { at: self.expiresAt } }

package/std/collections.hsx

@@ -1,6 +1,6 @@
 header collections
 
-instrument case(on: ref<financing.installments>[], agency: approval, overdue: duration = 3d, fee: percent = 20%) {
+instrument case(on: ref<financing.installments>[], agency: party, capital: party = programOperator, overdue: duration = 3d, fee: percent = 20%) {
   revisioned: true
   summary: "Refer an overdue installment without creating another debt."
   fields { assignedAgency: account of agency, plan: ref<on>, slice: ref<on.slice>, payment: ref<on.payment>, eligibleAt: date = after(self.slice.dueAt, overdue), agencyFee: money = rate(self.payment.amount, fee) }
@@ -11,10 +11,10 @@ instrument case(on: ref<financing.installments>[], agency: approval, overdue: du
     requires self.slice.principalReceivable.balance > "0"
     requires unique "overdue_referral" on [self.slice]
   }
-  action assign { from: opened, to: assigned, requires approval by agency }
+  action assign { from: opened, to: assigned, actor: { party: capital } }
   action recover { expansionLimit: 8192, from: assigned, to: recovered, actor: { party: agency }, requires self.payment.plan == self.plan, invoke: [{ reference: self.payment, action: pay, input: {} }, { reference: self.id, action: pay_fee, input: {} }] }
   action pay_fee { from: recovered, to: recovered, actor: { parent: current() }, moves self.agencyFee from self.plan.capital to agency }
-  action recall { from: [opened, assigned], to: recalled }
+  action recall { from: [opened, assigned], to: recalled, actor: { party: capital } }
   action return_uncollected { from: assigned, to: returned_uncollected, actor: { party: agency } }
 }
 

package/std/escrow.hsx

@@ -41,11 +41,11 @@ instrument hold(payer: party = party(person), payee: party = programOperator, ac
     deadline: { at: self.deliveredAt, offset: accept_within }
   }
   action verify_return {
-    from: disputed, to: return_verified
+    from: disputed, to: return_verified, actor: { party: payee }
     input { returnEvidence: text }
   }
   action refund {
-    from: dispute.refund_after, to: refunded
+    from: dispute.refund_after, to: refunded, actor: { party: payee }
     moves self.price from self.held to payer
   }
   action cancel { from: pending, to: cancelled }

package/std/financing.hsx

@@ -1,15 +1,15 @@
 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 = object(escrow.hold), approval: approval = programOperator, borrower: party = party(person), capital: party = programOperator, share: percent = 0%, 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<escrow.hold>?, borrower: party = party(person), capital: party = programOperator, share: percent = 0%, limits: ref<financing.limits> = object(financing.limits), portfolio: ref<financing.portfolio_limit> = object(financing.portfolio_limit)) {
   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>
+    funds: ref<funds>?, borrower: account of borrower, settlementIdentity: text, borrowerLimit: ref<limits>, portfolioLimit: ref<portfolio>
     months: integer = months, dates: list(date, months)
     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
+    price: money = subject.price
     downPayment: money = rate(self.price, down_payment)
     principal: money = subtract(self.price, self.downPayment)
     profit: money = rate(self.principal, profit)
@@ -20,7 +20,9 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
   invariants sum "principalReceivable.balance" of { instrument: all(financing.installments.slice), reference: "borrowerLimit", anchor: self.borrowerLimit, states: [pending, due, paid], limit: 366 } <= self.borrowerLimit.limit
   invariants sum "principalReceivable.balance" of { instrument: all(financing.installments.slice), reference: "portfolioLimit", anchor: self.portfolioLimit, states: [pending, due, paid], limit: 366 } <= self.portfolioLimit.limit
   action create {
-    requires self.borrower == self.funds.payer; requires self.borrowerLimit.borrower == self.funds.payer
+    subject { price: money }
+    requires self.borrowerLimit.borrower == self.borrower
+    when disburse_to is funds { requires self.borrower == self.funds.payer }
     invoke: [{ range: { count: { literal: months }, maximum: months, bind: position }, instrument: slice, action: create, input: { plan: { field: self.id }, borrowerLimit: { field: self.borrowerLimit }, portfolioLimit: { field: self.portfolioLimit }, position: { field: position } } }]
   }
   action sign {
@@ -28,8 +30,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
     requires count of { instrument: slice, reference: "plan", anchor: self.id, states: [draft], limit: 366 } == self.months
   }
   action disburse {
-    from: signed, to: active
-    requires approval by approval protectedRequest self differentFromInitiator true
+    from: signed, to: active, actor: { party: capital }
     requires self.borrowerLimit in [approved]
     requires self.portfolioLimit in [approved]
     when disburse_to is funds {
@@ -42,9 +43,11 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
   }
   action fund_down_payment {
     from: active, to: active, actor: { parent: current() }
-    calculate: [{ target: downPaymentCredit, op: minimum, values: [{ field: self.funds.held.balance }, { field: self.downPayment }] }, { target: downPaymentRemaining, op: subtract, base: { field: self.downPayment }, subtract: [{ field: self.downPaymentCredit }] }]
-    moves self.downPaymentRemaining from self.funds.payer to self.funds.held
-    moves self.principal from self.capital to self.funds.held
+    when disburse_to is funds {
+      calculate: [{ target: downPaymentCredit, op: minimum, values: [{ field: self.funds.held.balance }, { field: self.downPayment }] }, { target: downPaymentRemaining, op: subtract, base: { field: self.downPayment }, subtract: [{ field: self.downPaymentCredit }] }]
+      moves self.downPaymentRemaining from self.funds.payer to self.funds.held
+      moves self.principal from self.capital to self.funds.held
+    }
   }
   action complete {
     from: active, to: paid
@@ -90,8 +93,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
       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
+        from: requested, to: applied, actor: { party: capital }
         invoke: [{ reference: self.plan, action: write_off, input: { overdueSlice: { field: self.overdueSlice } } }]
       }
       action cancel { from: requested, to: cancelled }
@@ -140,7 +142,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
       }
       lifecycle { states: [proposed, applied, declined, withdrawn, expired, superseded], initial: proposed }
       action create {
-        actor: { party: borrower }
+        actor: { party: capital }
         requires self.plan in [active]; requires self.waiverPercent <= self.maximumWaiver
         set: { revision: { field: self.productRevision } }
         calculate: [
@@ -156,7 +158,6 @@ 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 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 }
@@ -165,8 +166,8 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
         invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due], limit: 366, order: [position] }, action: amend, input: { amendment: { field: self.id } } }]
         invoke: [{ selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [paid], limit: 366 }, action: verify_fixed_date, input: { amendment: { field: self.id } } }]
       }
-      action withdraw { from: proposed, to: withdrawn, actor: { party: borrower } }
-      action decline { from: proposed, to: declined, actor: { party: approval } }
+      action withdraw { from: proposed, to: withdrawn, actor: { party: capital } }
+      action decline { from: proposed, to: declined, actor: { party: borrower } }
       action expire { from: proposed, to: expired, actor: clock, due: { at: self.expiresAt } }
       action supersede { from: proposed, to: superseded, requires self.revision != self.productRevision, set: { staleReason: { literal: "economic_revision_changed" } } }
     }
@@ -200,7 +201,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
     slice: {
       revisioned: true
       fields {
-        plan: ref<parent>, borrowerLimit: ref<limits>, portfolioLimit: ref<limits.portfolio>, position: integer(1, months)
+        plan: ref<parent>, borrowerLimit: ref<limits>, portfolioLimit: ref<portfolio>, position: integer(1, months)
         originalDueAt: date = at(self.plan.dates, self.position), dueAt: date?, nextDueAt: date?, previousDueAt: date?, previousPosition: integer?, previousDate: date?, extensionLimit: date = after(self.originalDueAt, max_extension), lossEligibleAt: date?
         principalBase: money = divide(self.plan.principal, months)
         principalAllocated: money = multiply(self.principalBase, months)
@@ -221,7 +222,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
       lifecycle { states: [draft, pending, due, paid, written_off], initial: draft }
       action create {
         actor: { parent: parent }
-        input { plan: ref<parent>, borrowerLimit: ref<limits>, portfolioLimit: ref<limits.portfolio>, position: integer(1, months) }
+        input { plan: ref<parent>, borrowerLimit: ref<limits>, portfolioLimit: ref<portfolio>, position: integer(1, months) }
         set: { dueAt: { field: self.originalDueAt } }
         invoke: [{ reference: self.id, action: refresh_loss_date, input: {} }]
         requires self.plan in [quoted]; requires unique "signed_position" on [self.plan, self.position]; requires self.borrowerLimit == self.plan.borrowerLimit; requires self.portfolioLimit == self.plan.portfolioLimit
@@ -354,7 +355,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
       action create { input { plan: ref<parent>, amount: money, paymentIdentity: text } requires self.plan in [active]; requires unique "payment_identity" on [self.plan, self.paymentIdentity] }
       action pay {
         expansionLimit: 8192
-        from: pending, to: paid
+        from: pending, to: paid, actor: { party: borrower }
         calculate: [{ target: outstandingPrincipal, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366, order: [position] }, measure: { sum: "principalReceivable.balance" } }]
         when profit_earned is on_payment { calculate: [{ target: outstandingProfit, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366, order: [position] }, measure: { sum: "profitReceivable.balance" } }] }
         when profit_earned is by_schedule { calculate: [{ target: outstandingProfit, op: aggregate, selection: { instrument: slice, reference: "plan", anchor: self.plan, states: [pending, due, paid], limit: 366, order: [position] }, measure: { sum: "profitEarned.balance" } }] }
@@ -384,7 +385,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
         invoke: [{ reference: self.plan, action: record_payment, input: { identity: { field: self.paymentIdentity }, principal: { field: self.principalReturned }, profit: { field: self.profitReturned } } }]
       }
       action refund {
-        from: paid, to: refunded
+        from: paid, to: refunded, actor: { party: capital }
         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: {} }]
@@ -406,7 +407,7 @@ instrument installments(months: integer(1, 366), charge_limit: integer(1, 3) = 3
       }
       action refund {
         from: paid, to: refunded, actor: { parent: payment }
-        moves self.amount from self.slice.plan.capital to self.slice.plan.funds.payer; moves self.amount from self.slice.debt to self.slice.principalReceivable
+        moves self.amount from self.slice.plan.capital to self.slice.plan.borrower; moves self.amount from self.slice.debt to self.slice.principalReceivable
       }
     }
     profit_piece: {
@@ -433,7 +434,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)) {
+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, borrower: party = party(person)) {
   revisioned: true
   familyRevision: 1
   summary: "Separate approved fine and evidenced recovery claims on an overdue installment."
@@ -444,18 +445,18 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
   lifecycle { states: [proposed, assessed, collected, waived, refunded], initial: proposed }
   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 protectedRequest self differentFromInitiator true
+    from: proposed, to: assessed, actor: clock, due: { at: self.overdueAt }
+    requires self.slice.principalReceivable.balance > "0"
     moves self.fine from self.debt to self.receivable
   }
   action collect {
-    from: [assessed, collected], to: assessed, input { payment: ref<on.payment> }
+    from: [assessed, collected], to: assessed, actor: { parent: child(on, slice) }, input { payment: ref<on.payment> }
     requires input.payment in [paid]
     requires input.payment.plan == self.plan
     invoke: [{ instrument: receipt, action: create, input: { assessment: { field: self.id }, payment: { field: input.payment } } }, { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 1, where: { id: { field: self.id }, receivable.balance: { literal: "0" } } }, action: finish, input: {} }]
   }
   action payoff {
-    from: [assessed, collected], to: collected
+    from: [assessed, collected], to: collected, actor: { parent: on }
     requires self.plan in [paid]
     moves self.receivable.balance from self.plan.borrower to fines_to
     moves self.receivable.balance from self.receivable to self.debt
@@ -469,7 +470,7 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
   }
   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> }
+    from: [assessed, collected], to: assessed, actor: { party: fines_to }, input { payment: ref<on.payment> }
     requires input.payment in [paid, refunded]
     requires input.payment.plan == self.plan
     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: {} }]
@@ -480,8 +481,7 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
       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
+        from: requested, to: applied, actor: { party: fines_to }, input { reason: text, evidence: text }
         invoke: [{ reference: self.assessment, action: waive, input: { reason: { field: input.reason }, evidence: { field: input.evidence } } }]
       }
       action cancel { from: requested, to: cancelled }
@@ -512,18 +512,18 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
       lifecycle { states: [proposed, assessed, collected, waived, refunded], initial: proposed }
       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 protectedRequest self differentFromInitiator true
+        from: proposed, to: assessed, actor: clock, due: { at: self.assessment.overdueAt }
+        requires self.assessment.slice.principalReceivable.balance > "0"
         moves self.amount from self.debt to self.receivable
       }
       action collect {
-        from: [assessed, collected], to: assessed, input { payment: ref<on.payment> }
+        from: [assessed, collected], to: assessed, actor: { parent: child(on, slice) }, input { payment: ref<on.payment> }
         requires input.payment in [paid]
         requires input.payment.plan == self.plan
         invoke: [{ instrument: receipt, action: create, input: { assessment: { field: self.id }, payment: { field: input.payment } } }, { selection: { instrument: current(), reference: "plan", anchor: self.plan, states: [assessed], limit: 1, where: { id: { field: self.id }, receivable.balance: { literal: "0" } } }, action: finish, input: {} }]
       }
       action payoff {
-        from: [assessed, collected], to: collected
+        from: [assessed, collected], to: collected, actor: { parent: on }
         requires self.plan in [paid]
         moves self.receivable.balance from self.plan.borrower to costs_to
         moves self.receivable.balance from self.receivable to self.debt
@@ -537,7 +537,7 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
       }
       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> }
+        from: [assessed, collected], to: assessed, actor: { party: costs_to }, input { payment: ref<on.payment> }
         requires input.payment in [paid, refunded]
         requires input.payment.plan == self.plan
         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: {} }]
@@ -548,8 +548,7 @@ instrument late_charge(on: ref<financing.installments>[], grace: duration = 3d,
           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
+            from: requested, to: applied, actor: { party: costs_to }, input { reason: text, evidence: text }
             invoke: [{ reference: self.assessment, action: waive, input: { reason: { field: input.reason }, evidence: { field: input.evidence } } }]
           }
           action cancel { from: requested, to: cancelled }
@@ -575,32 +574,36 @@ 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) {
+instrument limits(per_borrower: money, borrower: party = party(person), active_plans: integer = 1) {
   familyRevision: 1
-  summary: "One borrower ceiling and one shared portfolio ceiling."
+  summary: "One outstanding balance ceiling per borrower."
   fields { borrower: account of borrower, limit: money = per_borrower, activePlans: integer = active_plans }
   lifecycle { states: [pending, approved], initial: pending }
   action create { requires unique "borrower_limit" on [self.borrower] }
   action approve { from: pending, to: approved }
-  records {
-    portfolio: {
-      fields { key: text = "portfolio", limit: money = portfolio }
-      lifecycle { states: [pending, approved], initial: pending }
-      action create { requires unique "portfolio_limit" on [self.key] }
-      action approve { from: pending, to: approved }
-    }
-  }
 }
 
-instrument credit_line(borrower: party, lender: party, limit: money, expires: date) {
+instrument portfolio_limit(limit: money) {
   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 }
+  summary: "One shared ceiling on the principal the product may hold."
+  fields { key: text = "portfolio", limit: money = limit }
+  lifecycle { states: [pending, approved], initial: pending }
+  action create { requires unique "portfolio_limit" on [self.key] }
+  action approve { from: pending, to: approved }
+}
+
+instrument credit_line(borrower: party = programOperator, adapter: text, limit: money, expires: date) {
+  familyRevision: 1
+  summary: "A revolving facility from an outside lender; each draw is a separate immutable advance."
+  fields { borrower: account of borrower, facility: account(borrower, cash, "facility"), debt: account(borrower, claim, contra, "debt"), limit: money = limit, expiresAt: date = expires }
   lifecycle { states: [pending, active, suspended, closed], initial: pending }
   action create {}
-  action activate { from: pending, to: active, actor: { party: lender } }
-  action suspend { from: active, to: suspended, actor: { party: lender } }
-  action resume { from: suspended, to: active, actor: { party: lender } }
+  action activate {
+    from: pending, to: active, actor: { party: borrower }
+    subject { adapter: adapter }
+  }
+  action suspend { from: active, to: suspended, actor: { party: borrower } }
+  action resume { from: suspended, to: active, actor: { party: borrower } }
   action close { from: [active, suspended], to: closed, due: { at: self.expiresAt }, requires count of { instrument: all(financing.advance), reference: "line", anchor: self.id, states: [drawn], limit: 366 } == 0 }
 }
 
@@ -615,8 +618,8 @@ instrument advance(line: ref<financing.credit_line>, amount: money = runtime) {
     from: pending, to: drawn
     requires self.line in [active]
     deadline: { at: self.line.expiresAt }
-    moves self.amount from self.line.lender to self.line.borrower; moves self.amount from self.line.debt to self.principalReceivable
+    moves self.amount from self.line.facility to self.line.borrower; moves self.amount from self.line.debt to self.principalReceivable
   }
-  action repay { from: drawn, to: repaid, moves self.amount from self.line.borrower to self.line.lender; moves self.amount from self.principalReceivable to self.line.debt }
+  action repay { from: drawn, to: repaid, moves self.amount from self.line.borrower to self.line.facility; moves self.amount from self.principalReceivable to self.line.debt }
   action cancel { from: pending, to: cancelled }
 }

package/std/insurance.hsx

@@ -1,13 +1,16 @@
 header insurance
 
-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 }
+instrument cover(holder: party, adapter: text, commission: percent = 0%, covers: ref, premium: money = runtime) {
+  summary: "Recurring cover bound to an outside insurer across an ADL boundary."
+  fields { covers: ref<covers>, holder: account of holder, expiresAt: date }
   lifecycle { states: [pending, active, cancelled, expired], initial: pending }
   action create {}
-  action activate { from: pending, to: active, requires approval by approval protectedRequest self differentFromInitiator true }
+  action activate {
+    from: pending, to: active, actor: { party: programOperator }
+    subject { adapter: adapter }
+  }
   action cancel {
-    from: active, to: cancelled
+    from: active, to: cancelled, actor: { party: holder }
     invoke: [{ selection: { instrument: slice, reference: "cover", anchor: self.id, states: [paid], limit: 366 }, action: refund, input: {} }]
   }
   action expire { from: active, to: expired, actor: clock, due: { at: self.expiresAt } }
@@ -25,34 +28,32 @@ instrument cover(holder: party, insurer: party, approval: approval = programOper
         requires unique "premium_period" on [self.cover, self.startsAt, self.endsAt]
       }
       action collect {
-        from: pending, to: paid
+        from: pending, to: paid, actor: { party: holder }
         requires self.cover in [active]
-        moves self.premium from holder to insurer
-        moves self.commission from insurer to programOperator
+        moves self.premium from holder to programOperator
       }
       action start { from: paid, to: active, actor: clock, due: { at: self.startsAt } }
       action expire { from: active, to: expired, actor: clock, due: { at: self.endsAt } }
       action refund {
-        from: paid, to: refunded, deadline: { at: self.startsAt }
-        moves self.commission from programOperator to insurer
-        moves self.premium from insurer to holder
+        from: paid, to: refunded, actor: { parent: parent }, deadline: { at: self.startsAt }
+        moves self.premium from programOperator to holder
       }
     }
   }
 }
 
-instrument claim(cover: ref<insurance.cover>, approved_by: approval) {
+instrument claim(cover: ref<insurance.cover>, inspector: party) {
   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
-    requires approval by approved_by
+    actor: { party: inspector }
     deadline: { at: self.expiresAt }
-    moves reserve self.amount from self.cover.insurer to self.cover.holder capture "reservation"
+    moves reserve self.amount from programOperator to self.cover.holder capture "reservation"
   }
-  action pay { from: approved, to: paid, deadline: { at: self.expiresAt }, moves post self.reservation }
-  action deny { from: submitted, to: denied, requires approval by approved_by for approve is "declined" }
+  action pay { from: approved, to: paid, actor: { party: inspector }, deadline: { at: self.expiresAt }, moves post self.reservation }
+  action deny { from: submitted, to: denied, actor: { party: inspector } }
   action expire { from: approved, to: expired, actor: clock, due: { at: self.expiresAt }, moves void self.reservation }
 }

package/std/lending.hsx

@@ -1,6 +1,6 @@
 header lending
 
-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)) {
+instrument round(borrower: party, plan: ref<financing.installments> = object(financing.installments), operator: party = programOperator, 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, plan: ref<plan>, price: money = self.plan.principal, closesAt: date
@@ -8,9 +8,9 @@ instrument round(borrower: party, plan: ref<financing.installments> = object(fin
     held: account of self
   }
   lifecycle { states: [open, funded, failed], initial: open }
-  action create { requires unique "funding_plan" on [self.plan]; requires self.borrower == self.plan.funds.payer }
+  action create { requires unique "funding_plan" on [self.plan]; requires self.borrower == self.plan.borrower }
   action close {
-    from: open, to: funded
+    from: open, to: funded, actor: { party: operator }
     requires sum "amount" of { instrument: commitments, reference: "round", anchor: self.id, states: [committed], limit: 366 } == self.price
     requires self.held.balance == self.price
     moves self.price from self.held to self.plan.capital
@@ -30,6 +30,7 @@ instrument commitment(round: ref<lending.round>, wallet: ref<wallet.balance>, in
   invariants sum "amount" of { instrument: all(lending.commitment), reference: "round", anchor: self.round, states: [committed, funded], limit: 366, where: { wallet: { field: self.wallet } } } <= self.round.maximumTicket
   invariants sum "amount" of { instrument: all(lending.commitment), reference: "round", anchor: self.round, states: [committed, funded], limit: 366 } <= self.round.price
   action create {
+    actor: { party: investor }
     requires self.round in [open]
     requires self.wallet in [active]
     requires self.amount >= self.round.minimumTicket
@@ -38,7 +39,7 @@ instrument commitment(round: ref<lending.round>, wallet: ref<wallet.balance>, in
   }
   action fund { from: committed, to: funded, actor: { parent: round } }
   action withdraw {
-    from: committed, to: withdrawn
+    from: committed, to: withdrawn, actor: { party: investor }
     requires self.round in [open]
     deadline: { at: self.round.closesAt }
     moves self.amount from self.round.held to self.wallet.held
@@ -49,7 +50,7 @@ instrument commitment(round: ref<lending.round>, wallet: ref<wallet.balance>, in
   }
 }
 
-instrument distribution(round: ref<lending.round>, receipt: ref, commitments: ref<lending.commitment> = object(lending.commitment), mode: enum(cash, loss) = cash, residual_to: party = programOperator, fee: percent = 1%, tax: percent = 15%) {
+instrument distribution(round: ref<lending.round>, receipt: ref, commitments: ref<lending.commitment> = object(lending.commitment), mode: enum(cash, loss) = cash, residual_to: party = programOperator, operator: party = programOperator, fee: percent = 1%, tax: percent = 15%) {
   summary: "Frozen weighted shares, floored once, with residual assigned to the chosen party."
   fields {
     round: ref<round>, source: ref<receipt>, mode: enum(cash, loss) = mode
@@ -76,7 +77,7 @@ instrument distribution(round: ref<lending.round>, receipt: ref, commitments: re
     calculate: [{ target: "net", op: "sum", values: [{ field: self.source.loss }] }]
   }
   action distribute_cash {
-    from: cash_ready, to: distributed
+    from: cash_ready, to: distributed, actor: { party: operator }
     requires sum "weight" of { instrument: share, reference: "distribution", anchor: self.id, states: [pending], limit: 366 } == self.round.price
     moves self.principal from self.source.capital to self.held; moves self.profit from self.source.profitIncome to self.held; moves self.charge from self.held to programOperator; moves self.vat from self.held to programTax
     invoke: [{ selection: { instrument: share, reference: "distribution", anchor: self.id, states: [pending], limit: 366 }, action: cash, input: {} }, { reference: self.id, action: residual_cash, input: {} }]
@@ -86,7 +87,7 @@ instrument distribution(round: ref<lending.round>, receipt: ref, commitments: re
     moves self.held.balance from self.held to residual_to
   }
   action distribute_loss {
-    from: loss_ready, to: distributed
+    from: loss_ready, to: distributed, actor: { party: operator }
     requires sum "weight" of { instrument: share, reference: "distribution", anchor: self.id, states: [pending], limit: 366 } == self.round.price
     moves self.net from self.source.lossAccount to self.losses
     invoke: [{ selection: { instrument: share, reference: "distribution", anchor: self.id, states: [pending], limit: 366 }, action: loss, input: {} }, { reference: self.id, action: residual_loss, input: {} }]

package/std/money.hsx

@@ -26,11 +26,11 @@ instrument hold(payer: party, payee: party, amount: money = runtime) {
     requires self.held.balance == self.amount
   }
   action release {
-    from: funded, to: released
+    from: funded, to: released, actor: { party: payer }
     moves self.amount from self.held to payee
   }
   action refund {
-    from: funded, to: refunded
+    from: funded, to: refunded, actor: { party: payee }
     moves self.amount from self.held to payer
   }
   action cancel { from: pending, to: cancelled }
@@ -41,7 +41,7 @@ instrument split(payer: party, amount: money = runtime, shares: split = { progra
   fields { amount: money = amount }
   lifecycle { states: [pending, paid, cancelled], initial: pending }
   action create {}
-  action pay { from: pending, to: paid, moves self.amount from payer shares shares }
+  action pay { from: pending, to: paid, actor: { party: payer }, moves self.amount from payer shares shares }
   action cancel { from: pending, to: cancelled }
 }
 
@@ -84,7 +84,7 @@ instrument pool(payer: party, payee: party, target: money, closes: date) {
   lifecycle { states: [open, paid, failed], initial: open }
   action create { }
   action pay {
-    from: open, to: paid
+    from: open, to: paid, actor: { party: payee }
     requires self.held.balance == self.target
     moves self.target from self.held to payee
   }
@@ -98,7 +98,7 @@ instrument pool(payer: party, payee: party, target: money, closes: date) {
       fields { pool: ref<parent>, payer: account of payer, amount: money }
       lifecycle { states: [pending, paid, refunded], initial: pending }
       action create { requires self.pool in [open] }
-      action pay { from: pending, to: paid, deadline: { at: self.pool.closesAt }, requires self.pool in [open], moves self.amount from self.payer to self.pool.held }
+      action pay { from: pending, to: paid, actor: { party: payer }, deadline: { at: self.pool.closesAt }, requires self.pool in [open], moves self.amount from self.payer to self.pool.held }
       action refund { from: paid, to: refunded, actor: { parent: parent }, moves self.amount from self.pool.held to self.payer }
     }
   }
@@ -114,29 +114,19 @@ instrument swap(first: party, second: party, first_amount: money, second_amount:
   action start_second { from: pending, to: second_ready, actor: { party: second }, deadline: { at: self.expiresAt }, moves reserve self.secondAmount from second to first capture "secondReceipt" }
   action finish_first { from: second_ready, to: both_ready, actor: { party: first }, deadline: { at: self.expiresAt }, moves reserve self.firstAmount from first to second capture "firstReceipt" }
   action expire_second { from: second_ready, to: cancelled, actor: clock, due: { at: self.expiresAt }, moves void self.secondReceipt }
-  action exchange { from: both_ready, to: exchanged, moves post self.firstReceipt; moves post self.secondReceipt }
+  action exchange { from: both_ready, to: exchanged, actor: { party: first }, moves post self.firstReceipt; moves post self.secondReceipt }
   action cancel { from: pending, to: cancelled }
   action expire_first { from: first_ready, to: cancelled, actor: clock, due: { at: self.expiresAt }, moves void self.firstReceipt }
   action expire_both { from: both_ready, to: cancelled, actor: clock, due: { at: self.expiresAt }, moves void self.firstReceipt; moves void self.secondReceipt }
 }
 
-instrument deposit(payer: party, payee: party, amount: money, expires: date, approval: approval) {
-  fields { amount: money = amount, expiresAt: date = expires, reservation: text? }
-  lifecycle { states: [pending, held, claimed, returned, cancelled], initial: pending }
-  action create {}
-  action fund { from: pending, to: held, actor: { party: payer }, moves reserve self.amount from payer to payee capture "reservation" }
-  action claim { from: held, to: claimed, deadline: { at: self.expiresAt }, requires approval by approval, moves post self.reservation }
-  action return { from: held, to: returned, actor: clock, due: { at: self.expiresAt }, moves void self.reservation }
-  action cancel { from: pending, to: cancelled }
-}
-
 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"
+    from: pending, to: instructed, actor: { party: payer }
     moves reserve self.amount from payer to payee capture "receipt" boundary adapter
   }
   action confirm {
@@ -156,6 +146,6 @@ instrument metered(payer: party, payee: party, unit_price: money, units: integer
   fields { usageIdentity: text, unitPrice: money = unit_price, units: integer = units, amount: money = multiply(self.unitPrice, self.units) }
   lifecycle { states: [recorded, billed, cancelled], initial: recorded }
   action create { requires unique "usage_event" on [self.usageIdentity] }
-  action bill { from: recorded, to: billed, moves self.amount from payer to payee fee fee }
+  action bill { from: recorded, to: billed, actor: { party: payee }, moves self.amount from payer to payee fee fee }
   action cancel { from: recorded, to: cancelled }
 }

package/std/reporting.hsx

@@ -351,7 +351,6 @@ instrument portfolio(on: ref<financing.installments>[], default_days: integer(1,
         request: [ "owner", "finance" ],
         read: [ "owner", "admin", "operations", "finance", "viewer" ],
         release: [  ],
-        independentApproval: true,
         retention: { policy: "report_replay", years: retention_years }
       }
     },
@@ -632,7 +631,6 @@ instrument portfolio(on: ref<financing.installments>[], default_days: integer(1,
         request: [ "owner", "finance" ],
         read: [ "owner", "admin", "operations", "finance", "viewer" ],
         release: [  ],
-        independentApproval: true,
         retention: { policy: "report_replay", years: retention_years }
       }
     },
@@ -1002,7 +1000,6 @@ instrument portfolio(on: ref<financing.installments>[], default_days: integer(1,
         request: [ "owner", "finance" ],
         read: [ "owner", "admin", "operations", "finance", "viewer" ],
         release: [  ],
-        independentApproval: true,
         retention: { policy: "report_replay", years: retention_years }
       }
     },
@@ -1278,7 +1275,6 @@ instrument portfolio(on: ref<financing.installments>[], default_days: integer(1,
         request: [ "owner", "finance" ],
         read: [ "owner", "admin", "operations", "finance", "viewer" ],
         release: [  ],
-        independentApproval: true,
         retention: { policy: "report_replay", years: retention_years }
       }
     }