@hyperscale0/hsx 3.2.0 → 4.0.0

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,24 +1,108 @@
 header marketplace
 
 instrument listing(seller: party) {
+  revisioned: true
   summary: "A seller's offer and its asking price."
   fields { seller: account of seller, title: text, price: money }
   lifecycle { states: [draft, active, withdrawn, sold], initial: draft }
   action create { actor: { party: seller } }
-  action publish { from: draft, to: active, actor: { party: seller } }
-  action withdraw { from: active, to: withdrawn, actor: { party: seller } }
-  action sell { from: active, to: sold, actor: { party: seller } }
+  action publish {
+    from: draft, to: active, actor: { party: seller }
+  }
+  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 }
 }
 
 instrument order(listing: ref<marketplace.listing>, buyer: party) {
+  revisioned: true
   summary: "A buyer's order for one listing at its declared price."
-  fields { listing: ref<listing>, buyer: account of buyer, price: money }
-  lifecycle { states: [placed, fulfilled, cancelled], initial: placed }
+  fields { listing: ref<listing>, buyer: account of buyer, price: money, reservations: integer?, ownReservations: integer?, blockingQuotes: integer?, ownBlockingQuotes: integer? }
+  lifecycle { states: [quoted, placed, fulfilled, cancelled], initial: quoted }
   action create {
     actor: { party: buyer }
     requires self.listing in [active]
+    calculate: [
+      { target: blockingQuotes, op: aggregate, selection: { instrument: all(marketplace.reservation), reference: "listing", anchor: self.listing, states: [active], limit: 366, where: { quotePolicy: { literal: "blocked" } } }, measure: count }
+      { target: ownBlockingQuotes, op: aggregate, selection: { instrument: all(marketplace.reservation), reference: "listing", anchor: self.listing, states: [active], limit: 366, where: { quotePolicy: { literal: "blocked" }, buyer: { field: self.buyer } } }, measure: count }
+    ]
+    requires self.blockingQuotes == self.ownBlockingQuotes
     requires self.price == self.listing.price
   }
+  action commit {
+    from: [quoted, placed], to: placed
+    requires self.listing in [active]
+    calculate: [
+      { target: reservations, op: aggregate, selection: { instrument: all(marketplace.reservation), reference: "listing", anchor: self.listing, states: [active], limit: 366 }, measure: count }
+      { target: ownReservations, op: aggregate, selection: { instrument: all(marketplace.reservation), reference: "listing", anchor: self.listing, states: [active], limit: 366, where: { buyer: { field: self.buyer } } }, measure: count }
+    ]
+    requires self.reservations == self.ownReservations
+    requires count of { instrument: current(), reference: "listing", anchor: self.listing, states: [placed, fulfilled], limit: 366 } <= 1
+  }
+  invariants count of { instrument: current(), reference: "listing", anchor: self.listing, states: [placed, fulfilled], limit: 366 } <= 1
   action fulfill { from: placed, to: fulfilled }
-  action cancel { from: placed, to: cancelled, actor: { party: buyer } }
+  action cancel { from: [quoted, placed], to: cancelled, actor: { party: buyer } }
+}
+
+instrument reservation(listing: ref<marketplace.listing>, funds: ref<escrow.hold>, plans: ref<financing.installments>[], converters: ref[], buyer: party, seller: party, expires_after: duration = 48h, deposit: money = 1000 SAR, cancellation_refund: percent = 100%, expiry_refund: percent = 100%, retained_to: party = programOperator, operator: party = programOperator, competing_quotes: enum(allowed, blocked) = allowed) {
+  revisioned: true
+  summary: "Exclusive timed listing hold with explicit deposit credit and refund."
+  fields {
+    listing: ref<listing>, funds: ref<funds>, buyer: account of buyer, seller: account of seller, price: money, terms: text
+    held: account of self, quotePolicy: enum(allowed, blocked) = competing_quotes, deposit: money = deposit, proposalExpiresAt: date = after(self.createdAt, expires_after), expiresAt: date?
+    credit: money?, refund: money?, retained: money?, dispositionAt: date?, reason: text?
+  }
+  lifecycle { states: [proposed, active, converted, cancelled, expired], initial: proposed }
+  invariants count of { instrument: current(), reference: "listing", anchor: self.listing, states: [active], limit: 366 } <= 1
+  action create { actor: { party: buyer }, requires self.listing in [active]; requires self.seller == self.listing.seller; requires self.price == self.listing.price }
+  action activate {
+    from: proposed, to: active, actor: { party: buyer }, deadline: { at: self.proposalExpiresAt }
+    calculate: [{ target: expiresAt, op: shift, date: { field: self.now }, milliseconds: { literal: expires_after }, direction: after }]
+    requires self.listing in [active]; requires self.price == self.listing.price
+    requires count of { instrument: all(marketplace.order), reference: "listing", anchor: self.listing, states: [placed, fulfilled], limit: 366 } == 0
+    moves self.deposit from self.buyer to self.held
+  }
+  action convert_financed {
+    from: active, to: active, actor: { party: buyer }, deadline: { at: self.expiresAt }
+    input { plan: ref<plans> }
+    requires input.plan.funds == self.funds; requires input.plan.borrower == self.buyer
+    invoke: [{ reference: input.plan, action: disburse, input: {} }]
+  }
+  action convert_cash {
+    from: active, to: active, actor: { party: buyer }, deadline: { at: self.expiresAt }
+    invoke: [{ reference: self.funds, action: fund, input: {} }]
+  }
+  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.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
+  }
+  action cancel {
+    from: active, to: cancelled, actor: { party: buyer }, input { reason: text }
+    calculate: [{ target: refund, op: rate, base: { field: self.held.balance }, bps: { literal: cancellation_refund }, rounding: floor }, { target: retained, op: subtract, base: { field: self.held.balance }, subtract: [{ field: self.refund }] }]
+    set: { reason: { field: input.reason }, dispositionAt: { field: self.now } }
+    moves self.refund from self.held to self.buyer; moves self.retained from self.held to retained_to
+  }
+  action seller_cancel {
+    from: active, to: cancelled, actor: { party: seller }, input { reason: text }
+    set: { reason: { field: input.reason }, dispositionAt: { field: self.now } }
+    moves self.held.balance from self.held to self.buyer
+  }
+  action operator_cancel {
+    from: active, to: cancelled, actor: { party: operator }, input { reason: text }
+    set: { reason: { field: input.reason }, dispositionAt: { field: self.now } }
+    moves self.held.balance from self.held to self.buyer
+  }
+  action withdraw { from: proposed, to: cancelled, actor: { party: buyer } }
+  action expire {
+    from: active, to: expired, actor: clock, due: { at: self.expiresAt }
+    calculate: [{ target: refund, op: rate, base: { field: self.held.balance }, bps: { literal: expiry_refund }, rounding: floor }, { target: retained, op: subtract, base: { field: self.held.balance }, subtract: [{ field: self.refund }] }]
+    set: { dispositionAt: { field: self.now } }
+    moves self.refund from self.held to self.buyer; moves self.retained from self.held to retained_to
+  }
+  action expire_proposal { from: proposed, to: expired, actor: clock, due: { at: self.proposalExpiresAt } }
 }

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 }, 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] }
-    }
-  }
-}