@hyperscale0/hsx 1.0.125 → 1.0.130

package/std/insurance.hsx

@@ -4,7 +4,11 @@ header insurance
 // Outside broker commissions are pass-through. Adapter-owned premium and claim
 // accounts lack an authored source party, so their moves remain unclassified.
 
-// Expose cover.create, activate and cancel separately. Activation binds adapter;
+// Expose cover.create, activate and cancel separately. The adapter names a
+// registered boundary adapter (conformance_boundary in sandbox). covers is an
+// optional link to a sibling attachment; the attached object is already the
+// insured thing. claim_limit is the sum insured: approved and paid claims on one
+// cover never total more. Activation binds adapter;
 // each slice needs a separately created unique period and an active cover to collect.
 // Collection debits holder for insurerPremium to the insurer and commission to
 // broker as two moves. Broker defaults to programOperator; bind a declared business
@@ -23,9 +27,9 @@ header insurance
 // reserves once; pay posts once and expiry voids once. Cover cancellation adds
 // bounded slice invocations. Run hsx cost for composed counts, not provider prices.
 
-instrument cover(holder: party, adapter: text, commission: percent = 0%, broker: party = programOperator, covers: ref, premium: money = runtime) {
+instrument cover(holder: party, adapter: text, commission: percent = 0%, broker: party = programOperator, covers: ref?, premium: money = runtime, claim_limit: money = runtime) {
   summary: "Recurring cover bound to an outside insurer across an ADL boundary."
-  fields { covers: ref<covers>, holder: account of holder, insurer: account(adapter(adapter), cash, "premium"), expiresAt: date }
+  fields { covers: ref<covers>?, holder: account of holder, insurer: account(adapter(adapter), cash, "premium"), expiresAt: date, claimLimit: money = claim_limit }
   lifecycle { states: [pending, active, cancelled, expired], initial: pending }
   action create {}
   action activate {
@@ -41,13 +45,12 @@ instrument cover(holder: party, adapter: text, commission: percent = 0%, broker:
     slice: {
       summary: "A whole premium period, collected once and refundable only before it starts."
       fields {
-        cover: ref<parent>, covers: ref<covers>, premium: money = premium, startsAt: date, endsAt: date
+        cover: ref<parent>, premium: money = premium, startsAt: date, endsAt: date
         commission: money = rate(self.premium, commission)
         insurerPremium: money = subtract(self.premium, self.commission), commissionReceipt: text?
       }
       lifecycle { states: [pending, paid, active, expired, refunded], initial: pending }
       action create {
-        requires self.covers == self.cover.covers
         requires self.startsAt < self.endsAt
         requires unique "premium_period" on [self.cover, self.startsAt, self.endsAt]
       }
@@ -76,6 +79,7 @@ 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 }
+  invariants sum "amount" of { instrument: current(), reference: "cover", anchor: self.cover, states: [approved, paid], limit: 366 } <= self.cover.claimLimit
   action create { requires self.cover in [active] }
   action approve {
     from: submitted, to: approved

package/std/marketplace.hsx

@@ -1,7 +1,7 @@
 header marketplace
 
 // Economics: Deposit funding, escrow credit and returns are principal. Retention is
-// earning for the company or a payout to a bound outside recipient.
+// earning for the company or passes the buyer's cash through to a bound outside recipient.
 
 // Listing, order and reservation are separate agreements. Expose their create
 // and decision actions individually. Order fulfillment does not move escrow cash.
@@ -100,7 +100,7 @@ instrument reservation(listing: ref<marketplace.listing>, funds: ref<escrow.hold
     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 economics { purpose: principal, sourceParty: programOperator }; moves self.retained from self.held to retained_to economics { recipient: retained_to, company: { purpose: earning, sourceParty: buyer }, participant: { purpose: participant_payout, sourceParty: programOperator } }
+    moves self.refund from self.held to self.buyer economics { purpose: principal, sourceParty: programOperator }; moves self.retained from self.held to retained_to economics { recipient: retained_to, company: { purpose: earning, sourceParty: buyer }, participant: { purpose: pass_through, sourceParty: programOperator } }
   }
   action seller_cancel {
     from: active, to: cancelled, actor: { party: seller }, input { reason: text }
@@ -117,7 +117,7 @@ instrument reservation(listing: ref<marketplace.listing>, funds: ref<escrow.hold
     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 economics { purpose: principal, sourceParty: programOperator }; moves self.retained from self.held to retained_to economics { recipient: retained_to, company: { purpose: earning, sourceParty: buyer }, participant: { purpose: participant_payout, sourceParty: programOperator } }
+    moves self.refund from self.held to self.buyer economics { purpose: principal, sourceParty: programOperator }; moves self.retained from self.held to retained_to economics { recipient: retained_to, company: { purpose: earning, sourceParty: buyer }, participant: { purpose: pass_through, sourceParty: programOperator } }
   }
   action expire_proposal { from: proposed, to: expired, actor: clock, due: { at: self.proposalExpiresAt } }
 }

package/std/money.hsx

@@ -1,7 +1,7 @@
 header money
 
 // Economics: Held funding and returns are principal. Release to the company realizes
-// earnings; release to another participant is a payout. Generic transfers, splits,
+// earnings; release to another participant passes the payer's cash through. Generic transfers, splits,
 // schedules, swaps, boundary payouts and metered fees retain no assumed purpose.
 
 // Expose each attachment's create and caller actions explicitly. A transfer or
@@ -48,7 +48,7 @@ instrument hold(payer: party, payee: party, amount: money = runtime) {
   }
   action release {
     from: funded, to: released, actor: { party: payer }
-    moves self.amount from self.held to payee economics { recipient: payee, company: { purpose: earning, sourceParty: payer }, participant: { purpose: participant_payout, sourceParty: programOperator } }
+    moves self.amount from self.held to payee economics { recipient: payee, company: { purpose: earning, sourceParty: payer }, participant: { purpose: pass_through, sourceParty: programOperator } }
   }
   action refund {
     from: funded, to: refunded, actor: { party: payee }
@@ -107,7 +107,7 @@ instrument pool(payer: party, payee: party, target: money, closes: date) {
   action pay {
     from: open, to: paid, actor: { party: payee }
     requires self.held.balance == self.target
-    moves self.target from self.held to payee economics { recipient: payee, company: { purpose: earning, sourceParty: payer }, participant: { purpose: participant_payout, sourceParty: programOperator } }
+    moves self.target from self.held to payee economics { recipient: payee, company: { purpose: earning, sourceParty: payer }, participant: { purpose: pass_through, sourceParty: programOperator } }
   }
   action fail {
     from: open, to: failed, actor: clock, due: { at: self.closesAt }

package/std/wallet.hsx

@@ -1,39 +1,50 @@
 header wallet
 
-// Economics: Topups and withdrawals are excluded prepaid credit. Spending remains
+// Economics: Topups and withdrawals are excluded prepaid credit; a top-up fee is
+// Company earning. Spending remains
 // unclassified because the bound payee alone does not state the purchase purpose.
 
 // Expose balance.create, activate, topup and withdraw as needed. Holder moves
 // cash only while active. Freeze blocks new topups, withdrawals and spend reserves;
-// close requires no held cash. Freeze/unfreeze use caller operation authority.
+// close requires no held cash. Only the Product operator freezes or unfreezes.
 // A separate spend record checks its amount against spendLimit at creation.
 // Expose reserve, pay and cancel for the bound payee. Reserve requires an active
 // wallet before expiresAt; pay posts the whole reservation, cancel/expiry void it.
 // Existing reservations may still post after the wallet freezes. There is no
 // daily aggregate limit, partial spend or card-network settlement in this header.
 
-// Cost: balance.create declares one owned account; topup and withdraw each
-// declare one transfer. Spend reserve, pay and cancel each declare one transfer
+// Top-up fee: topup_fee takes a floored percentage of each top-up for the Company;
+// the wallet receives the rest. At 1%, a 100.00 top-up credits 99.00 and earns 1.00.
+// The default 0% moves nothing to the Company.
+
+// Cost: balance.create declares one owned account; topup declares two transfers
+// and withdraw one. Spend reserve, pay and cancel each declare one transfer
 // instruction. These are counts, not the executor tariff.
 
-instrument balance(holder: party, spend_limit: money = 100000 SAR) {
+instrument balance(holder: party, spend_limit: money = 100000 SAR, topup_fee: percent = 0%) {
   summary: "A holder's reusable balance with an immutable per-spend ceiling."
-  fields { holder: account of holder, held: account of self, spendLimit: money = spend_limit }
+  fields { holder: account of holder, held: account of self, spendLimit: money = spend_limit, topupFee: money?, topupCredit: money? }
   lifecycle { states: [pending, active, frozen, closed], initial: pending }
   action create { }
   action activate { from: pending, to: active, actor: { party: holder } }
   action topup {
+    allowZero: true, requires input.amount > "0"
     from: active, to: active, actor: { party: holder }
     input { amount: money }
-    moves input.amount from holder to self.held economics { purpose: prepaid_credit, sourceParty: holder }
+    calculate: [
+      { target: topupFee, op: rate, base: { field: input.amount }, bps: { literal: topup_fee }, rounding: floor }
+      { target: topupCredit, op: subtract, base: { field: input.amount }, subtract: [{ field: self.topupFee }] }
+    ]
+    moves self.topupCredit from holder to self.held economics { purpose: prepaid_credit, sourceParty: holder }
+    moves self.topupFee from holder to programOperator economics { purpose: earning, sourceParty: holder }
   }
   action withdraw {
     from: active, to: active, actor: { party: holder }
     input { amount: money }
     moves input.amount from self.held to holder economics { purpose: prepaid_credit, sourceParty: programOperator }
   }
-  action freeze { from: active, to: frozen, }
-  action unfreeze { from: frozen, to: active, }
+  action freeze { from: active, to: frozen, actor: { party: programOperator } }
+  action unfreeze { from: frozen, to: active, actor: { party: programOperator } }
   action close { from: [pending, active], to: closed, requires self.held.balance == "0" }
 }