diff --git a/.github/workflows/contract-verify.yml b/.github/workflows/contract-verify.yml
index ae38191e0..f40a97640 100644
--- a/.github/workflows/contract-verify.yml
+++ b/.github/workflows/contract-verify.yml
@@ -45,6 +45,6 @@ jobs:
echo "oi-filepaths=$files2" >> "$GITHUB_OUTPUT"
- name: Contract verify action step
id: verify
- uses: Franziska-Mueller/qubic-contract-verify@main
+ uses: qubic/contract-verify@970ce102d56df53b68f1b8fa65b2dd445d5c9d81 # main
with:
filepaths: '${{ steps.filepaths.outputs.contract-filepaths }},${{ steps.filepaths.outputs.oi-filepaths }}'
diff --git a/data/bpp9000.task b/data/bpp9000.task
index 8ffa5e17a..38ce23517 100644
Binary files a/data/bpp9000.task and b/data/bpp9000.task differ
diff --git a/doc/ant_colony_mining.md b/doc/ant_colony_mining.md
index 881d65018..4a996840f 100644
--- a/doc/ant_colony_mining.md
+++ b/doc/ant_colony_mining.md
@@ -45,9 +45,10 @@ Standalone mining searches alone: every attempt starts from scratch. Ant-colony
- Every **mining identity** (a computor or candidate public key) owns its **own tree** - the colony is
a per-identity forest. A pool's workers extend the tree of the computor they mine for.
-- Each tree starts from a **virtual root**: a starting solution derived from that identity's public key
- and the epoch's spectrum digest. It is fixed for the epoch, identical every time you derive it, and
- is never stored or submitted.
+- Every tree starts from the same **virtual root**: one starting solution per epoch, derived from the
+ epoch's spectrum digest alone - identical for all identities, identical every time you derive it,
+ and never stored or submitted. All identities search from one shared origin; the trees branching
+ from it stay per-identity.
- To mine, you pick a **parent** (the root, or any node already in your tree), **inherit** it, vary it
under your nonce, and score the result.
- If the result **strictly beats the parent** and clears the epoch **threshold**, you **submit** it. On
@@ -58,7 +59,7 @@ miner starts from there instead of from scratch. The goal of the epoch is the si
found anywhere in the forest.
```
- virtual root (per identity, not stored)
+ virtual root (shared per epoch, not stored)
|
+----+----+
| |
@@ -73,20 +74,20 @@ Concretely, error gates every attachment: it only falls down a branch (a child m
and a *start* - a depth-1 child of the root - must clear the threshold.
```
- error = error count, lower is better threshold = 3838
+ error = error count, lower is better threshold = 4000
- root ~4044 raw a fresh root sits above 3838; a start must mutate below it
+ root ~4200 raw the epoch root (same for everyone) sits above 4000; a start must mutate below it
|
- +-- A 3790 <= threshold ACCEPT (depth-1 start)
+ +-- A 3900 <= threshold ACCEPT (depth-1 start)
| |
- | +-- B 3540 < 3790, beats A ACCEPT
+ | +-- B 3540 < 3900, beats A ACCEPT
| | |
| | +-- D 3120 < 3540, beats B ACCEPT
| | +-- E 3560 not < 3540 REJECT (must beat parent)
| |
- | +-- C 3700 < 3790, beats A ACCEPT
+ | +-- C 3700 < 3900, beats A ACCEPT
|
- +-- X 3900 > threshold REJECT (over threshold)
+ +-- X 4100 > threshold REJECT (over threshold)
Error only falls as you go deeper. The epoch winner is the single lowest-error node
found in any identity's forest.
@@ -96,7 +97,7 @@ At epoch end the node ranks every identity by its **single best** score and **ha
(the number of computors).
**Anti-spam deposit.** Each solution a computor publishes on-chain carries a **refundable
-1,000,000 QU deposit**, funded by the computor - not the worker. It is returned when the solution is
+1000000 QU deposit**, funded by the computor - not the worker. It is returned when the solution is
accepted **and** its claimed score matches the node's recompute; otherwise it is kept. So a computor
only publishes solutions it has already validated, and an honest, correct one costs nothing.
@@ -105,7 +106,7 @@ only publishes solutions it has already validated, and an honest, correct one co
## Part 2 - Miner / pool integration guide
**In short.** A miner works one identity's tree. It reads the epoch context, takes a **parent** (the
-identity's virtual root, or a node already in the tree), picks a canonical **nonce**, inherits the
+epoch's shared virtual root, or a node already in the tree), picks a canonical **nonce**, inherits the
parent's network, and **mutates and scores** it - reproducing the node's score exactly. If the result
**beats its parent** and **clears the threshold**, it hands the solution to the **computor**, which
re-checks it and **publishes it on-chain**; every node then recomputes the score, folds it into
@@ -117,8 +118,8 @@ scorer** - the tree, gates, deposit, and queries are the wrapper around it.
1. **Epoch context** - `REQUEST_ANT_EPOCH_CONTEXT` (public). Read the threshold, freshness window,
epoch spectrum digest, and child cap for this epoch, and **verify your task file** against the
returned `topologyHash` / `dataHash` (section 2.7a) before doing any work.
-2. **Get a starting point** - derive your identity's virtual root, or fetch an existing node you want
- to extend (`REQUEST_ANT_PARENT_ANN`).
+2. **Get a starting point** - derive the epoch's shared virtual root (from the spectrum digest), or
+ fetch an existing node you want to extend (`REQUEST_ANT_PARENT_ANN`).
3. **Pick a parent** - the root, or any node in your own tree.
4. **Search** - choose a nonce (section 2.2), inherit the parent LUT, run the mutation walk, score
(section 2.3).
@@ -153,17 +154,20 @@ knobs are not two solutions.
### 2.3 Scoring - bpp9000 (must be bit-exact)
Throughout, `publicKey` is the **mining identity you are extending** - the computor you mine for, which
-becomes the transaction's `sourcePublicKey`. Derive the root and the mutation seed from **that** key,
-not your worker key, or the node's recompute will not match yours.
+becomes the transaction's `sourcePublicKey`. The **mutation seed** derives from **that** key, not your
+worker key, or the node's recompute will not match yours. The **root** derives from no key at all -
+see below.
-**Root.** `deriveRootANN(publicKey, epochPool)`: `K12(publicKey)` seeds a per-neuron LUT from the
-epoch's random pool (the pool comes from the epoch-start spectrum digest). No mutation walk. Never
-stored. The same every time for the epoch.
+**Root.** `deriveRootANN(spectrumDigest, epochPool)`: `K12(spectrumDigest)` - the epoch-start
+spectrum digest from the epoch context - seeds a per-neuron LUT from the epoch's random pool (the
+pool itself also comes from that digest). No mutation walk. Never stored. **One root per epoch,
+identical for every identity**; per-identity variation enters only through the mutation seeds.
**Child.** `computeScoreFromParent(parentLUT, publicKey, nonce, anchorTickDigest)`:
1. Inherit `parentLUT`.
-2. `mutationSeed = K12(publicKey || nonce[3..31] || anchorTickDigest)` (`nonce[0..2]` zeroed).
+2. `mutationSeed = K12(publicKey || nonce[3..31] || anchorTickDigest)` (`nonce[0..2]` zeroed) -
+ still keyed by the mining identity, so different identities walk differently from the shared root.
3. Walk `numberOfMutations = 100` steps. Each step rewrites `L` LUT entries. For the first `K` steps
accept a worse-or-equal result (**explore**); after that accept only better-or-equal (**exploit**);
one-step rollback on reject. Keep and return the **best** score seen. The best is seeded with the
@@ -201,14 +205,15 @@ recorded but the **deposit is kept** and the miner is **not ranked**.
**Starting a tree.** The root's record score is the worst possible value, so a first (depth-1) child
passes the "beats parent" check trivially - the **threshold is the only score gate** for starting a
-tree. A random root scores far above the threshold, so a start still requires real mutation.
+tree. The shared epoch root scores far above the threshold, so a start still requires real mutation -
+and every identity starts from the same score, so ranking differences reflect search effort only.
**`ValidNotStored`.** Accepted, refunded, and ranked exactly like `Valid`, but the per-epoch store was
full so the node was not persisted for others to extend. Ranking and refund are unaffected.
### 2.5 The deposit
-Every on-chain `AntColonyMiningSolutionTransaction` carries a **1,000,000 QU** deposit
+Every on-chain `AntColonyMiningSolutionTransaction` carries a **1000000 QU** deposit
(`SOLUTION_SECURITY_DEPOSIT`), funded by the **computor** that publishes it - not the miner (see 2.6).
It is refunded **iff** the solution is accepted (`Valid` / `ValidNotStored`) **and** the claimed score
equals the node's recompute; otherwise it is kept. So a computor risks its own deposit and therefore
@@ -254,7 +259,7 @@ AntColonyMiningSolutionTransaction : Transaction { // 80-byte header + 48-byte
// --- Transaction header ---
m256i sourcePublicKey; // the COMPUTOR (tree owner); signs the tx and funds the deposit
m256i destinationPublicKey; // zero (NULL_ID)
- long long amount; // SOLUTION_SECURITY_DEPOSIT = 1,000,000 QU
+ long long amount; // SOLUTION_SECURITY_DEPOSIT = 1000000 QU
unsigned int tick; // publish tick
unsigned short inputType; // ANT_COLONY_MINING_SOLUTION_INPUT_TYPE = 12
unsigned short inputSize; // 48
@@ -301,7 +306,7 @@ signature = sign(operatorSubseed, operatorPublicKey, digest) // 64 bytes, appe
Request: empty. Response `RespondAntEpochContext` (120 bytes, packed):
```
-m256i spectrumDigest; // epoch-start spectrum digest (seeds every root)
+m256i spectrumDigest; // epoch-start spectrum digest; IS the root seed (and seeds the pool)
m256i topologyHash; // canonical task topology-block hash (BPP9000_TOPOLOGY_HASH)
m256i dataHash; // canonical task data-block hash (BPP9000_DATA_HASH)
unsigned int threshold; // per-epoch accept bound
@@ -364,7 +369,7 @@ byte, the exact form the scorer consumes - no unpacking needed):
unsigned int parentRefTick;
unsigned int parentRefSolutionIndexInTick;
unsigned int annSizeBytes; // ANN LUT size when status is OK, else 0
-unsigned char status; // 0 = OK, 1 = NOT_FOUND, 2 = IS_ROOT (derive your own root instead)
+unsigned char status; // 0 = OK, 1 = NOT_FOUND, 2 = IS_ROOT (derive the epoch root instead)
unsigned char padding[3];
```
diff --git a/doc/contracts.md b/doc/contracts.md
index c7f054802..1ba55265d 100644
--- a/doc/contracts.md
+++ b/doc/contracts.md
@@ -105,7 +105,7 @@ In order to develop a contract, follow these steps:
## Review and tests
Each contract must be validated with the following steps:
-1. The contract is verified with the [Qubic Contract Verification Tool](https://github.com/Franziska-Mueller/qubic-contract-verify), ensuring that it complies with the formal requirements mentioned above, such as no use of [forbidden C++ features](#restrictions-of-c-language-features).
+1. The contract is verified with the [Qubic Contract Verification Tool](https://github.com/qubic/contract-verify), ensuring that it complies with the formal requirements mentioned above, such as no use of [forbidden C++ features](#restrictions-of-c-language-features).
In the `qubic/core` repository, the tool is run automatically as GitHub workflow for PRs to the `develop` and `main` branches (as well as for commits in these branches).
However, since workflow runs on PRs require maintainer approval, we highly recommend to either build the tool from source or use the GitHub action provided in the tool's repository to analyze your contract header file before opening your PR.
2. The features of the contract have to be extensively tested with automated tests implemented within the Qubic Core's GoogleTest framework.
diff --git a/doc/contracts_oracles.md b/doc/contracts_oracles.md
index e16ed1bed..76dfe8080 100644
--- a/doc/contracts_oracles.md
+++ b/doc/contracts_oracles.md
@@ -194,7 +194,7 @@ static sint64 getSubscriptionFee(const OracleQuery& query, uint32 notifyPeriodIn
Additionally, the interface struct may contain other structs or convenience features for contracts using the oracle interface.
All code in the interface header file must respect the same [C++ language feature restrictions as contracts](#restrictions-of-c-language-features) (except for a few differences listed below).
-These are checked with the [Qubic Contract Verification Tool](https://github.com/Franziska-Mueller/qubic-contract-verify).
+These are checked with the [Qubic Contract Verification Tool](https://github.com/qubic/contract-verify).
The C++ language feature restrictions of oracle interfaces differ in the following points from those of contracts:
diff --git a/src/Qubic.vcxproj b/src/Qubic.vcxproj
index cce92d29a..04add7298 100644
--- a/src/Qubic.vcxproj
+++ b/src/Qubic.vcxproj
@@ -26,7 +26,6 @@
-
@@ -44,7 +43,6 @@
-
diff --git a/src/Qubic.vcxproj.filters b/src/Qubic.vcxproj.filters
index 32882eaf4..10cc5247b 100644
--- a/src/Qubic.vcxproj.filters
+++ b/src/Qubic.vcxproj.filters
@@ -126,9 +126,6 @@
contracts
-
- contracts
-
contracts
@@ -245,9 +242,6 @@
contracts
-
- contracts
-
platform
diff --git a/src/contract_core/contract_def.h b/src/contract_core/contract_def.h
index 6e292e289..300adc1a4 100644
--- a/src/contract_core/contract_def.h
+++ b/src/contract_core/contract_def.h
@@ -145,11 +145,7 @@
#define CONTRACT_INDEX QSWAP_CONTRACT_INDEX
#define CONTRACT_STATE_TYPE QSWAP
#define CONTRACT_STATE2_TYPE QSWAP2
-#ifdef OLD_QSWAP
-#include "contracts/Qswap_old.h"
-#else
#include "contracts/Qswap.h"
-#endif
#undef CONTRACT_INDEX
#undef CONTRACT_STATE_TYPE
@@ -209,11 +205,7 @@
#define CONTRACT_INDEX QRAFFLE_CONTRACT_INDEX
#define CONTRACT_STATE_TYPE QRAFFLE
#define CONTRACT_STATE2_TYPE QRAFFLE2
-#ifdef OLD_QRAFFLE
-#include "contracts/QRaffle_old.h"
-#else
#include "contracts/QRaffle.h"
-#endif
#undef CONTRACT_INDEX
#undef CONTRACT_STATE_TYPE
@@ -584,7 +576,7 @@ struct ContractStateChangeInfo
// When enabling, replace both lines below, e.g.:
//constexpr ContractStateChangeInfo contractStateChangeInfos[] = { { DUMMY_CONTRACT_INDEX, MIGRATE, 219 } };
//constexpr unsigned int contractStateChangeCount = sizeof(contractStateChangeInfos) / sizeof(contractStateChangeInfos[0]);
-constexpr ContractStateChangeInfo contractStateChangeInfos[] = { { QIP_CONTRACT_INDEX, RESET, 224 }, { RANDOM_CONTRACT_INDEX, PADDING, 224 } };
+constexpr ContractStateChangeInfo contractStateChangeInfos[] = { { QIP_CONTRACT_INDEX, RESET, 224 }, { RANDOM_CONTRACT_INDEX, PADDING, 224 }, {NOST_CONTRACT_INDEX, MIGRATE, 229}};
constexpr unsigned int contractStateChangeCount = sizeof(contractStateChangeInfos) / sizeof(contractStateChangeInfos[0]);
diff --git a/src/contracts/Nostromo.h b/src/contracts/Nostromo.h
index 1e50441e1..e3e34c840 100644
--- a/src/contracts/Nostromo.h
+++ b/src/contracts/Nostromo.h
@@ -1,29 +1,146 @@
using namespace QPI;
-constexpr uint64 NOSTROMO_TIER_FACEHUGGER_STAKE_AMOUNT = 20000000ULL;
-constexpr uint64 NOSTROMO_TIER_CHESTBURST_STAKE_AMOUNT = 100000000ULL;
-constexpr uint64 NOSTROMO_TIER_DOG_STAKE_AMOUNT = 200000000ULL;
-constexpr uint64 NOSTROMO_TIER_XENOMORPH_STAKE_AMOUNT = 800000000ULL;
-constexpr uint64 NOSTROMO_TIER_WARRIOR_STAKE_AMOUNT = 3200000000ULL;
-constexpr uint64 NOSTROMO_QX_TOKEN_ISSUANCE_FEE = 1000000000ULL;
-
-constexpr uint32 NOSTROMO_TIER_FACEHUGGER_POOL_WEIGHT = 55;
-constexpr uint32 NOSTROMO_TIER_CHESTBURST_POOL_WEIGHT = 300;
-constexpr uint32 NOSTROMO_TIER_DOG_POOL_WEIGHT = 750;
-constexpr uint32 NOSTROMO_TIER_XENOMORPH_POOL_WEIGHT = 3050;
-constexpr uint32 NOSTROMO_TIER_WARRIOR_POOL_WEIGHT = 13750;
-
-constexpr uint32 NOSTROMO_TIER_FACEHUGGER_UNSTAKE_FEE = 5;
-constexpr uint32 NOSTROMO_TIER_CHESTBURST_UNSTAKE_FEE = 4;
-constexpr uint32 NOSTROMO_TIER_DOG_UNSTAKE_FEE = 3;
-constexpr uint32 NOSTROMO_TIER_XENOMORPH_UNSTAKE_FEE = 2;
-constexpr uint32 NOSTROMO_TIER_WARRIOR_UNSTAKE_FEE = 1;
-constexpr uint32 NOSTROMO_CREATE_PROJECT_FEE = 100000000;
-
-constexpr uint32 NOSTROMO_MAX_USER = 262144;
-constexpr uint32 NOSTROMO_MAX_NUMBER_PROJECT = 262144;
-constexpr uint32 NOSTROMO_MAX_NUMBER_TOKEN = 262144;
-constexpr uint32 NOSTROMO_MAX_NUMBER_OF_PROJECT_USER_INVEST = 128;
+namespace QPI
+{
+ inline bool operator==(const Asset& lhs, const Asset& rhs)
+ {
+ return lhs.assetName == rhs.assetName && lhs.issuer == rhs.issuer;
+ }
+} // namespace QPI
+
+// Maximum number of active auction records stored by the contract, in auctions.
+constexpr uint64 NOST_AUCTION_NUM = 2048;
+// Number of full closed-auction snapshots retained in the history ring buffer, in entries.
+constexpr uint64 NOST_AUCTION_HISTORY_NUM = 1024;
+// Fixed length of an auction metadata IPFS CID, in bytes.
+constexpr uint64 NOST_AUCTION_METADATA_CID_LENGTH = 64;
+// Maximum number of active auction-participant bid records, in entries.
+constexpr uint64 NOST_AUCTION_PARTICIPANT_NUM = 4096;
+// Maximum number of wallets with unpaid QU obligations retained by the contract.
+constexpr uint64 NOST_PENDING_PAYOUT_NUM = 8192;
+// Maximum pending-payout slots one auction settlement may require before END_EPOCH fee distribution.
+constexpr uint64 NOST_AUCTION_REVENUE_MAX_PAYOUT_RECIPIENTS = 1;
+// Additional pending-payout slot reserved for the Batch bid caller's possible overpayment refund.
+constexpr uint64 NOST_BATCH_BID_CALLER_PAYOUT_RECIPIENTS = 1;
+// Maximum pending-payout slots reserved by a Standard bid for refunds and an immediate Buy Now settlement.
+constexpr uint64 NOST_STANDARD_BID_MAX_PAYOUT_RECIPIENTS = 6;
+// Maximum pending-payout slots reserved by Standard settlement for revenue distribution and bidder handling.
+constexpr uint64 NOST_STANDARD_FINALIZATION_MAX_PAYOUT_RECIPIENTS = 5;
+// Number of QPI-sized QU transfer chunks attempted for an immediate refund or settlement payout.
+constexpr uint64 NOST_IMMEDIATE_QU_TRANSFER_CHUNKS_PER_CALL = 1;
+// Maximum number of pending-payout wallets retried automatically during one END_EPOCH call.
+constexpr uint64 NOST_END_EPOCH_PAYOUT_RECIPIENT_NUM = 64;
+// Number of QPI-sized QU transfer chunks retried per pending-payout wallet at END_EPOCH.
+constexpr uint64 NOST_END_EPOCH_PAYOUT_CHUNKS_PER_RECIPIENT = 1;
+// Maximum number of QPI-sized QU transfers attempted for one wallet in one procedure call.
+constexpr uint64 NOST_MAX_QU_TRANSFER_CHUNKS_PER_CALL = 16;
+// Sentinel for "no participant slot".
+constexpr uint64 NOST_INVALID_PARTICIPANT_SLOT = NOST_AUCTION_PARTICIPANT_NUM;
+// Maximum number of entries returned by one paginated auction getter call.
+constexpr uint64 NOST_AUCTION_GETTER_PAGE_SIZE = 64;
+// Maximum number of asset entries in a Batch Auction lot.
+constexpr uint64 NOST_BATCH_AUCTION_LOT_ITEM_NUM = 1;
+// Integer offset that makes the Batch coverage threshold include the first quantity below the minimum allocation.
+constexpr uint64 NOST_BATCH_COVERAGE_THRESHOLD_OFFSET = 1;
+// Maximum number of asset entries in a Standard Auction lot.
+constexpr uint64 NOST_AUCTION_LOT_ITEM_NUM = 4;
+// Maximum number of bidder wallets allowed by a private auction wallet gate.
+constexpr uint64 NOST_AUCTION_ALLOWED_WALLET_NUM = 16;
+// Maximum number of alternative assets accepted by a private auction asset gate.
+constexpr uint64 NOST_AUCTION_REQUIRED_ACCESS_ASSET_NUM = 4;
+// Maximum configured duration of any auction, in days.
+constexpr uint32 NOST_AUCTION_MAX_DURATION_DAYS = 30;
+// Default fee charged to create a private auction, in qu.
+constexpr sint64 NOST_DEFAULT_PRIVATE_AUCTION_FEE = 50000000LL;
+// Default fee accumulated after successfully creating a public auction and distributed at END_EPOCH, in qu.
+constexpr sint64 NOST_PUBLIC_AUCTION_CREATION_FEE = 100LL;
+// Minimum total payment target for small accepted Batch Auction bids, in qu.
+constexpr uint64 NOST_BATCH_BID_FEE_CUTOFF = 100ULL;
+// Default fee deducted when an auction is cancelled, in basis points.
+constexpr uint64 NOST_DEFAULT_AUCTION_CANCELLATION_FEE_BP = 1000ULL;
+// Default management fee applied to gross auction proceeds, in basis points.
+constexpr uint64 NOST_DEFAULT_AUCTION_MANAGEMENT_FEE_BP = 50ULL;
+// Default development fee applied to gross auction proceeds, in basis points.
+constexpr uint64 NOST_DEFAULT_AUCTION_DEVELOPMENT_FEE_BP = 50ULL;
+// Default takeover coordinator fee applied to gross auction proceeds, in basis points.
+constexpr uint64 NOST_DEFAULT_AUCTION_TAKEOVER_COORDINATOR_FEE_BP = 50ULL;
+// Shareholder allocation of auction creation, small-bid, and cancellation service fees, in basis points.
+constexpr uint64 NOST_AUCTION_SERVICE_FEE_SHAREHOLDER_BP = 7270ULL;
+// Management allocation of auction creation, small-bid, and cancellation service fees, in basis points.
+constexpr uint64 NOST_AUCTION_SERVICE_FEE_MANAGEMENT_BP = 910ULL;
+// Development allocation of auction creation, small-bid, and cancellation service fees, in basis points.
+constexpr uint64 NOST_AUCTION_SERVICE_FEE_DEVELOPMENT_BP = 910ULL;
+// Takeover coordinator allocation of auction creation, small-bid, and cancellation service fees, in basis points.
+constexpr uint64 NOST_AUCTION_SERVICE_FEE_TAKEOVER_COORDINATOR_BP = 910ULL;
+// Default portion of the shareholder fee distributed as dividends, in basis points.
+constexpr uint64 NOST_DEFAULT_AUCTION_SHAREHOLDER_DIVIDEND_BP = 9000ULL;
+// Default shareholder fee for gross proceeds in tier 1, in basis points.
+constexpr uint64 NOST_DEFAULT_AUCTION_SHAREHOLDER_FEE_BP_TIER_1 = 500ULL;
+// Default shareholder fee for gross proceeds in tier 2, in basis points.
+constexpr uint64 NOST_DEFAULT_AUCTION_SHAREHOLDER_FEE_BP_TIER_2 = 450ULL;
+// Default shareholder fee for gross proceeds in tier 3, in basis points.
+constexpr uint64 NOST_DEFAULT_AUCTION_SHAREHOLDER_FEE_BP_TIER_3 = 400ULL;
+// Default shareholder fee for gross proceeds in tier 4, in basis points.
+constexpr uint64 NOST_DEFAULT_AUCTION_SHAREHOLDER_FEE_BP_TIER_4 = 350ULL;
+// Inclusive upper gross-proceeds threshold for shareholder fee tier 1, in qu.
+constexpr uint64 NOST_AUCTION_SHAREHOLDER_FEE_THRESHOLD_TIER_1 = 5000000000ULL;
+// Inclusive upper gross-proceeds threshold for shareholder fee tier 2, in qu.
+constexpr uint64 NOST_AUCTION_SHAREHOLDER_FEE_THRESHOLD_TIER_2 = 50000000000ULL;
+// Inclusive upper gross-proceeds threshold for shareholder fee tier 3, in qu.
+constexpr uint64 NOST_AUCTION_SHAREHOLDER_FEE_THRESHOLD_TIER_3 = 200000000000ULL;
+// Time added when an accepted bid arrives near an auction deadline, in seconds.
+constexpr uint64 NOST_AUCTION_EXTENSION_SECONDS = 300ULL;
+// Number of seconds used to convert one auction duration day.
+constexpr uint64 NOST_SECONDS_PER_DAY = 86400ULL;
+// Time allowed for a Standard Auction seller to resolve a pending sale, in seconds.
+constexpr uint64 NOST_AUCTION_SELLER_DECISION_WINDOW_SECONDS = 604800ULL;
+// Duration of the scheduled auction pause before an epoch transition, in seconds.
+constexpr uint64 NOST_AUCTION_PRE_EPOCH_PAUSE_SECONDS = 1800ULL;
+// Duration of the auction launch pause after `BEGIN_EPOCH`, in ticks.
+constexpr uint32 NOST_AUCTION_POST_BEGIN_EPOCH_PAUSE_TICKS = 500U;
+// Denominator representing 100 percent in basis-point calculations.
+constexpr uint64 NOST_BASIS_POINTS_SCALE = 10000ULL;
+// Number of microseconds used to convert a timestamp duration to seconds.
+constexpr uint64 NOST_MICROSECONDS_PER_SECOND = 1000000ULL;
+// Epoch at which the contract reapplies its default configuration, in epochs.
+constexpr uint16 NOST_REINITIALIZATION_EPOCH = 220U;
+// Quantity used to sell a Standard Auction lot as one indivisible unit, not an asset count.
+constexpr uint64 NOST_STANDARD_AUCTION_LOT_COUNT = 1ULL;
+// Minimum allowed Standard Auction starting and sale price, in qu.
+constexpr uint64 NOST_STANDARD_MIN_PRICE = 1000000ULL;
+// Minimum allowed Standard Auction bid increment, in qu.
+constexpr uint64 NOST_STANDARD_MIN_BID_INCREMENT = 1000ULL;
+// Year component of the packed initial date stamp.
+constexpr uint8 NOST_DEFAULT_INIT_YEAR = 22U;
+// Month component of the packed initial date stamp.
+constexpr uint8 NOST_DEFAULT_INIT_MONTH = 4U;
+// Day component of the packed initial date stamp.
+constexpr uint8 NOST_DEFAULT_INIT_DAY = 13U;
+// Bit offset of the year component in a packed date stamp, in bits.
+constexpr uint8 NOST_DATE_STAMP_YEAR_SHIFT = 9U;
+// Bit offset of the month component in a packed date stamp, in bits.
+constexpr uint8 NOST_DATE_STAMP_MONTH_SHIFT = 5U;
+// Runtime day-of-week index on which the scheduled pre-epoch pause begins.
+constexpr uint8 NOST_PRE_EPOCH_PAUSE_DAY_OF_WEEK = 0U;
+// UTC hour at which the scheduled pre-epoch pause begins.
+constexpr uint8 NOST_PRE_EPOCH_PAUSE_HOUR = 11U;
+// Minute within the configured hour at which the scheduled pre-epoch pause begins.
+constexpr uint8 NOST_PRE_EPOCH_PAUSE_MINUTE = 30U;
+// Packed date stamp used to recognize the contract's initial runtime date.
+constexpr uint32 NOST_DEFAULT_INIT_TIME =
+ NOST_DEFAULT_INIT_YEAR << NOST_DATE_STAMP_YEAR_SHIFT | NOST_DEFAULT_INIT_MONTH << NOST_DATE_STAMP_MONTH_SHIFT | NOST_DEFAULT_INIT_DAY;
+// Default enabled flag that routes all collected auction fees to development.
+constexpr uint8 NOST_ROUTE_ALL_FEES_TO_DEVELOPMENT = 1;
+// Default drop in the execution fee reserve that triggers an emergency pause, in basis points.
+constexpr uint64 NOST_DEFAULT_FEE_RESERVE_GUARD_DROP_BP = 1000ULL;
+// Default rolling window used to evaluate the execution fee reserve drop, in seconds.
+constexpr uint64 NOST_DEFAULT_FEE_RESERVE_GUARD_WINDOW_SECONDS = 600ULL;
+
+/** Old */
+constexpr uint32 NOSTROMO_MAX_USER_OLD = 262144;
+constexpr uint32 NOSTROMO_MAX_NUMBER_OF_PROJECT_USER_INVEST_OLD = 128;
+constexpr uint32 NOSTROMO_MAX_NUMBER_TOKEN_OLD = 262144;
+constexpr uint32 NOSTROMO_MAX_NUMBER_PROJECT_OLD = 262144;
struct NOST2
{
@@ -31,185 +148,324 @@ struct NOST2
struct NOST : public ContractBase
{
-public:
- /****** PORTED TIMEUTILS FROM OLD Nostromo *****/
- /**
- * Compare 2 date in uint32 format
- * @return -1 lesser(ealier) AB
- */
- inline static sint32 dateCompare(uint32& A, uint32& B, sint32& i)
+ enum class EProcedureId : uint8
{
- if (A == B) return 0;
- if (A < B) return -1;
- return 1;
- }
+ CreateAuction = 1,
+ PlaceBid = 2,
+ CancelAuction = 3,
+ TransferShareManagementRights = 4,
+ ResolvePendingStandardAuction = 5,
+ SetAuctionFees = 6,
+ SetAuctionFeesByManagement = 7,
+ SetManagement = 8,
+ SetFeeReserveGuardConfig = 9,
+ SetEmergencyPause = 10
+ };
- /**
- * @return pack Nost datetime data from year, month, day, hour, minute, second to a uint32
- * year is counted from 24 (2024)
- */
- inline static void packNostromoDate(uint32 _year, uint32 _month, uint32 _day, uint32 _hour, uint32 _minute, uint32 _second, uint32& res)
+ /** @brief Stable public-function identifiers used by the contract ABI. */
+ enum class EFunctionId : uint16
{
- res = ((_year - 24) << 26) | (_month << 22) | (_day << 17) | (_hour << 12) | (_minute << 6) | (_second);
- }
+ GetAuctionByIndex = 1,
+ GetAuctionParticipant = 2,
+ GetTicksBeforeAuctionLaunch = 3,
+ GetAuctionFees = 4,
+ GetFeeRecipients = 5,
+ GetClosedAuctionHistory = 6,
+ GetRouteAllFeesToDevelopment = 7,
+ GetContractStats = 8,
+ GetAuctionSummaries = 9,
+ GetActiveAuctionIndices = 10,
+ GetAuctionsBySeller = 11,
+ GetAuctionByMetadataCid = 12,
+ GetAuctionSummariesByIndexBatch = 13,
+ GetAuctionParticipants = 14,
+ GetUserParticipations = 15,
+ GetLatestAuctionIndex = 16,
+ GetAuctionCountBySeller = 17,
+ GetAuctionAtCreationSnapshot = 18,
+ GetBatchAuctionBidAvailability = 19,
+ CalculateBatchAuctionBidFee = 20,
+ GetPendingServiceFeePool = 21,
+ GetFeeReserveGuardState = 22,
+ GetPendingPayout = 23,
+ GetNostromoFeePool = 24
+ };
- inline static uint32 NostGetYear(uint32 data)
- {
- return ((data >> 26) + 24);
- }
- inline static uint32 NostGetMonth(uint32 data)
- {
- return ((data >> 22) & 0b1111);
- }
- inline static uint32 NostGetDay(uint32 data)
- {
- return ((data >> 17) & 0b11111);
- }
- inline static uint32 NostGetHour(uint32 data)
- {
- return ((data >> 12) & 0b11111);
- }
- inline static uint32 NostGetMinute(uint32 data)
+ enum class EAuctionType : uint8
{
- return ((data >> 6) & 0b111111);
- }
- inline static uint32 NostGetSecond(uint32 data)
+ None,
+ Batch,
+ Standard
+ };
+
+ enum class EAuctionVisibility : uint8
{
- return (data & 0b111111);
- }
- /*
- * @return unpack Nost datetime from uin32 to year, month, day, hour, minute, secon
- */
- inline static void unpackNostromoDate(uint8& _year, uint8& _month, uint8& _day, uint8& _hour, uint8& _minute, uint8& _second, uint32 data)
+ None,
+ Public,
+ Private
+ };
+
+ enum class EAuctionStatus : uint8
{
- _year = NostGetYear(data); // 6 bits
- _month = NostGetMonth(data); //4bits
- _day = NostGetDay(data); //5bits
- _hour = NostGetHour(data); //5bits
- _minute = NostGetMinute(data); //6bits
- _second = NostGetSecond(data); //6bits
- }
+ None,
+ Active,
+ Finalized,
+ Cancelled,
+ PendingSellerDecision
+ };
- inline static void accumulatedDay(sint32 month, uint64& res)
+ enum class EAuctionError : uint8
{
- switch (month)
- {
- case 1: res = 0; break;
- case 2: res = 31; break;
- case 3: res = 59; break;
- case 4: res = 90; break;
- case 5: res = 120; break;
- case 6: res = 151; break;
- case 7: res = 181; break;
- case 8: res = 212; break;
- case 9: res = 243; break;
- case 10:res = 273; break;
- case 11:res = 304; break;
- case 12:res = 334; break;
- }
- }
+ Success,
+ InvalidInput,
+ AuctionNotFound,
+ AuctionClosed,
+ Forbidden,
+ InsufficientFunds,
+ InsufficientAssetBalance,
+ StorageFull,
+ InvalidAuctionType,
+ InvalidVisibility,
+ BidTooLow,
+ PrivateAuctionAccessDenied,
+ AuctionPaused,
+ AuctionIndexExhausted,
+ QuantityUnavailable,
+ AuctionHasAcceptedBid,
+ PayoutQueueFull
+ };
+
/**
- * @return difference in number of second, A must be smaller than or equal B to have valid value
+ * @brief Stores one bid slot in one auction.
+ * @note The same struct is shared by batch and standard auctions.
*/
- inline static void diffDateInSecond(uint32& A, uint32& B, sint32& i, uint64& dayA, uint64& dayB, uint64& res)
+ struct AuctionParticipantData
{
- if (dateCompare(A, B, i) >= 0)
- {
- res = 0;
- return;
- }
- accumulatedDay(NostGetMonth(A), dayA);
- dayA += NostGetDay(A);
- accumulatedDay(NostGetMonth(B), dayB);
- dayB += (NostGetYear(B) - NostGetYear(A)) * 365ULL + NostGetDay(B);
+ /** @brief Auction that owns this bid slot. */
+ uint64 auctionIndex;
- // handling leap-year: only store last 2 digits of year here, don't care about mod 100 & mod 400 case
- for (i = NostGetYear(A); (uint32)(i) < NostGetYear(B); i++)
- {
- if (mod(i, 4) == 0)
- {
- dayB++;
- }
- }
- if (mod(sint32(NostGetYear(A)), 4) == 0 && (NostGetMonth(A) > 2)) dayA++;
- if (mod(sint32(NostGetYear(B)), 4) == 0 && (NostGetMonth(B) > 2)) dayB++;
- res = (dayB - dayA) * 3600ULL * 24;
- res += (NostGetHour(B) * 3600 + NostGetMinute(B) * 60 + NostGetSecond(B));
- res -= (NostGetHour(A) * 3600 + NostGetMinute(A) * 60 + NostGetSecond(A));
- }
+ /** @brief Monotonic bid sequence inside the auction, used for FIFO tie-breaks. */
+ uint64 bidIndex;
- inline static bool checkValidNostDateTime(uint32& A)
- {
- if (NostGetMonth(A) > 12) return false;
- if (NostGetDay(A) > 31) return false;
- if ((NostGetDay(A) == 31) &&
- (NostGetMonth(A) != 1) && (NostGetMonth(A) != 3) && (NostGetMonth(A) != 5) &&
- (NostGetMonth(A) != 7) && (NostGetMonth(A) != 8) && (NostGetMonth(A) != 10) && (NostGetMonth(A) != 12)) return false;
- if ((NostGetDay(A) == 30) && (NostGetMonth(A) == 2)) return false;
- if ((NostGetDay(A) == 29) && (NostGetMonth(A) == 2) && (mod(NostGetYear(A), 4u) != 0)) return false;
- if (NostGetHour(A) >= 24) return false;
- if (NostGetMinute(A) >= 60) return false;
- if (NostGetSecond(A) >= 60) return false;
- return true;
- }
+ /** @brief Amount currently locked in escrow for the participant bid. */
+ uint64 escrowedAmount;
+
+ /** @brief Quantity requested by the participant; standard auctions always use the whole lot quantity. */
+ uint64 requestedQuantity;
+
+ /** @brief Quantity finally allocated to the participant after batch auction settlement. */
+ uint64 allocatedQuantity;
+
+ /** @brief Offered price per asset in a batch auction, or total offered price for the whole lot in a standard auction. */
+ uint64 bidAmount;
+
+ /** @brief Wallet that owns this participant record. */
+ id participant;
- /****** END PORTED TIMEUTILS FROM OLD Nostromo *****/
+ /** @brief Timestamp of the participant's latest accepted bid. */
+ DateAndTime lastBidTime;
- struct investInfo
+ /** @brief Marks whether this fixed array slot contains a reusable historical or active record. */
+ uint8 isUsed;
+
+ /** @brief Marks bids that are still eligible for allocation or standard highest-bid settlement. */
+ uint8 isActive;
+
+ /** @brief Marks bids that remain inside the winning allocation after settlement. */
+ uint8 isWinningBid;
+ };
+
+ /**
+ * @brief Describes an asset and quantity used by an auction lot or private access rule.
+ */
+ struct AuctionAssetEntry
{
- uint64 investedAmount;
- uint64 claimedAmount;
- uint32 indexOfFundraising;
+ /** @brief Asset included in a lot or used as an access requirement. */
+ Asset asset;
+
+ /** @brief Lot quantity or minimum ownership quantity required for access. */
+ sint64 quantity;
};
- struct projectInfo
+ /**
+ * @brief Shared auction fields used by persistent state and public getter views.
+ * @note Container fields differ between persistent state and ABI views, so access-control collections stay outside this struct.
+ * @note `metadataIpfsCid` points to off-chain auction metadata stored in IPFS.
+ * @note `sellerDecisionDeadline` stays zero until a standard auction enters the manual decision window.
+ */
+ struct AuctionCore
{
- id creator;
- uint64 tokenName;
- uint64 supplyOfToken;
- uint32 startDate;
- uint32 endDate;
- uint32 numberOfYes;
- uint32 numberOfNo;
- bit isCreatedFundarasing;
+ /** @brief Assets and quantities offered by the auction. */
+ Array auctionLotItems;
+
+ /** @brief Lowercase base32 CIDv1 stored in Pinata for the auction name and description metadata. */
+ Array metadataIpfsCid;
+
+ /** @brief Wallet that created the auction and offers the lot for sale. */
+ id seller;
+
+ /** @brief Wallet that currently holds the highest bid. */
+ id highestBidder;
+
+ /** @brief Timestamp when the seller created the auction. */
+ DateAndTime createdAt;
+
+ /** @brief Timestamp of the most recent accepted bid. */
+ DateAndTime lastBidAt;
+
+ /** @brief Deadline for the seller to accept or reject a standard auction bid that ended between Initial Price and Sale Price. */
+ DateAndTime sellerDecisionDeadline;
+
+ /** @brief Timestamp when the auction was finalized, cancelled, or otherwise settled. */
+ DateAndTime settledAt;
+
+ /** @brief Total sale units offered; batch auctions use asset quantity, standard auctions use one unit for the whole lot. */
+ uint64 quantityForSale;
+
+ /** @brief Quantity already assigned to winning bids after settlement. */
+ uint64 allocatedQuantity;
+
+ /** @brief Minimum quantity requested by each batch bid; always zero for standard auctions. */
+ uint64 minimumPurchaseQuantity;
+
+ /** @brief Initial price for a standard auction; bids cannot start below this total price for the whole lot. */
+ uint64 initialPrice;
+
+ /** @brief Minimum selling price per asset in a batch auction, or desired minimum total selling price for the whole lot in a standard
+ * auction. */
+ uint64 salePrice;
+
+ /** @brief Minimum increment by which a new standard auction bid must exceed the current highest bid. */
+ uint64 minimumBidIncrement;
+
+ /** @brief Buy Now price that closes a standard auction immediately when matched or exceeded. */
+ uint64 buyNowPrice;
+
+ /** @brief Highest offered price per asset in a batch auction, or highest total offered price in a standard auction. */
+ uint64 highestBidPrice;
+
+ /** @brief Quantity requested by the current highest bid. */
+ uint64 highestBidQuantity;
+
+ /** @brief Total amount escrowed by the current highest bid; equal to the committed highest bid amount. */
+ uint64 highestBidAmount;
+
+ /** @brief Auction duration in seconds, derived from the duration configured in days. */
+ uint64 auctionDurationSeconds;
+
+ /** @brief Monotonic identifier assigned when the auction is created. */
+ uint64 auctionIndex;
+
+ /** @brief Monotonic per-auction bid index used to store every batch bid as a separate position. */
+ uint64 nextBidIndex;
+
+ /** @brief Fixed-array slot of the current standard-auction highest bid, or `NOST_INVALID_PARTICIPANT_SLOT`. */
+ uint64 highestBidSlotIndex;
+
+ /** @brief Auction House mode: Batch Auction or Standard Auction. */
+ EAuctionType type;
+
+ /** @brief Auction visibility: public or restricted private access. */
+ EAuctionVisibility visibility;
+
+ /** @brief Current lifecycle status of the auction, including the seller decision phase for standard auctions. */
+ EAuctionStatus status;
};
- struct fundaraisingInfo
+ /**
+ * @brief Stores all persistent data for one auction.
+ * @note The same struct is shared by batch and standard auctions.
+ */
+ struct AuctionData
{
- uint64 tokenPrice;
- uint64 soldAmount;
- uint64 requiredFunds;
- uint64 raisedFunds;
- uint32 indexOfProject;
- uint32 firstPhaseStartDate;
- uint32 firstPhaseEndDate;
- uint32 secondPhaseStartDate;
- uint32 secondPhaseEndDate;
- uint32 thirdPhaseStartDate;
- uint32 thirdPhaseEndDate;
- uint32 listingStartDate;
- uint32 cliffEndDate;
- uint32 vestingEndDate;
- uint8 threshold;
- uint8 TGE;
- uint8 stepOfVesting;
- bit isCreatedToken;
+ /** @brief Fields shared with the public auction view. */
+ AuctionCore core;
+
+ /** @brief Wallet whitelist used when the private auction uses wallet-based access. */
+ HashSet allowedBidderWallets;
+
+ /** @brief Minimum quantity by asset required for participation; owning any one entry grants access. */
+ HashMap requiredAccessAssets;
};
- struct StateData
+ /**
+ * @brief Serializable view of one auction for public getter outputs.
+ * @note Persistent state uses `HashSet` for access checks, but ABI payloads expose fixed arrays because `HashSet` is not valid in
+ * input/output structs.
+ */
+ struct AuctionView
{
- HashMap users;
- HashMap, NOSTROMO_MAX_USER> voteStatus;
- HashMap numberOfVotedProject;
- HashSet tokens;
+ /** @brief Fields shared with the persistent auction record. */
+ AuctionCore core;
+
+ /** @brief Wallet list used when the private auction restricts participation to predefined wallets. */
+ Array allowedBidderWallets;
+
+ /** @brief Asset and minimum-quantity alternatives used by private asset-based access. */
+ Array requiredAccessAssets;
+
+ /** @brief Number of populated entries in `requiredAccessAssets`. */
+ uint64 requiredAccessAssetCount;
- HashMap, NOSTROMO_MAX_USER> investors;
- HashMap numberOfInvestedProjects;
- Array tmpInvestedList;
+ /** @brief Number of populated entries in `allowedBidderWallets`. */
+ uint64 allowedBidderWalletCount;
+ };
- Array projects;
+ struct OldStateData
+ {
+ struct investInfo
+ {
+ uint64 investedAmount;
+ uint64 claimedAmount;
+ uint32 indexOfFundraising;
+ };
- Array fundaraisings;
+ struct projectInfo
+ {
+ id creator;
+ uint64 tokenName;
+ uint64 supplyOfToken;
+ uint32 startDate;
+ uint32 endDate;
+ uint32 numberOfYes;
+ uint32 numberOfNo;
+ bit isCreatedFundarasing;
+ };
+
+ struct fundaraisingInfo
+ {
+ uint64 tokenPrice;
+ uint64 soldAmount;
+ uint64 requiredFunds;
+ uint64 raisedFunds;
+ uint32 indexOfProject;
+ uint32 firstPhaseStartDate;
+ uint32 firstPhaseEndDate;
+ uint32 secondPhaseStartDate;
+ uint32 secondPhaseEndDate;
+ uint32 thirdPhaseStartDate;
+ uint32 thirdPhaseEndDate;
+ uint32 listingStartDate;
+ uint32 cliffEndDate;
+ uint32 vestingEndDate;
+ uint8 threshold;
+ uint8 TGE;
+ uint8 stepOfVesting;
+ bit isCreatedToken;
+ };
+
+ HashMap users;
+ HashMap, NOSTROMO_MAX_USER_OLD> voteStatus;
+ HashMap numberOfVotedProject;
+ HashSet tokens;
+
+ HashMap, NOSTROMO_MAX_USER_OLD> investors;
+ HashMap numberOfInvestedProjects;
+ Array tmpInvestedList;
+
+ Array projects;
+
+ Array fundaraisings;
id teamAddress;
sint64 transferRightsFee;
@@ -217,1432 +473,6044 @@ struct NOST : public ContractBase
uint32 numberOfRegister, numberOfCreatedProject, numberOfFundraising;
};
- struct registerInTier_input
+ /**
+ * @brief Epoch fee accrual shared by Nostromo modules.
+ * @note Auction shareholder amounts are separated by sale tier because their fee formulas differ. Other recipient amounts are compatible sums.
+ */
+ struct NostromoFeePool
+ {
+ uint64 shareholderDividendTier1Amount;
+ uint64 shareholderDividendTier2Amount;
+ uint64 shareholderDividendTier3Amount;
+ uint64 shareholderDividendTier4Amount;
+ uint64 commonServiceFeeAmount;
+ uint64 shareholderDividendAmount;
+ uint64 managementAmount;
+ uint64 developmentAmount;
+ uint64 takeoverCoordinatorAmount;
+ };
+
+ struct StateData
+ {
+ /** @brief Configured fee charged when creating a private auction. */
+ sint64 privateAuctionFee;
+
+ /** @brief Configured non-negative fee accumulated when creating a public auction and distributed at `END_EPOCH`. */
+ sint64 publicAuctionCreationFee;
+
+ /** @brief Configured cancellation fee rate in basis points. */
+ uint64 auctionCancellationFeeBasisPoints;
+
+ /** @brief Undistributed shareholder revenue from the shared fee pool reserved for contract dividends. */
+ uint64 auctionShareholderDividendPool;
+
+ /** @brief Configured management fee rate in basis points, charged from auction proceeds. */
+ uint64 managementFeeBasisPoints;
+
+ /** @brief Configured development fee rate in basis points, charged from auction proceeds. */
+ uint64 developmentFeeBasisPoints;
+
+ /** @brief Configured takeover coordinator fee rate in basis points, charged from auction proceeds. */
+ uint64 takeoverCoordinatorFeeBasisPoints;
+
+ /** @brief Share of the shareholder fee redirected to dividends, expressed in basis points. */
+ uint64 shareholderDividendBasisPoints;
+
+ /** @brief Shareholder fee tier applied to auctions up to the first threshold. */
+ uint64 shareholderFeeBasisPointsTier1;
+
+ /** @brief Shareholder fee tier applied to auctions above the first threshold and up to the second threshold. */
+ uint64 shareholderFeeBasisPointsTier2;
+
+ /** @brief Shareholder fee tier applied to auctions above the second threshold and up to the third threshold. */
+ uint64 shareholderFeeBasisPointsTier3;
+
+ /** @brief Shareholder fee tier applied to auctions above the third threshold. */
+ uint64 shareholderFeeBasisPointsTier4;
+
+ /** @brief Start of the currently active global auction timer pause interval. */
+ DateAndTime auctionTimerPauseStartedAt;
+
+ /** @brief End of the currently active global auction timer pause interval. */
+ DateAndTime auctionTimerPauseEndsAt;
+
+ /** @brief Configured maximum auction duration in days. */
+ uint32 maxAuctionDurationDays;
+
+ /** @brief Cached QX transfer fee refreshed at the beginning of each epoch. */
+ uint32 qxTransferFee;
+
+ /** @brief Flag indicating whether the post-`BEGIN_EPOCH()` auction pause is active for the current epoch. */
+ uint8 isPostBeginEpochPauseArmed;
+
+ /** @brief Flag indicating whether auction deadlines are currently frozen by a global pause interval. */
+ uint8 isAuctionTimerPaused;
+
+ /** @brief Flag indicating whether every auction fee is routed to the development wallet. */
+ uint8 routeAllFeesToDevelopment;
+
+ id management;
+
+ id development;
+
+ id takeoverCoordinator;
+
+ /** @brief Total number of auctions ever created; also the next auction index. */
+ uint64 totalAuctionsCreated;
+
+ /** @brief Circular buffer with full snapshots of finalized and cancelled auctions. */
+ Array closedAuctionHistory;
+
+ /** @brief Monotonic insertion counter for `closedAuctionHistory`. */
+ uint64 closedAuctionHistoryCounter;
+
+ HashMap auctionList;
+ /** @brief Active bid records; slots are cleared as soon as the bid leaves the live order book. */
+ Array participants;
+ /** @brief Bounded history of completed, refunded, and displaced bid records. */
+ Array participantHistory;
+ /** @brief Monotonic insertion counter for `participantHistory`. */
+ uint64 participantHistoryCounter;
+
+ /** @brief Wallet-indexed QU liabilities registered before an auction is finalized. */
+ HashMap pendingQuPayouts;
+ /** @brief Sum of all values in `pendingQuPayouts`, in qu. */
+ uint64 totalPendingQuPayouts;
+ /** @brief Physical hash-map slot from which the next bounded automatic payout scan starts. */
+ uint64 pendingPayoutScanCursor;
+ /** @brief Lifetime number of finalized auctions. */
+ uint64 totalFinalizedAuctions;
+ /** @brief Lifetime number of cancelled auctions. */
+ uint64 totalCancelledAuctions;
+
+ /** @brief Shared fee accrual for Auction House and future Nostromo modules, settled at `END_EPOCH`. */
+ NostromoFeePool feePool;
+
+ /** @brief Configured drop in the execution fee reserve that triggers an emergency pause, in basis points. */
+ uint64 feeReserveGuardDropBasisPoints;
+
+ /** @brief Configured rolling window used to evaluate the execution fee reserve drop, in seconds. */
+ uint64 feeReserveGuardWindowSeconds;
+
+ /** @brief Execution fee reserve value recorded at the start of the current guard window. */
+ sint64 feeReserveBaseline;
+
+ /** @brief Start of the current guard window; invalid when the window has not been initialized. */
+ DateAndTime feeReserveBaselineAt;
+
+ /** @brief Timestamp at which the emergency pause was triggered; invalid when not paused. */
+ DateAndTime emergencyPausedAt;
+
+ /** @brief Flag indicating whether an emergency pause is currently blocking auction interactions. */
+ uint8 isEmergencyPaused;
+ };
+
+ /** @brief Input payload used to create a Batch Auction or Standard Auction in the Auction House. */
+ struct CreateAuction_input
{
- uint32 tierLevel;
+ /** @brief Lowercase base32 CIDv1 stored in Pinata for the auction name and description metadata. */
+ Array metadataIpfsCid;
+
+ /** @brief Assets and quantities offered by the auction. */
+ Array auctionLotItems;
+
+ /** @brief Asset and minimum-quantity alternatives used by private asset-based access. */
+ Array requiredAccessAssets;
+
+ /** @brief Wallet list used when the private auction restricts participation to predefined wallets. */
+ Array allowedBidderWallets;
+
+ /** @brief Required minimum requested quantity for batch bids; ignored for standard auctions. */
+ uint64 minimumPurchaseQuantity;
+
+ /** @brief Initial price for a standard auction; bids cannot be placed below this total price for the whole lot. */
+ uint64 initialPrice;
+
+ /** @brief Minimum selling price per asset in a batch auction, or desired minimum total selling price for the whole lot in a standard
+ * auction. */
+ uint64 salePrice;
+
+ /** @brief Minimum increment by which each new standard auction bid must exceed the current highest bid. */
+ uint64 minimumBidIncrement;
+
+ /** @brief Buy Now price that immediately closes a standard auction once matched or exceeded. */
+ uint64 buyNowPrice;
+
+ /** @brief Auction duration in days, capped by the contract configuration. */
+ uint32 durationDays;
+
+ /** @brief Auction House mode selected by the seller: Batch Auction or Standard Auction. */
+ uint8 auctionType;
+
+ /** @brief Visibility selected by the seller: public or private. */
+ uint8 auctionVisibility;
};
- struct registerInTier_output
+ /** @brief Result of auction creation. */
+ struct CreateAuction_output
{
- uint32 tierLevel;
+ /** @brief Monotonic index assigned to the new auction when creation succeeds. */
+ uint64 auctionIndex;
+
+ /** @brief Result code describing whether the auction creation succeeded. */
+ EAuctionError errorCode;
};
- struct logoutFromTier_input
+ /** @brief Input payload used to place a bid in a Batch Auction or Standard Auction. */
+ struct PlaceBid_input
{
+ /** @brief Monotonic index of the target auction. */
+ uint64 auctionIndex;
+
+ /** @brief Requested quantity for a batch auction, which must meet its configured minimum; ignored for a standard auction. */
+ uint64 quantity;
+ /** @brief Offered price per asset in a batch auction, or total offered price for the whole lot in a standard auction. */
+ uint64 bidAmount;
};
- struct logoutFromTier_output
+ /** @brief Result of a bid placement request. */
+ struct PlaceBid_output
{
- bit result;
+ /** @brief Amount that remains escrowed for the accepted bid. */
+ uint64 escrowedAmount;
+
+ /** @brief Amount refunded to the bidder, including replaced escrow or invocation change. */
+ uint64 refundedAmount;
+
+ /** @brief Result code describing whether the bid placement succeeded. */
+ EAuctionError errorCode;
};
- struct createProject_input
+ /** @brief Input payload used to cancel an active auction. */
+ struct CancelAuction_input
{
- uint64 tokenName;
- uint64 supply;
- uint32 startYear;
- uint32 startMonth;
- uint32 startDay;
- uint32 startHour;
- uint32 endYear;
- uint32 endMonth;
- uint32 endDay;
- uint32 endHour;
+ /** @brief Monotonic index of the auction that the seller wants to cancel. */
+ uint64 auctionIndex;
};
- struct createProject_output
+ /** @brief Result of an auction cancellation request. */
+ struct CancelAuction_output
{
- uint32 indexOfProject;
+ /** @brief Total amount refunded to bidders because of the cancellation. */
+ uint64 refundedAmount;
+
+ /** @brief Cancellation fee charged to the seller according to the auction rules. */
+ uint64 cancellationFee;
+
+ /** @brief Result code describing whether the cancellation succeeded. */
+ EAuctionError errorCode;
};
- struct voteInProject_input
+ /** @brief Input payload used by the seller to accept or reject a pending standard auction result. */
+ struct ResolvePendingStandardAuction_input
{
- uint32 indexOfProject;
- bit decision;
+ /** @brief Monotonic index of the standard auction awaiting the seller decision. */
+ uint64 auctionIndex;
+
+ /** @brief Set to `1` to accept the sale or `0` to reject it. */
+ uint8 acceptSale;
};
- struct voteInProject_output
+ /** @brief Result of a seller decision on a pending standard auction. */
+ struct ResolvePendingStandardAuction_output
{
+ /** @brief Amount refunded to the bidder when the seller rejects the sale. */
+ uint64 refundedAmount;
+ /** @brief Result code describing whether the seller decision was applied. */
+ EAuctionError errorCode;
};
- struct createFundraising_input
+ /** @brief Input payload used by the takeover coordinator to overwrite the full auction fee configuration. */
+ struct SetAuctionFees_input
{
- uint64 tokenPrice;
- uint64 soldAmount;
- uint64 requiredFunds;
+ /** @brief Fee charged when a private auction is created. */
+ sint64 privateAuctionFee;
- uint32 indexOfProject;
- uint32 firstPhaseStartYear;
- uint32 firstPhaseStartMonth;
- uint32 firstPhaseStartDay;
- uint32 firstPhaseStartHour;
- uint32 firstPhaseEndYear;
- uint32 firstPhaseEndMonth;
- uint32 firstPhaseEndDay;
- uint32 firstPhaseEndHour;
+ /** @brief Non-negative fee accumulated when a public auction is created and distributed at `END_EPOCH`. */
+ sint64 publicAuctionCreationFee;
- uint32 secondPhaseStartYear;
- uint32 secondPhaseStartMonth;
- uint32 secondPhaseStartDay;
- uint32 secondPhaseStartHour;
- uint32 secondPhaseEndYear;
- uint32 secondPhaseEndMonth;
- uint32 secondPhaseEndDay;
- uint32 secondPhaseEndHour;
+ /** @brief Cancellation fee rate in basis points. */
+ uint64 auctionCancellationFeeBasisPoints;
- uint32 thirdPhaseStartYear;
- uint32 thirdPhaseStartMonth;
- uint32 thirdPhaseStartDay;
- uint32 thirdPhaseStartHour;
- uint32 thirdPhaseEndYear;
- uint32 thirdPhaseEndMonth;
- uint32 thirdPhaseEndDay;
- uint32 thirdPhaseEndHour;
+ /** @brief Management fee rate in basis points. */
+ uint64 managementFeeBasisPoints;
- uint32 listingStartYear;
- uint32 listingStartMonth;
- uint32 listingStartDay;
- uint32 listingStartHour;
+ /** @brief Development fee rate in basis points. */
+ uint64 developmentFeeBasisPoints;
- uint32 cliffEndYear;
- uint32 cliffEndMonth;
- uint32 cliffEndDay;
- uint32 cliffEndHour;
+ /** @brief Takeover coordinator fee rate in basis points. */
+ uint64 takeoverCoordinatorFeeBasisPoints;
- uint32 vestingEndYear;
- uint32 vestingEndMonth;
- uint32 vestingEndDay;
- uint32 vestingEndHour;
+ /** @brief Percentage of the shareholder fee distributed as dividends, in basis points. */
+ uint64 shareholderDividendBasisPoints;
- uint8 threshold;
- uint8 TGE;
- uint8 stepOfVesting;
- };
+ /** @brief Shareholder fee tier for auctions up to the first threshold. */
+ uint64 shareholderFeeBasisPointsTier1;
- struct createFundraising_output
- {
+ /** @brief Shareholder fee tier for auctions above the first threshold and up to the second threshold. */
+ uint64 shareholderFeeBasisPointsTier2;
+
+ /** @brief Shareholder fee tier for auctions above the second threshold and up to the third threshold. */
+ uint64 shareholderFeeBasisPointsTier3;
+ /** @brief Shareholder fee tier for auctions above the third threshold. */
+ uint64 shareholderFeeBasisPointsTier4;
};
- struct investInProject_input
+ struct SetAuctionFees_output
{
- uint32 indexOfFundraising;
+ /** @brief Result code describing whether the fee update succeeded. */
+ EAuctionError errorCode;
};
- struct investInProject_output
+ /** @brief Input payload used by management to update every fee except takeover coordinator-specific splits. */
+ struct SetAuctionFeesByManagement_input
{
+ /** @brief Fee charged when a private auction is created. */
+ sint64 privateAuctionFee;
+ /** @brief Non-negative fee accumulated when a public auction is created and distributed at `END_EPOCH`. */
+ sint64 publicAuctionCreationFee;
+
+ /** @brief Cancellation fee rate in basis points. */
+ uint64 auctionCancellationFeeBasisPoints;
+
+ /** @brief Management fee rate in basis points. */
+ uint64 managementFeeBasisPoints;
+
+ /** @brief Development fee rate in basis points. */
+ uint64 developmentFeeBasisPoints;
+
+ /** @brief Shareholder fee tier for auctions up to the first threshold. */
+ uint64 shareholderFeeBasisPointsTier1;
+
+ /** @brief Shareholder fee tier for auctions above the first threshold and up to the second threshold. */
+ uint64 shareholderFeeBasisPointsTier2;
+
+ /** @brief Shareholder fee tier for auctions above the second threshold and up to the third threshold. */
+ uint64 shareholderFeeBasisPointsTier3;
+
+ /** @brief Shareholder fee tier for auctions above the third threshold. */
+ uint64 shareholderFeeBasisPointsTier4;
};
- struct claimToken_input
+ struct SetAuctionFeesByManagement_output
{
- uint64 amount;
- uint32 indexOfFundraising;
+ /** @brief Result code describing whether the fee update succeeded. */
+ EAuctionError errorCode;
};
- struct claimToken_output
+ /** @brief Input payload used by the takeover coordinator to appoint a new management wallet. */
+ struct SetManagement_input
{
- uint64 claimedAmount;
+ /** @brief New wallet that will receive management privileges. */
+ id management;
};
- struct upgradeTier_input
+ struct SetManagement_output
{
- uint32 newTierLevel;
+ /** @brief Result code describing whether the management update succeeded. */
+ EAuctionError errorCode;
};
- struct upgradeTier_output
+ /** @brief Input payload used by the takeover coordinator or management to configure the execution fee reserve guard. */
+ struct SetFeeReserveGuardConfig_input
{
+ /** @brief Drop in the execution fee reserve, relative to the window baseline, that triggers an emergency pause, in basis points. */
+ uint64 dropBasisPoints;
+ /** @brief Rolling window used to evaluate the execution fee reserve drop, in seconds. */
+ uint64 windowSeconds;
};
- struct TransferShareManagementRights_input
+ struct SetFeeReserveGuardConfig_output
{
- Asset asset;
- sint64 numberOfShares;
- uint32 newManagingContractIndex;
+ /** @brief Result code describing whether the guard configuration update succeeded. */
+ EAuctionError errorCode;
};
- struct TransferShareManagementRights_output
+
+ /** @brief Input payload used by the takeover coordinator or management to manually pause or resume auction interactions. */
+ struct SetEmergencyPause_input
{
- sint64 transferredNumberOfShares;
+ /** @brief Set to `1` to activate the emergency pause or `0` to resume normal operation. */
+ uint8 paused;
};
- struct getStats_input
+ struct SetEmergencyPause_output
{
-
+ /** @brief Result code describing whether the emergency pause update succeeded. */
+ EAuctionError errorCode;
};
- struct getStats_output
+ /** @brief Input payload used to fetch one auction from storage. */
+ struct GetAuctionByIndex_input
{
- uint64 epochRevenue, totalPoolWeight;
- uint32 numberOfRegister, numberOfCreatedProject, numberOfFundraising;
+ /** @brief Monotonic index of the auction to read. */
+ uint64 auctionIndex;
};
- struct getTierLevelByUser_input
+ /** @brief Auction data returned by the read-only auction getter. */
+ struct GetAuctionByIndex_output
{
- id userId;
+ /** @brief Serializable auction data stored for the requested auction. */
+ AuctionView auction;
+
+ /** @brief Flag indicating whether the auction record exists. */
+ uint8 found;
};
- struct getTierLevelByUser_output
+ /** @brief Input payload used to fetch one participant record from an auction. */
+ struct GetAuctionParticipant_input
{
- uint8 tierLevel;
+ /** @brief Monotonic index of the auction that owns the participant record. */
+ uint64 auctionIndex;
+
+ /** @brief Wallet whose participant record should be returned. */
+ id participant;
};
- struct getUserVoteStatus_input
+ /** @brief Participant data returned by the read-only participant getter. */
+ struct GetAuctionParticipant_output
{
- id userId;
+ /** @brief Participant record for the requested wallet in the requested auction. */
+ AuctionParticipantData participantData;
+
+ /** @brief Flag indicating whether the participant record exists. */
+ uint8 found;
};
- struct getUserVoteStatus_output
+ /** @brief Input payload used to query the remaining post-BEGIN_EPOCH auction launch pause. */
+ using GetTicksBeforeAuctionLaunch_input = NoData;
+
+ /** @brief Result returned by the auction launch pause getter. */
+ struct GetTicksBeforeAuctionLaunch_output
{
- uint32 numberOfVotedProjects;
- Array projectIndexList;
+ /** @brief Number of ticks remaining before auction interactions resume after `BEGIN_EPOCH`. */
+ uint32 ticks;
};
- struct checkTokenCreatability_input
+ /** @brief Input payload used to read the current auction fee configuration. */
+ /** @brief Input payload used to read the amount of accumulated service fees awaiting distribution at `END_EPOCH`. */
+ using GetPendingServiceFeePool_input = NoData;
+
+ struct GetPendingServiceFeePool_output
{
- uint64 tokenName;
+ /** @brief Aggregate fee amount still awaiting `END_EPOCH` settlement. */
+ uint64 pendingServiceFeePool;
};
- struct checkTokenCreatability_output
+ /** @brief Input payload used to inspect the detailed shared Nostromo fee pool. */
+ using GetNostromoFeePool_input = NoData;
+
+ struct GetNostromoFeePool_output
{
- bit result; // result = 1 is the token already issued by SC
+ /** @brief Detailed fee accumulators that have not yet been moved to dividends or recipient payout liabilities. */
+ NostromoFeePool feePool;
+
+ /** @brief Aggregate of every amount in `feePool`. */
+ uint64 totalAmount;
};
- struct getNumberOfInvestedProjects_input
+ /** @brief Input used to inspect a wallet's registered QU payout. */
+ struct GetPendingPayout_input
{
- id userId;
+ /** @brief Wallet whose unpaid QU amount should be returned. */
+ id account;
};
- struct getNumberOfInvestedProjects_output
+ struct GetPendingPayout_output
{
- uint32 numberOfInvestedProjects;
+ /** @brief QU currently owed to the requested wallet. */
+ uint64 amount;
};
-protected:
+ /** @brief Input payload used to read the current state of the execution fee reserve guard. */
+ using GetFeeReserveGuardState_input = NoData;
- struct registerInTier_locals
+ struct GetFeeReserveGuardState_output
{
- uint64 tierStakedAmount;
- uint32 poolWeight;
+ /** @brief Live execution fee reserve value read from the system contract. */
+ sint64 currentFeeReserve;
+
+ /** @brief Execution fee reserve value recorded at the start of the current guard window. */
+ sint64 feeReserveBaseline;
+
+ /** @brief Start of the current guard window; invalid when the window has not been initialized. */
+ DateAndTime feeReserveBaselineAt;
+
+ /** @brief Timestamp at which the emergency pause was triggered; invalid when not paused. */
+ DateAndTime emergencyPausedAt;
+
+ /** @brief Configured drop in the execution fee reserve that triggers an emergency pause, in basis points. */
+ uint64 dropBasisPoints;
+
+ /** @brief Configured rolling window used to evaluate the execution fee reserve drop, in seconds. */
+ uint64 windowSeconds;
+
+ /** @brief Flag indicating whether an emergency pause is currently blocking auction interactions. */
+ uint8 isEmergencyPaused;
};
- PUBLIC_PROCEDURE_WITH_LOCALS(registerInTier)
- {
- if (state.get().users.contains(qpi.invocator()))
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
- }
- if (input.tierLevel < 1 || input.tierLevel > 5)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
- }
-
- switch (input.tierLevel)
- {
- case 1:
- locals.tierStakedAmount = NOSTROMO_TIER_FACEHUGGER_STAKE_AMOUNT;
- locals.poolWeight = NOSTROMO_TIER_FACEHUGGER_POOL_WEIGHT;
- break;
- case 2:
- locals.tierStakedAmount = NOSTROMO_TIER_CHESTBURST_STAKE_AMOUNT;
- locals.poolWeight = NOSTROMO_TIER_CHESTBURST_POOL_WEIGHT;
- break;
- case 3:
- locals.tierStakedAmount = NOSTROMO_TIER_DOG_STAKE_AMOUNT;
- locals.poolWeight = NOSTROMO_TIER_DOG_POOL_WEIGHT;
- break;
- case 4:
- locals.tierStakedAmount = NOSTROMO_TIER_XENOMORPH_STAKE_AMOUNT;
- locals.poolWeight = NOSTROMO_TIER_XENOMORPH_POOL_WEIGHT;
- break;
- case 5:
- locals.tierStakedAmount = NOSTROMO_TIER_WARRIOR_STAKE_AMOUNT;
- locals.poolWeight = NOSTROMO_TIER_WARRIOR_POOL_WEIGHT;
- break;
- default:
- break;
- }
- if (qpi.invocationReward() < (sint64)locals.tierStakedAmount)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
- }
- else
- {
- state.mut().users.set(qpi.invocator(), input.tierLevel);
- state.mut().numberOfRegister++;
- if (qpi.invocationReward() > (sint64)locals.tierStakedAmount)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - locals.tierStakedAmount);
- }
- state.mut().totalPoolWeight += locals.poolWeight;
- output.tierLevel = input.tierLevel;
- }
- }
+ using GetAuctionFees_input = NoData;
- struct logoutFromTier_locals
+ struct GetAuctionFees_output
{
- uint64 earnedAmount;
- uint32 elementIndex;
- uint8 tierLevel;
+ /** @brief Fee charged when a private auction is created. */
+ sint64 privateAuctionFee;
+
+ /** @brief Non-negative fee accumulated when a public auction is created and distributed at `END_EPOCH`. */
+ sint64 publicAuctionCreationFee;
+
+ /** @brief Cancellation fee rate in basis points. */
+ uint64 auctionCancellationFeeBasisPoints;
+
+ /** @brief Management fee rate in basis points. */
+ uint64 managementFeeBasisPoints;
+
+ /** @brief Development fee rate in basis points. */
+ uint64 developmentFeeBasisPoints;
+
+ /** @brief Takeover coordinator fee rate in basis points. */
+ uint64 takeoverCoordinatorFeeBasisPoints;
+
+ /** @brief Percentage of the shareholder fee distributed as dividends, in basis points. */
+ uint64 shareholderDividendBasisPoints;
+
+ /** @brief Shareholder fee tier for auctions up to the first threshold. */
+ uint64 shareholderFeeBasisPointsTier1;
+
+ /** @brief Shareholder fee tier for auctions above the first threshold and up to the second threshold. */
+ uint64 shareholderFeeBasisPointsTier2;
+
+ /** @brief Shareholder fee tier for auctions above the second threshold and up to the third threshold. */
+ uint64 shareholderFeeBasisPointsTier3;
+
+ /** @brief Shareholder fee tier for auctions above the third threshold. */
+ uint64 shareholderFeeBasisPointsTier4;
};
- PUBLIC_PROCEDURE_WITH_LOCALS(logoutFromTier)
+ /** @brief Input for the arithmetic-only Batch Auction bid reward calculator. */
+ struct CalculateBatchAuctionBidFee_input
{
- if (state.get().users.contains(qpi.invocator()) == 0)
- {
- return ;
- }
- state.get().users.get(qpi.invocator(), locals.tierLevel);
- switch (locals.tierLevel)
- {
- case 1:
- locals.earnedAmount = div(NOSTROMO_TIER_FACEHUGGER_STAKE_AMOUNT * NOSTROMO_TIER_FACEHUGGER_UNSTAKE_FEE, 100ULL);
- qpi.transfer(qpi.invocator(), qpi.invocationReward() + NOSTROMO_TIER_FACEHUGGER_STAKE_AMOUNT - locals.earnedAmount);
- state.mut().epochRevenue += locals.earnedAmount;
- state.mut().totalPoolWeight -= NOSTROMO_TIER_FACEHUGGER_POOL_WEIGHT;
- break;
- case 2:
- locals.earnedAmount = div(NOSTROMO_TIER_CHESTBURST_STAKE_AMOUNT * NOSTROMO_TIER_CHESTBURST_UNSTAKE_FEE, 100ULL);
- qpi.transfer(qpi.invocator(), qpi.invocationReward() + NOSTROMO_TIER_CHESTBURST_STAKE_AMOUNT - locals.earnedAmount);
- state.mut().epochRevenue += locals.earnedAmount;
- state.mut().totalPoolWeight -= NOSTROMO_TIER_CHESTBURST_POOL_WEIGHT;
- break;
- case 3:
- locals.earnedAmount = div(NOSTROMO_TIER_DOG_STAKE_AMOUNT * NOSTROMO_TIER_DOG_UNSTAKE_FEE, 100ULL);
- qpi.transfer(qpi.invocator(), qpi.invocationReward() + NOSTROMO_TIER_DOG_STAKE_AMOUNT - locals.earnedAmount);
- state.mut().epochRevenue += locals.earnedAmount;
- state.mut().totalPoolWeight -= NOSTROMO_TIER_DOG_POOL_WEIGHT;
- break;
- case 4:
- locals.earnedAmount = div(NOSTROMO_TIER_XENOMORPH_STAKE_AMOUNT * NOSTROMO_TIER_XENOMORPH_UNSTAKE_FEE, 100ULL);
- qpi.transfer(qpi.invocator(), qpi.invocationReward() + NOSTROMO_TIER_XENOMORPH_STAKE_AMOUNT - locals.earnedAmount);
- state.mut().epochRevenue += locals.earnedAmount;
- state.mut().totalPoolWeight -= NOSTROMO_TIER_XENOMORPH_POOL_WEIGHT;
- break;
- case 5:
- locals.earnedAmount = div(NOSTROMO_TIER_WARRIOR_STAKE_AMOUNT * NOSTROMO_TIER_WARRIOR_UNSTAKE_FEE, 100ULL);
- qpi.transfer(qpi.invocator(), qpi.invocationReward() + NOSTROMO_TIER_WARRIOR_STAKE_AMOUNT - locals.earnedAmount);
- state.mut().epochRevenue += locals.earnedAmount;
- state.mut().totalPoolWeight -= NOSTROMO_TIER_WARRIOR_POOL_WEIGHT;
- break;
- default:
- break;
- }
+ /** @brief Number of assets requested by the prospective bid. */
+ uint64 bidQuantity;
- state.mut().users.removeByKey(qpi.invocator());
- state.mut().numberOfRegister -= 1;
- output.result = 1;
- }
+ /** @brief Prospective price per asset, in qu. */
+ uint64 bidAmount;
+ };
- struct createProject_locals
+ /** @brief Escrow, accumulated fee, and total reward required by the Batch Auction bid arithmetic. */
+ struct CalculateBatchAuctionBidFee_output
{
- projectInfo newProject;
- uint32 elementIndex, startDate, endDate, curDate;
- uint8 tierLevel;
+ /** @brief Saturating product of `bidQuantity` and `bidAmount`. */
+ uint64 escrowAmount;
+
+ /** @brief Amount accumulated for distribution at `END_EPOCH` for an accepted bid: `max(100 - bidQuantity * bidAmount, 0)`. */
+ uint64 fee;
+
+ /** @brief Saturating sum of `escrowAmount` and `fee`. */
+ uint64 requiredReward;
};
- PUBLIC_PROCEDURE_WITH_LOCALS(createProject)
+ /**
+ * @brief Pure breakdown of one auction revenue split.
+ * @note Runtime settlement and tests share this struct to keep fee arithmetic aligned.
+ */
+ struct AuctionRevenueBreakdown
{
- packNostromoDate(input.startYear, input.startMonth, input.startDay, input.startHour, 0, 0, locals.startDate);
- packNostromoDate(input.endYear, input.endMonth, input.endDay, input.endHour, 0, 0, locals.endDate);
- packNostromoDate(qpi.year(), qpi.month(), qpi.day(), qpi.hour(), qpi.minute(), qpi.second(), locals.curDate);
+ /** @brief Net amount that remains for the seller after every configured fee is applied. */
+ uint64 sellerPayout;
- if(locals.curDate > locals.startDate || locals.startDate >= locals.endDate || checkValidNostDateTime(locals.startDate) == 0 || checkValidNostDateTime(locals.endDate) == 0)
- {
- output.indexOfProject = NOSTROMO_MAX_NUMBER_PROJECT;
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return;
- }
+ /** @brief Shareholder fee tier selected for the provided gross amount. */
+ uint64 shareholderFeeBasisPoints;
- if (state.get().tokens.contains(input.tokenName))
- {
- output.indexOfProject = NOSTROMO_MAX_NUMBER_PROJECT;
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
- }
+ /** @brief Gross shareholder fee amount before dividend retention is split out. */
+ uint64 shareholderFeeAmount;
- if (state.get().users.get(qpi.invocator(), locals.tierLevel) && (locals.tierLevel == 4 || locals.tierLevel == 5))
- {
- if (qpi.invocationReward() < NOSTROMO_CREATE_PROJECT_FEE)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- output.indexOfProject = NOSTROMO_MAX_NUMBER_PROJECT;
- return ;
+ /** @brief Portion of the shareholder fee retained by the contract for dividend distribution. */
+ uint64 shareholderDividendAmount;
+
+ /** @brief Management wallet fee amount. */
+ uint64 managementFeeAmount;
+
+ /** @brief Development wallet fee amount. */
+ uint64 developmentFeeAmount;
+
+ /** @brief Base takeover coordinator fee charged directly from the gross amount. */
+ uint64 takeoverCoordinatorBaseAmount;
+
+ /** @brief Total takeover coordinator gain including retained shareholder-fee remainder. */
+ uint64 takeoverCoordinatorFeeAmount;
+ };
+
+ /**
+ * @brief Pure breakdown of one service fee charged for private-auction creation or auction cancellation.
+ * @note Runtime settlement and tests share this struct to keep fee arithmetic aligned.
+ */
+ struct AuctionServiceFeeBreakdown
+ {
+ /** @brief Portion retained by the contract for shareholder dividends. */
+ uint64 shareholderDividendAmount;
+
+ /** @brief Management wallet fee amount. */
+ uint64 managementFeeAmount;
+
+ /** @brief Development wallet fee amount. */
+ uint64 developmentFeeAmount;
+
+ /** @brief Takeover coordinator wallet fee amount. */
+ uint64 takeoverCoordinatorFeeAmount;
+ };
+
+ /** @brief Input payload used to read the wallets that receive auction fee transfers. */
+ using GetFeeRecipients_input = NoData;
+
+ struct GetFeeRecipients_output
+ {
+ /** @brief Wallet that receives the management fee. */
+ id management;
+
+ /** @brief Wallet that receives the development fee. */
+ id development;
+
+ /** @brief Wallet that receives the takeover coordinator fee. */
+ id takeoverCoordinator;
+ };
+
+ /** @brief Input payload used to read the closed auctions history ring buffer. */
+ using GetClosedAuctionHistory_input = NoData;
+
+ struct GetClosedAuctionHistory_output
+ {
+ /** @brief Ring buffer of auction indices recorded after finalization or cancellation. */
+ Array auctionIndices;
+
+ /** @brief Total number of history writes since initialization. */
+ uint64 totalEntries;
+ };
+
+ /** @brief Input payload used to read the temporary fee routing override flag. */
+ using GetRouteAllFeesToDevelopment_input = NoData;
+
+ struct GetRouteAllFeesToDevelopment_output
+ {
+ /** @brief `1` routes every fee to development, `0` uses the standard fee distribution. */
+ uint8 enabled;
+ };
+
+ struct AuctionSummary
+ {
+ Array metadataIpfsCid;
+ id seller;
+ id highestBidder;
+ DateAndTime createdAt;
+ DateAndTime settledAt;
+ uint64 auctionIndex;
+ uint64 quantityForSale;
+ uint64 allocatedQuantity;
+ uint64 initialPrice;
+ uint64 salePrice;
+ uint64 buyNowPrice;
+ uint64 highestBidPrice;
+ uint64 highestBidQuantity;
+ uint64 highestBidAmount;
+ uint8 type;
+ uint8 visibility;
+ uint8 status;
+ };
+
+ struct ParticipantSummary
+ {
+ id participant;
+ DateAndTime lastBidTime;
+ uint64 bidAmount;
+ uint64 escrowedAmount;
+ uint64 requestedQuantity;
+ uint64 allocatedQuantity;
+ uint8 isWinningBid;
+ };
+
+ struct UserParticipationSummary
+ {
+ id participant;
+ DateAndTime lastBidTime;
+ uint64 auctionIndex;
+ uint64 bidAmount;
+ uint64 escrowedAmount;
+ uint64 requestedQuantity;
+ uint64 allocatedQuantity;
+ uint8 isWinningBid;
+ };
+
+ struct ContractStats
+ {
+ uint64 totalAuctionsCreated;
+ uint64 activeAuctionCount;
+ uint64 pendingSellerDecisionAuctionCount;
+ uint64 finalizedAuctionCount;
+ uint64 cancelledAuctionCount;
+ uint64 participantCount;
+ uint64 closedAuctionHistoryCounter;
+ uint64 auctionShareholderDividendPool;
+ uint64 pendingServiceFeePool;
+ uint64 totalPendingQuPayouts;
+ uint64 retainedClosedAuctionCount;
+ uint64 retainedParticipantHistoryCount;
+ uint32 qxTransferFee;
+ uint8 routeAllFeesToDevelopment;
+ uint8 isAuctionTimerPaused;
+ uint8 isPostBeginEpochPauseArmed;
+ uint8 isEmergencyPaused;
+ };
+
+ using GetContractStats_input = NoData;
+ struct GetContractStats_output
+ {
+ ContractStats stats;
+ };
+
+ struct GetAuctionSummaries_input
+ {
+ uint64 offset;
+ uint64 limit;
+ };
+ struct GetAuctionSummaries_output
+ {
+ Array auctions;
+ uint64 totalCount;
+ uint64 returnedCount;
+ };
+
+ struct GetActiveAuctionIndices_input
+ {
+ uint64 offset;
+ uint64 limit;
+ };
+ struct GetActiveAuctionIndices_output
+ {
+ Array auctionIndices;
+ uint64 totalCount;
+ uint64 returnedCount;
+ };
+
+ struct GetAuctionsBySeller_input
+ {
+ id seller;
+ uint64 offset;
+ uint64 limit;
+ };
+ struct GetAuctionsBySeller_output
+ {
+ Array auctions;
+ uint64 totalCount;
+ uint64 returnedCount;
+ };
+
+ struct GetAuctionByMetadataCid_input
+ {
+ Array metadataIpfsCid;
+ };
+ struct GetAuctionByMetadataCid_output
+ {
+ AuctionSummary auction;
+ uint64 auctionIndex;
+ uint8 found;
+ };
+
+ struct GetAuctionSummariesByIndexBatch_input
+ {
+ Array auctionIndices;
+ uint64 count;
+ };
+ struct GetAuctionSummariesByIndexBatch_output
+ {
+ Array auctions;
+ Array found;
+ uint64 returnedCount;
+ };
+
+ struct GetAuctionParticipants_input
+ {
+ uint64 auctionIndex;
+ uint64 offset;
+ uint64 limit;
+ };
+ struct GetAuctionParticipants_output
+ {
+ Array participants;
+ uint64 totalCount;
+ uint64 returnedCount;
+ };
+
+ struct GetUserParticipations_input
+ {
+ id participant;
+ uint64 offset;
+ uint64 limit;
+ };
+ struct GetUserParticipations_output
+ {
+ Array participations;
+ uint64 totalCount;
+ uint64 returnedCount;
+ };
+
+ using GetLatestAuctionIndex_input = NoData;
+ struct GetLatestAuctionIndex_output
+ {
+ uint64 auctionIndex;
+ uint8 found;
+ };
+
+ struct GetAuctionCountBySeller_input
+ {
+ id seller;
+ };
+ struct GetAuctionCountBySeller_output
+ {
+ uint64 count;
+ };
+
+ struct GetAuctionAtCreationSnapshot_input
+ {
+ uint64 auctionIndex;
+ };
+ struct GetAuctionAtCreationSnapshot_output
+ {
+ id seller;
+ DateAndTime createdAt;
+ uint64 auctionIndex;
+ uint64 quantityForSale;
+ uint64 initialPrice;
+ uint64 salePrice;
+ uint64 minimumBidIncrement;
+ uint64 buyNowPrice;
+ uint64 auctionDurationSeconds;
+ uint8 type;
+ uint8 visibility;
+ uint8 found;
+ };
+
+ /** @brief Input payload used to read current bid capacity guidance for one active Batch Auction. */
+ struct GetBatchAuctionBidAvailability_input
+ {
+ /** @brief Monotonic index of the Batch Auction to inspect. */
+ uint64 auctionIndex;
+ };
+
+ /** @brief Read-only guidance for the next acceptable Batch Auction bid. */
+ struct GetBatchAuctionBidAvailability_output
+ {
+ /** @brief Lowest price per asset that can currently accept a new bid meeting the auction minimum quantity. */
+ uint64 minimumBidPrice;
+
+ /** @brief Quantity available at `minimumBidPrice`; zero when no valid new bid can be accepted. */
+ uint64 availableQuantity;
+
+ /** @brief Flag indicating whether the auction exists. */
+ uint8 found;
+
+ /** @brief Flag indicating whether the auction is an active Batch Auction that can accept another valid bid. */
+ uint8 isAcceptingBids;
+ };
+
+ /** @brief Internal input used to validate an auction lot and resolve its total escrow quantity. */
+ struct AnalyzeAuctionLot_input
+ {
+ /** @brief Auction lot contents to validate. */
+ Array auctionLotItems;
+
+ /** @brief Requested auction duration in days. */
+ uint32 durationDays;
+ };
+
+ /** @brief Internal output returned after validating an auction lot. */
+ struct AnalyzeAuctionLot_output
+ {
+ /** @brief Total quantity that must be escrowed from the lot. */
+ uint64 totalEscrowQuantity;
+
+ /** @brief Number of non-empty lot entries found in the lot. */
+ uint64 lotItemCount;
+
+ /** @brief Flag indicating whether the lot and duration are valid. */
+ uint8 isValid;
+ };
+
+ struct AnalyzeAuctionLot_locals
+ {
+ AuctionAssetEntry lotItem;
+ uint64 lotItemIndex;
+ };
+
+ /** @brief Internal input used to count non-empty wallet entries in a private wallet whitelist. */
+ struct CountAllowedBidderWallets_input
+ {
+ /** @brief Wallet list provided for private wallet-based access control. */
+ Array allowedBidderWallets;
+ };
+
+ /** @brief Internal output containing the number of non-empty wallet whitelist entries. */
+ struct CountAllowedBidderWallets_output
+ {
+ /** @brief Number of non-zero wallet entries found in the whitelist. */
+ uint64 allowedWalletCount;
+ };
+
+ struct CountAllowedBidderWallets_locals
+ {
+ uint64 allowedWalletIndex;
+ };
+
+ /** @brief Internal input used to count non-empty asset entries in a private asset access list. */
+ struct CountRequiredAccessAssets_input
+ {
+ /** @brief Asset and minimum-quantity alternatives provided for private access control. */
+ Array requiredAccessAssets;
+ };
+
+ /** @brief Internal output containing the number of non-empty private access assets. */
+ struct CountRequiredAccessAssets_output
+ {
+ /** @brief Number of populated asset entries found in the private access list. */
+ uint64 requiredAccessAssetCount;
+
+ /** @brief Flag indicating whether every entry has a valid asset/quantity combination. */
+ uint8 isValid;
+ };
+
+ struct CountRequiredAccessAssets_locals
+ {
+ AuctionAssetEntry requiredAccessAsset;
+ uint64 requiredAccessAssetIndex;
+ };
+
+ struct NostromoProcedureLog
+ {
+ uint32 contractIndex;
+ uint32 errorCode;
+ id actor;
+ sint64 amount;
+ uint64 auctionIndex;
+ uint8 procedure;
+ sint8 _terminator;
+ };
+
+ /** @brief Internal input used to locate either a live or retained closed auction. */
+ struct FindAuction_input
+ {
+ uint64 auctionIndex;
+ };
+
+ struct FindAuction_output
+ {
+ AuctionData auction;
+ uint8 found;
+ };
+
+ struct FindAuction_locals
+ {
+ AuctionData archivedAuction;
+ uint64 historyIndex;
+ };
+
+ /** @brief Internal input used to test whether an auction remains in retained closed history. */
+ struct IsClosedAuctionRetained_input
+ {
+ uint64 auctionIndex;
+ };
+
+ struct IsClosedAuctionRetained_output
+ {
+ uint8 found;
+ };
+
+ struct IsClosedAuctionRetained_locals
+ {
+ uint64 retainedClosedAuctionCount;
+ uint64 historyIndex;
+ };
+
+ /** @brief Internal cursor used to enumerate retained auctions in ascending creation order. */
+ struct SelectNextRetainedAuction_input
+ {
+ id seller;
+ uint64 afterAuctionIndex;
+ uint8 hasAfterAuctionIndex;
+ uint8 includeClosedAuctions;
+ uint8 filterBySeller;
+ };
+
+ struct SelectNextRetainedAuction_output
+ {
+ AuctionData auction;
+ uint8 found;
+ };
+
+ struct SelectNextRetainedAuction_locals
+ {
+ AuctionData candidateAuction;
+ uint64 retainedClosedAuctionCount;
+ uint64 historyIndex;
+ sint64 auctionElementIndex;
+ };
+
+ struct CountRetainedAuctionsBySeller_input
+ {
+ id seller;
+ };
+
+ struct CountRetainedAuctionsBySeller_output
+ {
+ uint64 count;
+ };
+
+ struct CountRetainedAuctionsBySeller_locals
+ {
+ AuctionData candidateAuction;
+ uint64 retainedClosedAuctionCount;
+ uint64 historyIndex;
+ sint64 auctionElementIndex;
+ };
+
+ struct FindFirstRetainedAuctionByMetadataCid_input
+ {
+ Array metadataIpfsCid;
+ };
+
+ struct FindFirstRetainedAuctionByMetadataCid_output
+ {
+ AuctionData auction;
+ uint8 found;
+ };
+
+ struct FindFirstRetainedAuctionByMetadataCid_locals
+ {
+ AuctionData candidateAuction;
+ uint64 retainedClosedAuctionCount;
+ uint64 metadataIndex;
+ uint64 historyIndex;
+ sint64 auctionElementIndex;
+ uint8 metadataMatches;
+ };
+
+ struct GetAuctionByIndex_locals
+ {
+ AuctionData auction;
+ FindAuction_input findAuctionInput;
+ FindAuction_output findAuctionOutput;
+ AuctionAssetEntry requiredAccessAsset;
+ id allowedBidderWallet;
+ sint64 requiredAccessAssetSetIndex;
+ sint64 allowedBidderWalletSetIndex;
+ };
+
+ struct GetterScan_locals
+ {
+ AuctionData auction;
+ AuctionParticipantData participantData;
+ AuctionSummary auctionSummary;
+ ParticipantSummary participantSummary;
+ UserParticipationSummary userParticipationSummary;
+ SelectNextRetainedAuction_input selectNextAuctionInput;
+ SelectNextRetainedAuction_output selectNextAuctionOutput;
+ FindAuction_input findAuctionInput;
+ FindAuction_output findAuctionOutput;
+ uint64 auctionIndex;
+ uint64 boundedLimit;
+ uint64 metadataIndex;
+ uint64 requestedIndex;
+ uint64 participantSlotIndex;
+ uint64 historyIndex;
+ uint64 scannedAuctionCount;
+ sint64 auctionElementIndex;
+ uint8 metadataMatches;
+ };
+
+ using GetContractStats_locals = GetterScan_locals;
+
+ struct GetAuctionSummaries_locals
+ {
+ AuctionData auction;
+ AuctionSummary auctionSummary;
+ SelectNextRetainedAuction_input selectNextAuctionInput;
+ SelectNextRetainedAuction_output selectNextAuctionOutput;
+ uint64 boundedLimit;
+ uint64 scannedAuctionCount;
+ };
+
+ struct GetActiveAuctionIndices_locals
+ {
+ SelectNextRetainedAuction_input selectNextAuctionInput;
+ SelectNextRetainedAuction_output selectNextAuctionOutput;
+ uint64 boundedLimit;
+ uint64 scannedAuctionCount;
+ };
+
+ struct GetAuctionsBySeller_locals
+ {
+ AuctionData auction;
+ AuctionSummary auctionSummary;
+ SelectNextRetainedAuction_input selectNextAuctionInput;
+ SelectNextRetainedAuction_output selectNextAuctionOutput;
+ CountRetainedAuctionsBySeller_input countAuctionsInput;
+ CountRetainedAuctionsBySeller_output countAuctionsOutput;
+ uint64 boundedLimit;
+ uint64 scannedAuctionCount;
+ };
+
+ struct GetAuctionByMetadataCid_locals
+ {
+ FindFirstRetainedAuctionByMetadataCid_input findAuctionInput;
+ FindFirstRetainedAuctionByMetadataCid_output findAuctionOutput;
+ };
+
+ using GetAuctionSummariesByIndexBatch_locals = GetterScan_locals;
+ using GetAuctionParticipants_locals = GetterScan_locals;
+ using GetUserParticipations_locals = GetterScan_locals;
+
+ struct GetAuctionCountBySeller_locals
+ {
+ CountRetainedAuctionsBySeller_input countAuctionsInput;
+ CountRetainedAuctionsBySeller_output countAuctionsOutput;
+ };
+
+ using GetAuctionAtCreationSnapshot_locals = GetterScan_locals;
+
+ struct GetAuctionParticipant_locals
+ {
+ AuctionParticipantData participantData;
+ uint64 participantSlotIndex;
+ uint64 bestParticipantSlotIndex;
+ uint8 bestParticipantFound;
+ };
+
+ struct GetClosedAuctionHistory_locals
+ {
+ AuctionData auction;
+ uint64 historyIndex;
+ };
+
+ /** @brief Internal input used to compute Batch Auction capacity at a candidate bid price. */
+ struct ComputeBatchBidAvailability_input
+ {
+ /** @brief Monotonic index of the Batch Auction to inspect. */
+ uint64 auctionIndex;
+
+ /** @brief Candidate bid price; zero returns capacity at the computed minimum valid price. */
+ uint64 bidAmount;
+ };
+
+ using ComputeBatchBidAvailability_output = GetBatchAuctionBidAvailability_output;
+
+ struct ComputeBatchBidAvailability_locals
+ {
+ AuctionData auction;
+ AuctionParticipantData participantData;
+ uint64 lowestWinningPrice;
+ uint64 outputPrice;
+ uint64 priorityQuantity;
+ uint64 salePriorityQuantity;
+ uint64 effectiveCoverageQuantity;
+ uint64 participantIndex;
+ uint8 lowestWinningPriceFound;
+ };
+
+ struct GetBatchAuctionBidAvailability_locals
+ {
+ ComputeBatchBidAvailability_input computeBatchBidAvailabilityInput;
+ IsClosedAuctionRetained_input isClosedAuctionRetainedInput;
+ IsClosedAuctionRetained_output isClosedAuctionRetainedOutput;
+ };
+
+ /** @brief Internal input used to verify whether the invocator satisfies any private asset requirement. */
+ struct HasRequiredAccessAsset_input
+ {
+ /** @brief Monotonic index of the auction whose private asset-based access rules should be evaluated. */
+ uint64 auctionIndex;
+ };
+
+ /** @brief Internal output of the private asset access check. */
+ struct HasRequiredAccessAsset_output
+ {
+ /** @brief Flag indicating whether the invocator owns the minimum quantity of any required asset. */
+ uint8 hasRequiredAccessAsset;
+ };
+
+ struct HasRequiredAccessAsset_locals
+ {
+ AuctionData auction;
+ AuctionAssetEntry requiredAccessAsset;
+ sint64 requiredAccessAssetSetIndex;
+ sint64 possessedAccessShares;
+ };
+
+ /** @brief Internal input used to settle a batch auction after its bidding window closes. */
+ struct FinalizeBatchAuction_input
+ {
+ /** @brief Timestamp used as the auction settlement time. */
+ DateAndTime currentDate;
+
+ /** @brief Monotonic index of the batch auction to finalize. */
+ uint64 auctionIndex;
+ };
+
+ /** @brief Internal output returned after batch auction finalization. */
+ struct FinalizeBatchAuction_output
+ {
+ /**
+ * @brief Flag indicating whether batch settlement finished successfully.
+ * @note Final allocations are never smaller than the auction minimum; any insufficient remainder is returned to the seller.
+ */
+ uint8 success;
+ };
+
+ /** @brief Internal input used to settle a standard auction when it is accepted or auto-finalized. */
+ struct FinalizeStandardAuction_input
+ {
+ /** @brief Timestamp used as the auction settlement time. */
+ DateAndTime currentDate;
+
+ /** @brief Monotonic index of the standard auction to finalize. */
+ uint64 auctionIndex;
+ };
+
+ /** @brief Internal output returned after standard auction finalization. */
+ struct FinalizeStandardAuction_output
+ {
+ /** @brief Flag indicating whether standard auction settlement finished successfully. */
+ uint8 success;
+ };
+
+ /** @brief Internal input used to reject a pending standard auction during the seller decision window. */
+ struct RejectStandardAuction_input
+ {
+ /** @brief Timestamp used as the auction settlement time. */
+ DateAndTime currentDate;
+
+ /** @brief Monotonic index of the pending standard auction to reject. */
+ uint64 auctionIndex;
+ };
+
+ /** @brief Internal output returned after rejecting a pending standard auction. */
+ struct RejectStandardAuction_output
+ {
+ /** @brief Amount refunded to the highest bidder after the rejection. */
+ uint64 refundedAmount;
+
+ /** @brief Flag indicating whether the rejection flow finished successfully. */
+ uint8 success;
+ };
+
+ /** @brief Internal input used to evaluate whether auction interactions are currently paused. */
+ struct IsAuctionInteractionPaused_input
+ {
+ };
+
+ /** @brief Internal output of the auction interaction pause check. */
+ struct IsAuctionInteractionPaused_output
+ {
+ /** @brief Flag indicating whether auction interactions are blocked by bootstrap time or by epoch timing pauses. */
+ uint8 isPaused;
+ };
+
+ /** @brief Internal input used to resolve the currently active global auction pause interval. */
+ struct GetAuctionPauseState_input
+ {
+ };
+
+ /** @brief Internal output describing the current global auction pause interval. */
+ struct GetAuctionPauseState_output
+ {
+ /** @brief Pause start timestamp for the current active pause interval. */
+ DateAndTime pauseStartedAt;
+
+ /** @brief Pause end timestamp for the current active pause interval. */
+ DateAndTime pauseEndsAt;
+
+ /** @brief Flag indicating whether auction timers are currently paused. */
+ uint8 isPaused;
+ };
+
+ /** @brief Internal locals used to resolve the currently active global auction pause interval. */
+ struct GetAuctionPauseState_locals
+ {
+ /** @brief Compact current date marker used to detect the bootstrap default time sentinel. */
+ DateAndTime currentDate;
+ uint32 currentDateStamp;
+ };
+
+ using SyncAuctionPauseState_input = NoData;
+ using SyncAuctionPauseState_output = NoData;
+
+ /** @brief Internal locals used to synchronize auction deadlines with the global pause interval. */
+ struct SyncAuctionPauseState_locals
+ {
+ AuctionData auction;
+ DateAndTime currentDate;
+ GetAuctionPauseState_input getAuctionPauseStateInput;
+ GetAuctionPauseState_output getAuctionPauseStateOutput;
+ uint64 pausedSeconds;
+ sint64 auctionIndex;
+ };
+
+ /** @brief Internal input used to split auction proceeds between seller and configured fee recipients. */
+ struct DistributeAuctionRevenue_input
+ {
+ /** @brief Seller wallet that receives the net proceeds. */
+ id seller;
+
+ /** @brief Gross amount collected from the auction before fee distribution. */
+ uint64 grossAmount;
+ };
+
+ /** @brief Internal output returned after auction revenue distribution is computed. */
+ struct DistributeAuctionRevenue_output
+ {
+ /** @brief Net amount that should be transferred to the seller after auction fees. */
+ uint64 sellerPayout;
+
+ /** @brief Flag indicating whether the revenue distribution completed successfully. */
+ uint8 success;
+ };
+
+ /** @brief Internal input used to accrue a service fee in the shared Nostromo fee pool. */
+ struct AccumulateAuctionServiceFee_input
+ {
+ /** @brief Fee amount that should be accumulated. */
+ uint64 feeAmount;
+ };
+
+ /** @brief Internal output returned after service-fee accrual is completed. */
+ struct AccumulateAuctionServiceFee_output
+ {
+ /** @brief Flag indicating whether the service fee was recorded. */
+ uint8 success;
+ };
+
+ using DistributeNostromoFeePool_input = NoData;
+
+ struct DistributeNostromoFeePool_output
+ {
+ /** @brief Flag indicating whether every current pool accumulator was durably settled. */
+ uint8 success;
+ };
+
+ /** @brief Internal input used to compute the remaining post-BEGIN_EPOCH launch pause. */
+ struct GetTicksBeforeAuctionLaunchInternal_input
+ {
+ };
+
+ /** @brief Internal output containing the remaining post-BEGIN_EPOCH launch pause. */
+ struct GetTicksBeforeAuctionLaunchInternal_output
+ {
+ /** @brief Number of ticks remaining before auction interactions resume after `BEGIN_EPOCH`. */
+ uint32 ticks;
+ };
+
+ struct GetTicksBeforeAuctionLaunchInternal_locals
+ {
+ DateAndTime currentDate;
+ DateAndTime pauseEndsAt;
+ uint64 remainingSeconds;
+ };
+
+ struct GetTicksBeforeAuctionLaunch_locals
+ {
+ DateAndTime currentDate;
+ DateAndTime pauseEndsAt;
+ uint64 remainingSeconds;
+ };
+
+ /** @brief Internal input used to register a QU liability before settlement side effects are committed. */
+ struct QueueQuPayout_input
+ {
+ id recipient;
+ uint64 amount;
+ };
+
+ struct QueueQuPayout_output
+ {
+ uint8 success;
+ };
+
+ struct QueueQuPayout_locals
+ {
+ uint64 previousAmount;
+ uint64 updatedAmount;
+ sint64 payoutIndex;
+ };
+
+ /** @brief Internal input used to discharge a bounded number of QPI-sized payout chunks. */
+ struct FlushQuPayout_input
+ {
+ id recipient;
+ uint64 maxChunks;
+ };
+
+ struct FlushQuPayout_output
+ {
+ uint64 transferredAmount;
+ uint64 remainingAmount;
+ uint8 success;
+ };
+
+ struct FlushQuPayout_locals
+ {
+ uint64 chunkAmount;
+ uint64 chunkIndex;
+ sint64 transferResult;
+ };
+
+ using ProcessPendingQuPayouts_input = NoData;
+ using ProcessPendingQuPayouts_output = NoData;
+
+ /** @brief Internal locals used by the bounded round-robin pending-payout processor. */
+ struct ProcessPendingQuPayouts_locals
+ {
+ FlushQuPayout_input flushQuPayoutInput;
+ FlushQuPayout_output flushQuPayoutOutput;
+ id pendingPayoutRecipient;
+ uint64 payoutScanIndex;
+ uint64 payoutTargetRecipientCount;
+ uint64 processedPayoutRecipientCount;
+ sint64 payoutElementIndex;
+ };
+
+ struct QueueAndFlushQuPayout_input
+ {
+ id recipient;
+ uint64 amount;
+ uint64 maxChunks;
+ };
+
+ struct QueueAndFlushQuPayout_output
+ {
+ uint64 transferredAmount;
+ uint64 remainingAmount;
+ uint8 success;
+ };
+
+ struct QueueAndFlushQuPayout_locals
+ {
+ QueueQuPayout_input queueQuPayoutInput;
+ QueueQuPayout_output queueQuPayoutOutput;
+ FlushQuPayout_input flushQuPayoutInput;
+ FlushQuPayout_output flushQuPayoutOutput;
+ };
+
+ /** @brief Internal input used to move a bid record from live storage into bounded history. */
+ struct ArchiveParticipant_input
+ {
+ AuctionParticipantData participantData;
+ };
+
+ using ArchiveParticipant_output = NoData;
+
+ struct ArchiveParticipant_locals
+ {
+ uint64 historyIndex;
+ };
+
+ /** @brief Internal input used to process a batch auction bid after the common PlaceBid checks succeed. */
+ struct ProcessBatchBid_input
+ {
+ /** @brief Monotonic index of the target batch auction. */
+ uint64 auctionIndex;
+
+ /** @brief Quantity requested by the bidder in the batch auction. */
+ uint64 effectiveQuantity;
+
+ /** @brief Offered price per asset for the requested quantity in the batch auction. */
+ uint64 bidAmount;
+
+ /** @brief Timestamp of the accepted bid. */
+ DateAndTime currentDate;
+
+ /** @brief Seconds elapsed since auction creation at the moment of the bid. */
+ uint64 elapsedSeconds;
+ };
+
+ /** @brief Internal input used to refresh the cached highest bid fields of one batch auction. */
+ struct RecomputeBatchHighestBid_input
+ {
+ /** @brief Monotonic index of the batch auction whose cached top bid must be rebuilt. */
+ uint64 auctionIndex;
+ };
+
+ using RecomputeBatchHighestBid_output = NoData;
+
+ /** @brief Internal output returned after processing a batch auction bid. */
+ struct ProcessBatchBid_output
+ {
+ /** @brief Amount that remains escrowed for the accepted batch bid. */
+ uint64 escrowedAmount;
+
+ /** @brief Amount refunded during batch bid processing. */
+ uint64 refundedAmount;
+
+ /** @brief Result code describing whether the batch bid processing succeeded. */
+ EAuctionError errorCode;
+
+ /** @brief Flag indicating whether batch bid processing completed successfully. */
+ uint8 success;
+ };
+
+ struct ProcessBatchBid_locals
+ {
+ AuctionData auction;
+ AuctionParticipantData participantData;
+ AuctionParticipantData worstParticipantData;
+ ComputeBatchBidAvailability_input computeBatchBidAvailabilityInput;
+ ComputeBatchBidAvailability_output computeBatchBidAvailabilityOutput;
+ RecomputeBatchHighestBid_input recomputeBatchHighestBidInput;
+ RecomputeBatchHighestBid_output recomputeBatchHighestBidOutput;
+ ArchiveParticipant_input archiveParticipantInput;
+ ArchiveParticipant_output archiveParticipantOutput;
+ QueueAndFlushQuPayout_input payoutInput;
+ QueueAndFlushQuPayout_output payoutOutput;
+ AccumulateAuctionServiceFee_input accumulateAuctionServiceFeeInput;
+ AccumulateAuctionServiceFee_output accumulateAuctionServiceFeeOutput;
+ uint64 activeQuantity;
+ uint64 displacedQuantity;
+ uint64 displacedRefund;
+ uint64 excessQuantity;
+ uint64 remainingWorstQuantity;
+ CalculateBatchAuctionBidFee_output bidFeeCalculation;
+ uint64 participantIndex;
+ uint64 freeParticipantSlotIndex;
+ uint64 worstParticipantSlotIndex;
+ uint8 worstParticipantFound;
+ uint8 freeParticipantSlotFound;
+ };
+
+ struct RecomputeBatchHighestBid_locals
+ {
+ AuctionData auction;
+ AuctionParticipantData participantData;
+ AuctionParticipantData bestParticipantData;
+ uint64 participantIndex;
+ uint64 bestParticipantSlotIndex;
+ uint8 bestParticipantFound;
+ };
+
+ /** @brief Internal input used to process a standard auction bid after the common PlaceBid checks succeed. */
+ struct ProcessStandardBid_input
+ {
+ /** @brief Monotonic index of the target standard auction. */
+ uint64 auctionIndex;
+
+ /** @brief Total amount the bidder commits for the standard auction lot. */
+ uint64 bidAmount;
+
+ /** @brief Timestamp of the accepted bid. */
+ DateAndTime currentDate;
+
+ /** @brief Seconds elapsed since auction creation at the moment of the bid. */
+ uint64 elapsedSeconds;
+ };
+
+ /** @brief Internal output returned after processing a standard auction bid. */
+ struct ProcessStandardBid_output
+ {
+ /** @brief Amount that remains escrowed for the accepted standard bid. */
+ uint64 escrowedAmount;
+
+ /** @brief Amount refunded during standard bid processing. */
+ uint64 refundedAmount;
+
+ /** @brief Result code describing whether the standard bid processing succeeded. */
+ EAuctionError errorCode;
+
+ /** @brief Flag indicating whether standard bid processing completed successfully. */
+ uint8 success;
+ };
+
+ struct ProcessStandardBid_locals
+ {
+ AuctionData auction;
+ AuctionParticipantData participantData;
+ AuctionParticipantData previousHighestBidderData;
+ FinalizeStandardAuction_input finalizeStandardAuctionInput;
+ FinalizeStandardAuction_output finalizeStandardAuctionOutput;
+ ArchiveParticipant_input archiveParticipantInput;
+ ArchiveParticipant_output archiveParticipantOutput;
+ QueueAndFlushQuPayout_input payoutInput;
+ QueueAndFlushQuPayout_output payoutOutput;
+ uint64 previousEscrow;
+ uint64 requiredEscrow;
+ uint64 participantSlotIndex;
+ uint64 highestBidderSlotIndex;
+ uint64 freeParticipantSlotIndex;
+ uint8 participantExists;
+ uint8 highestBidderExists;
+ uint8 freeParticipantSlotFound;
+ uint8 finalizeImmediately;
+ };
+
+ /** @brief Internal input used to validate the IPFS metadata CID format required by the Auction House. */
+ struct ValidateMetadataCid_input
+ {
+ /** @brief Candidate lowercase base32 CIDv1 for auction metadata stored in Pinata. */
+ Array metadataIpfsCid;
+ };
+
+ /** @brief Internal output of the metadata CID validation routine. */
+ struct ValidateMetadataCid_output
+ {
+ /** @brief Flag indicating whether the metadata CID has the required lowercase base32 CIDv1 format. */
+ uint8 isValid;
+ };
+
+ struct ValidateMetadataCid_locals
+ {
+ uint64 cidIndex;
+ uint8 cidChar;
+ uint8 hasPayloadCharacters;
+ uint8 reachedTerminator;
+ };
+
+ /** @brief Internal input used to verify that the seller owns enough shares for every asset in the auction lot. */
+ struct VerifyAuctionLotBalances_input
+ {
+ /** @brief Auction lot that should be checked against the seller balance. */
+ Array auctionLotItems;
+ };
+
+ /** @brief Internal output of the seller balance verification routine. */
+ struct VerifyAuctionLotBalances_output
+ {
+ /** @brief Flag indicating whether the seller owns enough shares for the entire lot. */
+ uint8 hasEnoughBalance;
+ };
+
+ struct VerifyAuctionLotBalances_locals
+ {
+ AuctionAssetEntry lotItem;
+ uint64 lotItemIndex;
+ sint64 possessedShares;
+ };
+
+ /** @brief Internal input used to transfer the auction lot from the seller into contract escrow. */
+ struct EscrowAuctionLotAssets_input
+ {
+ /** @brief Auction lot that must be moved into contract escrow. */
+ Array auctionLotItems;
+ };
+
+ /** @brief Internal output of the lot escrow routine. */
+ struct EscrowAuctionLotAssets_output
+ {
+ /** @brief Flag indicating whether every lot asset was successfully escrowed. */
+ uint8 success;
+ };
+
+ struct EscrowAuctionLotAssets_locals
+ {
+ AuctionAssetEntry lotItem;
+ uint64 lotItemIndex;
+ uint64 rollbackLotItemIndex;
+ sint64 remainingShares;
+ };
+
+ /** @brief Internal input used to return an auction lot from contract escrow to a target wallet. */
+ struct RollbackAuctionLotAssets_input
+ {
+ /** @brief Auction lot that must be transferred out of contract escrow. */
+ Array auctionLotItems;
+
+ /** @brief Destination wallet that should receive the lot from escrow. */
+ id recipient;
+ };
+
+ using RollbackAuctionLotAssets_output = NoData;
+
+ struct RollbackAuctionLotAssets_locals
+ {
+ AuctionAssetEntry lotItem;
+ uint64 lotItemIndex;
+ };
+
+ /** @brief Internal input used to archive and remove a closed auction from active storage. */
+ struct ArchiveClosedAuction_input
+ {
+ AuctionData auction;
+ };
+
+ using ArchiveClosedAuction_output = NoData;
+
+ struct ArchiveClosedAuction_locals
+ {
+ uint64 historyIndex;
+ };
+
+ struct FinalizeBatchAuction_locals
+ {
+ AuctionData auction;
+ AuctionParticipantData participantData;
+ AuctionParticipantData bestParticipantData;
+ AuctionAssetEntry batchLotItem;
+ DistributeAuctionRevenue_input distributeAuctionRevenueInput;
+ DistributeAuctionRevenue_output distributeAuctionRevenueOutput;
+ ArchiveParticipant_input archiveParticipantInput;
+ ArchiveParticipant_output archiveParticipantOutput;
+ ArchiveClosedAuction_input archiveClosedAuctionInput;
+ ArchiveClosedAuction_output archiveClosedAuctionOutput;
+ QueueAndFlushQuPayout_input payoutInput;
+ QueueAndFlushQuPayout_output payoutOutput;
+ DateAndTime currentDate;
+ uint64 remainingQuantity;
+ uint64 allocatedQuantity;
+ uint64 requiredPayment;
+ uint64 refundAmount;
+ uint64 soldQuantity;
+ uint64 totalGrossAmount;
+ uint64 lotItemIndex;
+ uint64 participantIndex;
+ uint64 bestParticipantSlotIndex;
+ uint8 bestParticipantFound;
+ uint8 lotItemFound;
+ };
+
+ struct FinalizeStandardAuction_locals
+ {
+ AuctionData auction;
+ AuctionParticipantData highestBidderData;
+ RollbackAuctionLotAssets_input rollbackAuctionLotAssetsInput;
+ RollbackAuctionLotAssets_output rollbackAuctionLotAssetsOutput;
+ DistributeAuctionRevenue_input distributeAuctionRevenueInput;
+ DistributeAuctionRevenue_output distributeAuctionRevenueOutput;
+ ArchiveParticipant_input archiveParticipantInput;
+ ArchiveParticipant_output archiveParticipantOutput;
+ ArchiveClosedAuction_input archiveClosedAuctionInput;
+ ArchiveClosedAuction_output archiveClosedAuctionOutput;
+ QueueAndFlushQuPayout_input payoutInput;
+ QueueAndFlushQuPayout_output payoutOutput;
+ uint64 highestBidderSlotIndex;
+ uint8 highestBidderExists;
+ uint8 lotSold;
+ };
+
+ struct DistributeAuctionRevenue_locals
+ {
+ AuctionRevenueBreakdown auctionRevenueBreakdown;
+ NostromoFeePool feePool;
+ QueueAndFlushQuPayout_input payoutInput;
+ QueueAndFlushQuPayout_output payoutOutput;
+ uint64 shareholderFeeTierIndex;
+ };
+
+ struct AccumulateAuctionServiceFee_locals
+ {
+ NostromoFeePool feePool;
+ };
+
+ struct DistributeNostromoFeePool_locals
+ {
+ AuctionServiceFeeBreakdown auctionServiceFeeBreakdown;
+ NostromoFeePool feePool;
+ QueueAndFlushQuPayout_input payoutInput;
+ QueueAndFlushQuPayout_output payoutOutput;
+ uint64 shareholderDividendAmount;
+ uint64 distributedDividendAmount;
+ uint64 dividendPerShare;
+ };
+
+ struct RejectStandardAuction_locals
+ {
+ AuctionData auction;
+ AuctionParticipantData highestBidderData;
+ RollbackAuctionLotAssets_input rollbackAuctionLotAssetsInput;
+ RollbackAuctionLotAssets_output rollbackAuctionLotAssetsOutput;
+ ArchiveParticipant_input archiveParticipantInput;
+ ArchiveParticipant_output archiveParticipantOutput;
+ ArchiveClosedAuction_input archiveClosedAuctionInput;
+ ArchiveClosedAuction_output archiveClosedAuctionOutput;
+ QueueAndFlushQuPayout_input payoutInput;
+ QueueAndFlushQuPayout_output payoutOutput;
+ uint64 highestBidderSlotIndex;
+ uint8 highestBidderExists;
+ };
+
+ struct CreateAuction_locals
+ {
+ AuctionData auction;
+ NostromoProcedureLog log;
+ IsAuctionInteractionPaused_input isAuctionInteractionPausedInput;
+ IsAuctionInteractionPaused_output isAuctionInteractionPausedOutput;
+ ValidateMetadataCid_input validateMetadataCidInput;
+ ValidateMetadataCid_output validateMetadataCidOutput;
+ AnalyzeAuctionLot_input analyzeAuctionLotInput;
+ AnalyzeAuctionLot_output analyzeAuctionLotOutput;
+ CountAllowedBidderWallets_input countAllowedBidderWalletsInput;
+ CountAllowedBidderWallets_output countAllowedBidderWalletsOutput;
+ CountRequiredAccessAssets_input countRequiredAccessAssetsInput;
+ CountRequiredAccessAssets_output countRequiredAccessAssetsOutput;
+ AuctionAssetEntry requiredAccessAsset;
+ VerifyAuctionLotBalances_input verifyAuctionLotBalancesInput;
+ EscrowAuctionLotAssets_input escrowAuctionLotAssetsInput;
+ RollbackAuctionLotAssets_input rollbackAuctionLotAssetsInput;
+ AccumulateAuctionServiceFee_input accumulateAuctionServiceFeeInput;
+ sint64 requiredFee;
+ sint64 existingRequiredAccessQuantity;
+ uint64 resolvedQuantityForSale;
+ uint64 resolvedMinimumPurchaseQuantity;
+ uint64 allowedWalletIndex;
+ uint64 requiredAccessAssetIndex;
+ RollbackAuctionLotAssets_output rollbackAuctionLotAssetsOutput;
+ EscrowAuctionLotAssets_output escrowAuctionLotAssetsOutput;
+ VerifyAuctionLotBalances_output verifyAuctionLotBalancesOutput;
+ AccumulateAuctionServiceFee_output accumulateAuctionServiceFeeOutput;
+ };
+
+ struct PlaceBid_locals
+ {
+ AuctionData auction;
+ FindAuction_input findAuctionInput;
+ FindAuction_output findAuctionOutput;
+ NostromoProcedureLog log;
+ IsAuctionInteractionPaused_input isAuctionInteractionPausedInput;
+ IsAuctionInteractionPaused_output isAuctionInteractionPausedOutput;
+ HasRequiredAccessAsset_input hasRequiredAccessAssetInput;
+ HasRequiredAccessAsset_output hasRequiredAccessAssetOutput;
+ ProcessBatchBid_input processBatchBidInput;
+ ProcessBatchBid_output processBatchBidOutput;
+ ProcessStandardBid_input processStandardBidInput;
+ ProcessStandardBid_output processStandardBidOutput;
+ uint64 elapsedSeconds;
+ DateAndTime currentDate;
+ uint8 hasAccess;
+ };
+
+ struct CancelAuction_locals
+ {
+ AuctionData auction;
+ FindAuction_input findAuctionInput;
+ FindAuction_output findAuctionOutput;
+ AuctionParticipantData participantData;
+ NostromoProcedureLog log;
+ RollbackAuctionLotAssets_input rollbackAuctionLotAssetsInput;
+ RollbackAuctionLotAssets_output rollbackAuctionLotAssetsOutput;
+ AccumulateAuctionServiceFee_input accumulateAuctionServiceFeeInput;
+ AccumulateAuctionServiceFee_output accumulateAuctionServiceFeeOutput;
+ ArchiveClosedAuction_input archiveClosedAuctionInput;
+ ArchiveClosedAuction_output archiveClosedAuctionOutput;
+ DateAndTime currentDate;
+ uint64 cancellationBaseAmount;
+ uint64 participantIndex;
+ };
+
+ struct ResolvePendingStandardAuction_locals
+ {
+ AuctionData auction;
+ FindAuction_input findAuctionInput;
+ FindAuction_output findAuctionOutput;
+ DateAndTime currentDate;
+ NostromoProcedureLog log;
+
+ IsAuctionInteractionPaused_input isAuctionInteractionPausedInput;
+ IsAuctionInteractionPaused_output isAuctionInteractionPausedOutput;
+ FinalizeStandardAuction_input finalizeStandardAuctionInput;
+ FinalizeStandardAuction_output finalizeStandardAuctionOutput;
+ RejectStandardAuction_input rejectStandardAuctionInput;
+ RejectStandardAuction_output rejectStandardAuctionOutput;
+ };
+
+ struct END_TICK_locals
+ {
+ AuctionData auction;
+ DateAndTime currentDate;
+ SyncAuctionPauseState_input syncAuctionPauseStateInput;
+ SyncAuctionPauseState_output syncAuctionPauseStateOutput;
+ uint64 elapsedSeconds;
+ uint32 currentDateStamp;
+ sint64 auctionIndex;
+ FinalizeBatchAuction_input finalizeBatchAuctionInput;
+ FinalizeBatchAuction_output finalizeBatchAuctionOutput;
+ FinalizeStandardAuction_input finalizeStandardAuctionInput;
+ FinalizeStandardAuction_output finalizeStandardAuctionOutput;
+ sint64 currentReserve;
+ sint64 reserveDrop;
+ uint64 guardElapsedSeconds;
+ uint64 guardDropThreshold;
+ };
+
+ struct BEGIN_EPOCH_locals
+ {
+ QX::Fees_input feesInput;
+ QX::Fees_output feesOutput;
+ };
+
+ struct END_EPOCH_locals
+ {
+ DistributeNostromoFeePool_input distributeNostromoFeePoolInput;
+ DistributeNostromoFeePool_output distributeNostromoFeePoolOutput;
+ ProcessPendingQuPayouts_input processPendingQuPayoutsInput;
+ ProcessPendingQuPayouts_output processPendingQuPayoutsOutput;
+ };
+
+ /** @brief Input payload used to move share management rights to another managing contract. */
+ struct TransferShareManagementRights_input
+ {
+ /** @brief Asset whose management rights should be transferred. */
+ Asset asset;
+
+ /** @brief Number of shares whose management rights should be transferred. */
+ sint64 numberOfShares;
+
+ /** @brief Destination managing contract index. */
+ uint32 newManagingContractIndex;
+ };
+
+ /** @brief Result of a share management rights transfer request. */
+ struct TransferShareManagementRights_output
+ {
+ /** @brief Number of shares whose management rights were transferred. */
+ sint64 transferredNumberOfShares;
+
+ /** @brief Result code describing whether the transfer request succeeded. */
+ EAuctionError errorCode;
+ };
+
+ struct TransferShareManagementRights_locals
+ {
+ NostromoProcedureLog log;
+
+ sint64 result;
+ sint64 reward;
+ sint64 refundAmount;
+ bit success;
+ };
+
+ struct SetAuctionFees_locals
+ {
+ NostromoProcedureLog log;
+ };
+
+ struct SetAuctionFeesByManagement_locals
+ {
+ NostromoProcedureLog log;
+ };
+
+ struct SetManagement_locals
+ {
+ NostromoProcedureLog log;
+ };
+
+ struct SetFeeReserveGuardConfig_locals
+ {
+ NostromoProcedureLog log;
+ };
+
+ struct SetEmergencyPause_locals
+ {
+ NostromoProcedureLog log;
+ };
+
+ REGISTER_USER_FUNCTIONS_AND_PROCEDURES()
+ {
+ REGISTER_USER_PROCEDURE(CreateAuction, static_cast(EProcedureId::CreateAuction));
+ REGISTER_USER_PROCEDURE(PlaceBid, static_cast(EProcedureId::PlaceBid));
+ REGISTER_USER_PROCEDURE(CancelAuction, static_cast(EProcedureId::CancelAuction));
+ REGISTER_USER_PROCEDURE(TransferShareManagementRights, static_cast(EProcedureId::TransferShareManagementRights));
+ REGISTER_USER_PROCEDURE(ResolvePendingStandardAuction, static_cast(EProcedureId::ResolvePendingStandardAuction));
+ REGISTER_USER_PROCEDURE(SetAuctionFees, static_cast(EProcedureId::SetAuctionFees));
+ REGISTER_USER_PROCEDURE(SetAuctionFeesByManagement, static_cast(EProcedureId::SetAuctionFeesByManagement));
+ REGISTER_USER_PROCEDURE(SetManagement, static_cast(EProcedureId::SetManagement));
+ REGISTER_USER_PROCEDURE(SetFeeReserveGuardConfig, static_cast(EProcedureId::SetFeeReserveGuardConfig));
+ REGISTER_USER_PROCEDURE(SetEmergencyPause, static_cast(EProcedureId::SetEmergencyPause));
+
+ REGISTER_USER_FUNCTION(GetAuctionByIndex, static_cast(EFunctionId::GetAuctionByIndex));
+ REGISTER_USER_FUNCTION(GetAuctionParticipant, static_cast(EFunctionId::GetAuctionParticipant));
+ REGISTER_USER_FUNCTION(GetTicksBeforeAuctionLaunch, static_cast(EFunctionId::GetTicksBeforeAuctionLaunch));
+ REGISTER_USER_FUNCTION(GetAuctionFees, static_cast(EFunctionId::GetAuctionFees));
+ REGISTER_USER_FUNCTION(GetFeeRecipients, static_cast(EFunctionId::GetFeeRecipients));
+ REGISTER_USER_FUNCTION(GetClosedAuctionHistory, static_cast(EFunctionId::GetClosedAuctionHistory));
+ REGISTER_USER_FUNCTION(GetRouteAllFeesToDevelopment, static_cast(EFunctionId::GetRouteAllFeesToDevelopment));
+ REGISTER_USER_FUNCTION(GetContractStats, static_cast(EFunctionId::GetContractStats));
+ REGISTER_USER_FUNCTION(GetAuctionSummaries, static_cast(EFunctionId::GetAuctionSummaries));
+ REGISTER_USER_FUNCTION(GetActiveAuctionIndices, static_cast(EFunctionId::GetActiveAuctionIndices));
+ REGISTER_USER_FUNCTION(GetAuctionsBySeller, static_cast(EFunctionId::GetAuctionsBySeller));
+ REGISTER_USER_FUNCTION(GetAuctionByMetadataCid, static_cast(EFunctionId::GetAuctionByMetadataCid));
+ REGISTER_USER_FUNCTION(GetAuctionSummariesByIndexBatch, static_cast(EFunctionId::GetAuctionSummariesByIndexBatch));
+ REGISTER_USER_FUNCTION(GetAuctionParticipants, static_cast(EFunctionId::GetAuctionParticipants));
+ REGISTER_USER_FUNCTION(GetUserParticipations, static_cast(EFunctionId::GetUserParticipations));
+ REGISTER_USER_FUNCTION(GetLatestAuctionIndex, static_cast(EFunctionId::GetLatestAuctionIndex));
+ REGISTER_USER_FUNCTION(GetAuctionCountBySeller, static_cast(EFunctionId::GetAuctionCountBySeller));
+ REGISTER_USER_FUNCTION(GetAuctionAtCreationSnapshot, static_cast(EFunctionId::GetAuctionAtCreationSnapshot));
+ REGISTER_USER_FUNCTION(GetBatchAuctionBidAvailability, static_cast(EFunctionId::GetBatchAuctionBidAvailability));
+ REGISTER_USER_FUNCTION(CalculateBatchAuctionBidFee, static_cast(EFunctionId::CalculateBatchAuctionBidFee));
+ REGISTER_USER_FUNCTION(GetPendingServiceFeePool, static_cast(EFunctionId::GetPendingServiceFeePool));
+ REGISTER_USER_FUNCTION(GetFeeReserveGuardState, static_cast(EFunctionId::GetFeeReserveGuardState));
+ REGISTER_USER_FUNCTION(GetPendingPayout, static_cast(EFunctionId::GetPendingPayout));
+ REGISTER_USER_FUNCTION(GetNostromoFeePool, static_cast(EFunctionId::GetNostromoFeePool));
+ }
+
+ /**
+ * @brief Initializes default governance, fee, pause, and guard settings.
+ */
+ INITIALIZE()
+ {
+ // Install the default governance, fee, pause, and guard configuration into the zeroed contract state.
+ state.mut().privateAuctionFee = NOST_DEFAULT_PRIVATE_AUCTION_FEE;
+ state.mut().publicAuctionCreationFee = NOST_PUBLIC_AUCTION_CREATION_FEE;
+ state.mut().auctionCancellationFeeBasisPoints = NOST_DEFAULT_AUCTION_CANCELLATION_FEE_BP;
+ state.mut().managementFeeBasisPoints = NOST_DEFAULT_AUCTION_MANAGEMENT_FEE_BP;
+ state.mut().developmentFeeBasisPoints = NOST_DEFAULT_AUCTION_DEVELOPMENT_FEE_BP;
+ state.mut().takeoverCoordinatorFeeBasisPoints = NOST_DEFAULT_AUCTION_TAKEOVER_COORDINATOR_FEE_BP;
+ state.mut().shareholderDividendBasisPoints = NOST_DEFAULT_AUCTION_SHAREHOLDER_DIVIDEND_BP;
+ state.mut().shareholderFeeBasisPointsTier1 = NOST_DEFAULT_AUCTION_SHAREHOLDER_FEE_BP_TIER_1;
+ state.mut().shareholderFeeBasisPointsTier2 = NOST_DEFAULT_AUCTION_SHAREHOLDER_FEE_BP_TIER_2;
+ state.mut().shareholderFeeBasisPointsTier3 = NOST_DEFAULT_AUCTION_SHAREHOLDER_FEE_BP_TIER_3;
+ state.mut().shareholderFeeBasisPointsTier4 = NOST_DEFAULT_AUCTION_SHAREHOLDER_FEE_BP_TIER_4;
+ state.mut().maxAuctionDurationDays = NOST_AUCTION_MAX_DURATION_DAYS;
+ state.mut().isAuctionTimerPaused = 1;
+ state.mut().routeAllFeesToDevelopment = NOST_ROUTE_ALL_FEES_TO_DEVELOPMENT;
+ state.mut().auctionTimerPauseStartedAt.setInvalid();
+ state.mut().auctionTimerPauseEndsAt.setInvalid();
+ state.mut().feeReserveGuardDropBasisPoints = NOST_DEFAULT_FEE_RESERVE_GUARD_DROP_BP;
+ state.mut().feeReserveGuardWindowSeconds = NOST_DEFAULT_FEE_RESERVE_GUARD_WINDOW_SECONDS;
+ state.mut().management = ID(_I, _G, _P, _Z, _X, _Q, _O, _R, _J, _Y, _Q, _P, _A, _G, _V, _A, _B, _N, _T, _N, _I, _S, _O, _Y, _T, _M, _T, _A,
+ _N, _M, _K, _Z, _A, _S, _T, _P, _P, _G, _Z, _O, _N, _A, _Q, _J, _X, _Q, _O, _S, _W, _Q, _O, _V, _J, _C, _K, _D);
+ state.mut().development = ID(_D, _Q, _V, _H, _M, _Z, _F, _C, _W, _O, _K, _M, _H, _F, _B, _H, _L, _X, _U, _I, _U, _G, _P, _P, _X, _R, _Z, _C,
+ _U, _V, _S, _N, _J, _F, _Z, _J, _F, _M, _Q, _M, _Y, _D, _B, _X, _E, _S, _E, _A, _T, _M, _W, _L, _K, _N, _L, _D);
+ state.mut().takeoverCoordinator =
+ ID(_X, _J, _O, _S, _N, _L, _T, _Z, _V, _V, _H, _N, _Z, _C, _B, _Y, _X, _I, _E, _V, _N, _E, _P, _P, _B, _O, _Q, _A, _W, _D, _B, _V, _G, _E,
+ _N, _Z, _O, _X, _S, _V, _O, _B, _K, _G, _Z, _C, _C, _F, _D, _B, _D, _M, _T, _M, _L, _C);
+ }
+
+ MIGRATE()
+ {
+ state.mut().privateAuctionFee = NOST_DEFAULT_PRIVATE_AUCTION_FEE;
+ state.mut().publicAuctionCreationFee = NOST_PUBLIC_AUCTION_CREATION_FEE;
+ state.mut().auctionCancellationFeeBasisPoints = NOST_DEFAULT_AUCTION_CANCELLATION_FEE_BP;
+ state.mut().managementFeeBasisPoints = NOST_DEFAULT_AUCTION_MANAGEMENT_FEE_BP;
+ state.mut().developmentFeeBasisPoints = NOST_DEFAULT_AUCTION_DEVELOPMENT_FEE_BP;
+ state.mut().takeoverCoordinatorFeeBasisPoints = NOST_DEFAULT_AUCTION_TAKEOVER_COORDINATOR_FEE_BP;
+ state.mut().shareholderDividendBasisPoints = NOST_DEFAULT_AUCTION_SHAREHOLDER_DIVIDEND_BP;
+ state.mut().shareholderFeeBasisPointsTier1 = NOST_DEFAULT_AUCTION_SHAREHOLDER_FEE_BP_TIER_1;
+ state.mut().shareholderFeeBasisPointsTier2 = NOST_DEFAULT_AUCTION_SHAREHOLDER_FEE_BP_TIER_2;
+ state.mut().shareholderFeeBasisPointsTier3 = NOST_DEFAULT_AUCTION_SHAREHOLDER_FEE_BP_TIER_3;
+ state.mut().shareholderFeeBasisPointsTier4 = NOST_DEFAULT_AUCTION_SHAREHOLDER_FEE_BP_TIER_4;
+ state.mut().maxAuctionDurationDays = NOST_AUCTION_MAX_DURATION_DAYS;
+ state.mut().routeAllFeesToDevelopment = NOST_ROUTE_ALL_FEES_TO_DEVELOPMENT;
+ state.mut().feeReserveGuardDropBasisPoints = NOST_DEFAULT_FEE_RESERVE_GUARD_DROP_BP;
+ state.mut().feeReserveGuardWindowSeconds = NOST_DEFAULT_FEE_RESERVE_GUARD_WINDOW_SECONDS;
+ state.mut().management = ID(_I, _G, _P, _Z, _X, _Q, _O, _R, _J, _Y, _Q, _P, _A, _G, _V, _A, _B, _N, _T, _N, _I, _S, _O, _Y, _T, _M, _T, _A,
+ _N, _M, _K, _Z, _A, _S, _T, _P, _P, _G, _Z, _O, _N, _A, _Q, _J, _X, _Q, _O, _S, _W, _Q, _O, _V, _J, _C, _K, _D);
+ state.mut().development = ID(_D, _Q, _V, _H, _M, _Z, _F, _C, _W, _O, _K, _M, _H, _F, _B, _H, _L, _X, _U, _I, _U, _G, _P, _P, _X, _R, _Z, _C,
+ _U, _V, _S, _N, _J, _F, _Z, _J, _F, _M, _Q, _M, _Y, _D, _B, _X, _E, _S, _E, _A, _T, _M, _W, _L, _K, _N, _L, _D);
+ state.mut().takeoverCoordinator =
+ ID(_X, _J, _O, _S, _N, _L, _T, _Z, _V, _V, _H, _N, _Z, _C, _B, _Y, _X, _I, _E, _V, _N, _E, _P, _P, _B, _O, _Q, _A, _W, _D, _B, _V, _G, _E,
+ _N, _Z, _O, _X, _S, _V, _O, _B, _K, _G, _Z, _C, _C, _F, _D, _B, _D, _M, _T, _M, _L, _C);
+ }
+
+ /**
+ * @brief Allows share acquisition without charging an additional contract fee.
+ */
+ PRE_ACQUIRE_SHARES()
+ {
+ output.requestedFee = 0;
+ output.allowTransfer = true;
+ }
+
+ /**
+ * @brief Refreshes epoch-scoped configuration and arms auction timer pauses.
+ */
+ BEGIN_EPOCH_WITH_LOCALS()
+ {
+ // Refresh the QX fee cache once per epoch so share transfers can expose current cost guidance.
+ CALL_OTHER_CONTRACT_FUNCTION(QX, Fees, locals.feesInput, locals.feesOutput);
+ // Preserve the previous cache when QX is temporarily unavailable; a failed call must not install an undefined fee.
+ if (interContractCallError == NoCallError)
+ {
+ state.mut().qxTransferFee = locals.feesOutput.transferFee;
+ }
+
+ // Freeze auction timers across the epoch boundary; END_TICK later accounts this pause back into deadlines.
+ state.mut().isPostBeginEpochPauseArmed = 1;
+ if (!state.get().isAuctionTimerPaused)
+ {
+ state.mut().isAuctionTimerPaused = 1;
+ state.mut().auctionTimerPauseStartedAt = qpi.now();
+ state.mut().auctionTimerPauseEndsAt = qpi.now();
+ return;
+ }
+
+ if (!state.get().auctionTimerPauseStartedAt.isValid() || qpi.now() < state.get().auctionTimerPauseStartedAt)
+ {
+ state.mut().auctionTimerPauseStartedAt = qpi.now();
+ }
+ if (!state.get().auctionTimerPauseEndsAt.isValid() || qpi.now() > state.get().auctionTimerPauseEndsAt)
+ {
+ state.mut().auctionTimerPauseEndsAt = qpi.now();
+ }
+ }
+
+ /**
+ * @brief Retries pending QU payouts, settles the shared Nostromo fee pool, and performs storage cleanup.
+ */
+ END_EPOCH_WITH_LOCALS()
+ {
+ CALL(ProcessPendingQuPayouts, locals.processPendingQuPayoutsInput, locals.processPendingQuPayoutsOutput);
+
+ CALL(DistributeNostromoFeePool, locals.distributeNostromoFeePoolInput, locals.distributeNostromoFeePoolOutput);
+
+ state.mut().auctionList.cleanupIfNeeded();
+ state.mut().pendingQuPayouts.cleanupIfNeeded();
+ }
+
+ /**
+ * @brief Advances auction lifecycle state and finalizes auctions whose deadlines elapsed.
+ */
+ END_TICK_WITH_LOCALS()
+ {
+ makeDateStamp(qpi.year(), qpi.month(), qpi.day(), locals.currentDateStamp);
+ locals.currentDate = qpi.now();
+
+ // The reserve guard converts a sudden execution-fee reserve drop into an emergency pause.
+ if (!state.get().isEmergencyPaused)
+ {
+ locals.currentReserve = qpi.queryFeeReserve(SELF_INDEX);
+ // The first observation establishes a baseline instead of interpreting startup state as a reserve drop.
+ if (!state.get().feeReserveBaselineAt.isValid())
+ {
+ state.mut().feeReserveBaseline = locals.currentReserve;
+ state.mut().feeReserveBaselineAt = locals.currentDate;
+ }
+ else
+ {
+ // Subsequent observations either trigger the guard or roll the baseline into a new window.
+ diffDateInSecond(state.get().feeReserveBaselineAt, locals.currentDate, locals.guardElapsedSeconds);
+ locals.reserveDrop = state.get().feeReserveBaseline - locals.currentReserve;
+ if (state.get().feeReserveBaseline > 0 && locals.reserveDrop > 0)
+ {
+ locals.guardDropThreshold =
+ div(smul(static_cast(state.get().feeReserveBaseline), state.get().feeReserveGuardDropBasisPoints),
+ NOST_BASIS_POINTS_SCALE);
+ if (static_cast(locals.reserveDrop) >= locals.guardDropThreshold &&
+ locals.guardElapsedSeconds <= state.get().feeReserveGuardWindowSeconds)
+ {
+ state.mut().isEmergencyPaused = 1;
+ state.mut().emergencyPausedAt = locals.currentDate;
+ state.mut().feeReserveBaselineAt.setInvalid();
+ }
+ else if (locals.guardElapsedSeconds >= state.get().feeReserveGuardWindowSeconds)
+ {
+ state.mut().feeReserveBaseline = locals.currentReserve;
+ state.mut().feeReserveBaselineAt = locals.currentDate;
+ }
+ }
+ else if (locals.guardElapsedSeconds >= state.get().feeReserveGuardWindowSeconds)
+ {
+ state.mut().feeReserveBaseline = locals.currentReserve;
+ state.mut().feeReserveBaselineAt = locals.currentDate;
+ }
+ }
+ }
+
+ CALL(SyncAuctionPauseState, locals.syncAuctionPauseStateInput, locals.syncAuctionPauseStateOutput);
+ // Lifecycle transitions must not advance while SyncAuctionPauseState still owns the global timer freeze.
+ if (state.get().isAuctionTimerPaused)
+ {
+ return;
+ }
+
+ // Only live auctions advance after pause synchronization has extended their timers.
+ locals.auctionIndex = state.get().auctionList.nextElementIndex(NULL_INDEX);
+ while (locals.auctionIndex != NULL_INDEX)
+ {
+ locals.auction = state.get().auctionList.value(locals.auctionIndex);
+ switch (locals.auction.core.status)
+ {
+ case EAuctionStatus::Active:
+ diffDateInSecond(locals.auction.core.createdAt, locals.currentDate, locals.elapsedSeconds);
+ // Only an elapsed active auction is eligible for automatic settlement or seller-decision transition.
+ if (locals.elapsedSeconds >= locals.auction.core.auctionDurationSeconds)
+ {
+ switch (locals.auction.core.type)
+ {
+ case EAuctionType::Batch:
+ locals.finalizeBatchAuctionInput.auctionIndex = locals.auction.core.auctionIndex;
+ locals.finalizeBatchAuctionInput.currentDate = locals.currentDate;
+ CALL(FinalizeBatchAuction, locals.finalizeBatchAuctionInput, locals.finalizeBatchAuctionOutput);
+ break;
+ case EAuctionType::Standard:
+ // No-bid and reserve-satisfying outcomes are deterministic and need no seller approval window.
+ if (locals.auction.core.highestBidAmount == 0 || locals.auction.core.highestBidPrice >= locals.auction.core.salePrice)
+ {
+ locals.finalizeStandardAuctionInput.auctionIndex = locals.auction.core.auctionIndex;
+ locals.finalizeStandardAuctionInput.currentDate = locals.currentDate;
+ CALL(FinalizeStandardAuction, locals.finalizeStandardAuctionInput, locals.finalizeStandardAuctionOutput);
+ }
+ else
+ {
+ // A funded bid below the seller's sale price requires an explicit, time-bounded seller choice.
+ // Below-sale standard bids enter a seller decision window instead of settling immediately.
+ locals.auction.core.status = EAuctionStatus::PendingSellerDecision;
+ locals.auction.core.sellerDecisionDeadline = locals.currentDate;
+ locals.auction.core.sellerDecisionDeadline.add(0, 0, 0, 0, 0, NOST_AUCTION_SELLER_DECISION_WINDOW_SECONDS);
+ state.mut().auctionList.replace(locals.auction.core.auctionIndex, locals.auction);
+ }
+ break;
+ default: break;
+ };
+ }
+ break;
+ case EAuctionStatus::PendingSellerDecision:
+ switch (locals.auction.core.type)
+ {
+ case EAuctionType::Standard:
+ // Expiry resolves in favor of the recorded highest bidder so the seller cannot lock escrow indefinitely.
+ if (locals.auction.core.sellerDecisionDeadline <= locals.currentDate)
+ {
+ locals.finalizeStandardAuctionInput.auctionIndex = locals.auction.core.auctionIndex;
+ locals.finalizeStandardAuctionInput.currentDate = locals.currentDate;
+ CALL(FinalizeStandardAuction, locals.finalizeStandardAuctionInput, locals.finalizeStandardAuctionOutput);
+ }
+ break;
+ default: break;
+ }
+ break;
+ default: break;
+ }
+
+ locals.auctionIndex = state.get().auctionList.nextElementIndex(locals.auctionIndex);
+ }
+ }
+
+ /**
+ * @brief Validates auction lot entries and totals the escrowed quantity.
+ */
+ PRIVATE_FUNCTION_WITH_LOCALS(AnalyzeAuctionLot)
+ {
+ output.totalEscrowQuantity = 0;
+ output.lotItemCount = 0;
+ output.isValid = 0;
+
+ // Lot validation also enforces the configured maximum auction lifetime.
+ if (input.durationDays == 0 || input.durationDays > state.get().maxAuctionDurationDays)
+ {
+ return;
+ }
+
+ // Scan the full fixed ABI array because valid entries may be followed only by zero-padded slots.
+ for (locals.lotItemIndex = 0; locals.lotItemIndex < input.auctionLotItems.capacity(); ++locals.lotItemIndex)
+ {
+ locals.lotItem = input.auctionLotItems.get(locals.lotItemIndex);
+ // A zero asset is padding only when its paired quantity is also zero.
+ if (isZeroAsset(locals.lotItem.asset))
+ {
+ if (locals.lotItem.quantity != 0)
+ {
+ return;
+ }
+ continue;
+ }
+
+ if (locals.lotItem.quantity <= 0)
+ {
+ return;
+ }
+
+ output.lotItemCount = sadd(output.lotItemCount, 1ULL);
+ output.totalEscrowQuantity = sadd(output.totalEscrowQuantity, static_cast(locals.lotItem.quantity));
+ }
+
+ output.isValid = output.lotItemCount > 0 ? 1 : 0;
+ }
+
+ /**
+ * @brief Resolves whether the current tick belongs to a scheduled auction pause window.
+ */
+ PRIVATE_FUNCTION_WITH_LOCALS(GetAuctionPauseState)
+ {
+ output.isPaused = 0;
+ output.pauseStartedAt.setInvalid();
+ output.pauseEndsAt.setInvalid();
+
+ // The initial runtime date is treated as a full-day launch pause.
+ locals.currentDate = qpi.now();
+ makeDateStamp(qpi.year(), qpi.month(), qpi.day(), locals.currentDateStamp);
+ if (locals.currentDateStamp == NOST_DEFAULT_INIT_TIME)
+ {
+ output.isPaused = 1;
+ output.pauseStartedAt = locals.currentDate;
+ output.pauseStartedAt.setTime(0, 0, 0, 0, 0);
+ output.pauseEndsAt = output.pauseStartedAt;
+ output.pauseEndsAt.addDays(1);
+ return;
+ }
+
+ // Scheduled pre-epoch pauses keep auctions from expiring during the transition window.
+ if (qpi.dayOfWeek(qpi.year(), qpi.month(), qpi.day()) == NOST_PRE_EPOCH_PAUSE_DAY_OF_WEEK && qpi.hour() == NOST_PRE_EPOCH_PAUSE_HOUR &&
+ qpi.minute() >= NOST_PRE_EPOCH_PAUSE_MINUTE)
+ {
+ output.isPaused = 1;
+ output.pauseStartedAt = locals.currentDate;
+ output.pauseStartedAt.setTime(NOST_PRE_EPOCH_PAUSE_HOUR, NOST_PRE_EPOCH_PAUSE_MINUTE, 0, 0, 0);
+ output.pauseEndsAt = output.pauseStartedAt;
+ output.pauseEndsAt.add(0, 0, 0, 0, 0, NOST_AUCTION_PRE_EPOCH_PAUSE_SECONDS);
+ }
+ }
+
+ /**
+ * @brief Reports whether user-facing auction interactions are currently paused.
+ */
+ PRIVATE_FUNCTION(IsAuctionInteractionPaused)
+ {
+ // Emergency pause takes precedence over scheduled and post-epoch launch pauses.
+ if (state.get().isEmergencyPaused)
+ {
+ output.isPaused = 1;
+ return;
+ }
+
+ output.isPaused = state.get().isAuctionTimerPaused;
+ if (output.isPaused)
+ {
+ return;
+ }
+
+ output.isPaused = state.get().isPostBeginEpochPauseArmed && (qpi.tick() - qpi.initialTick()) < NOST_AUCTION_POST_BEGIN_EPOCH_PAUSE_TICKS;
+ }
+
+ /**
+ * @brief Synchronizes timer pause state and extends affected auction deadlines.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(SyncAuctionPauseState)
+ {
+ locals.currentDate = qpi.now();
+
+ // While emergency pause is active, keep extending the timer pause window.
+ if (state.get().isEmergencyPaused)
+ {
+ if (!state.get().isAuctionTimerPaused)
+ {
+ state.mut().isAuctionTimerPaused = 1;
+ state.mut().auctionTimerPauseStartedAt = locals.currentDate;
+ state.mut().auctionTimerPauseEndsAt = locals.currentDate;
+ }
+ else
+ {
+ state.mut().auctionTimerPauseEndsAt = locals.currentDate;
+ }
+ return;
+ }
+
+ CALL(GetAuctionPauseState, locals.getAuctionPauseStateInput, locals.getAuctionPauseStateOutput);
+
+ // The launch pause can overlap the scheduled pause; merge both windows before timers resume.
+ if (state.get().isPostBeginEpochPauseArmed)
+ {
+ if ((qpi.tick() - qpi.initialTick()) < NOST_AUCTION_POST_BEGIN_EPOCH_PAUSE_TICKS)
+ {
+ if (!state.get().isAuctionTimerPaused)
+ {
+ state.mut().isAuctionTimerPaused = 1;
+ state.mut().auctionTimerPauseStartedAt = locals.currentDate;
+ state.mut().auctionTimerPauseEndsAt = locals.currentDate;
+ }
+ else
+ {
+ if (!state.get().auctionTimerPauseStartedAt.isValid())
+ {
+ state.mut().auctionTimerPauseStartedAt = locals.currentDate;
+ }
+ if (!state.get().auctionTimerPauseEndsAt.isValid() || locals.currentDate > state.get().auctionTimerPauseEndsAt)
+ {
+ state.mut().auctionTimerPauseEndsAt = locals.currentDate;
+ }
+ }
+
+ if (locals.getAuctionPauseStateOutput.isPaused)
+ {
+ if (!state.get().auctionTimerPauseStartedAt.isValid() ||
+ locals.getAuctionPauseStateOutput.pauseStartedAt < state.get().auctionTimerPauseStartedAt)
+ {
+ state.mut().auctionTimerPauseStartedAt = locals.getAuctionPauseStateOutput.pauseStartedAt;
+ }
+ if (!state.get().auctionTimerPauseEndsAt.isValid() ||
+ locals.getAuctionPauseStateOutput.pauseEndsAt > state.get().auctionTimerPauseEndsAt)
+ {
+ state.mut().auctionTimerPauseEndsAt = locals.getAuctionPauseStateOutput.pauseEndsAt;
+ }
+ }
+ return;
+ }
+
+ state.mut().isPostBeginEpochPauseArmed = 0;
+ }
+
+ // Scheduled pauses are recorded as a window that will later be added to all active deadlines.
+ if (locals.getAuctionPauseStateOutput.isPaused)
+ {
+ if (!state.get().isAuctionTimerPaused)
+ {
+ state.mut().isAuctionTimerPaused = 1;
+ state.mut().auctionTimerPauseStartedAt = locals.getAuctionPauseStateOutput.pauseStartedAt;
+ state.mut().auctionTimerPauseEndsAt = locals.getAuctionPauseStateOutput.pauseEndsAt;
+ return;
+ }
+
+ if (!state.get().auctionTimerPauseStartedAt.isValid() ||
+ locals.getAuctionPauseStateOutput.pauseStartedAt < state.get().auctionTimerPauseStartedAt)
+ {
+ state.mut().auctionTimerPauseStartedAt = locals.getAuctionPauseStateOutput.pauseStartedAt;
+ }
+ if (!state.get().auctionTimerPauseEndsAt.isValid() || locals.getAuctionPauseStateOutput.pauseEndsAt > state.get().auctionTimerPauseEndsAt)
+ {
+ state.mut().auctionTimerPauseEndsAt = locals.getAuctionPauseStateOutput.pauseEndsAt;
+ }
+ return;
+ }
+
+ if (!state.get().isAuctionTimerPaused)
+ {
+ return;
+ }
+
+ if (!state.get().auctionTimerPauseStartedAt.isValid() || !state.get().auctionTimerPauseEndsAt.isValid())
+ {
+ state.mut().isAuctionTimerPaused = 0;
+ state.mut().auctionTimerPauseStartedAt.setInvalid();
+ state.mut().auctionTimerPauseEndsAt.setInvalid();
+ return;
+ }
+
+ // When the pause ends, preserve elapsed auction time by extending every affected deadline.
+ diffDateInSecond(state.get().auctionTimerPauseStartedAt, state.get().auctionTimerPauseEndsAt, locals.pausedSeconds);
+ if (locals.pausedSeconds > 0)
+ {
+ locals.auctionIndex = state.get().auctionList.nextElementIndex(NULL_INDEX);
+ while (locals.auctionIndex != NULL_INDEX)
+ {
+ locals.auction = state.get().auctionList.value(locals.auctionIndex);
+ if (locals.auction.core.status == EAuctionStatus::Active)
+ {
+ locals.auction.core.auctionDurationSeconds = sadd(locals.auction.core.auctionDurationSeconds, locals.pausedSeconds);
+ state.mut().auctionList.replace(locals.auction.core.auctionIndex, locals.auction);
+ }
+ else if (locals.auction.core.status == EAuctionStatus::PendingSellerDecision && locals.auction.core.sellerDecisionDeadline.isValid())
+ {
+ locals.auction.core.sellerDecisionDeadline.add(0, 0, 0, 0, 0, static_cast(locals.pausedSeconds));
+ state.mut().auctionList.replace(locals.auction.core.auctionIndex, locals.auction);
+ }
+ locals.auctionIndex = state.get().auctionList.nextElementIndex(locals.auctionIndex);
+ }
+ }
+
+ state.mut().isAuctionTimerPaused = 0;
+ state.mut().auctionTimerPauseStartedAt.setInvalid();
+ state.mut().auctionTimerPauseEndsAt.setInvalid();
+ }
+
+ /**
+ * @brief Returns remaining launch-delay ticks after the current epoch begins.
+ */
+ PRIVATE_FUNCTION_WITH_LOCALS(GetTicksBeforeAuctionLaunchInternal)
+ {
+ output.ticks = 0;
+
+ // An unarmed delay has no remaining ticks even if the current tick is near the epoch boundary.
+ if (!state.get().isPostBeginEpochPauseArmed)
+ {
+ return;
+ }
+
+ output.ticks = static_cast(max(static_cast(NOST_AUCTION_POST_BEGIN_EPOCH_PAUSE_TICKS) -
+ (static_cast(qpi.tick()) - static_cast(qpi.initialTick())),
+ 0));
+ }
+
+ /**
+ * @brief Registers a QU obligation before the associated settlement becomes final.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(QueueQuPayout)
+ {
+ output.success = 0;
+ // Zero is an idempotent no-op, while a non-zero obligation must always have a payable recipient.
+ if (input.amount == 0 || isZero(input.recipient))
+ {
+ output.success = input.amount == 0;
+ return;
+ }
+
+ locals.previousAmount = 0;
+ // Reject aggregate overflow before touching either the per-wallet entry or its mirrored total.
+ if (input.amount > UINT64_MAX - state.get().totalPendingQuPayouts)
+ {
+ return;
+ }
+
+ // Multiple settlements for one wallet share one liability entry to conserve bounded map capacity.
+ if (state.get().pendingQuPayouts.get(input.recipient, locals.previousAmount))
+ {
+ // The wallet-level value must remain exactly reconcilable with totalPendingQuPayouts.
+ if (input.amount > UINT64_MAX - locals.previousAmount)
+ {
+ return;
+ }
+
+ locals.updatedAmount = sadd(locals.previousAmount, input.amount);
+ if (!state.mut().pendingQuPayouts.replace(input.recipient, locals.updatedAmount))
+ {
+ return;
+ }
+ }
+ else
+ {
+ // First-time recipients consume a new map slot; failure leaves the global liability total unchanged.
+ locals.payoutIndex = state.mut().pendingQuPayouts.set(input.recipient, input.amount);
+ if (locals.payoutIndex == NULL_INDEX)
+ {
+ return;
+ }
+ }
+
+ state.mut().totalPendingQuPayouts = sadd(state.get().totalPendingQuPayouts, input.amount);
+ output.success = 1;
+ }
+
+ /**
+ * @brief Pays a bounded number of chunks and preserves every unpaid remainder in state.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(FlushQuPayout)
+ {
+ output.success = 0;
+ output.transferredAmount = 0;
+ output.remainingAmount = 0;
+ // Absence is distinct from a paid zero balance because zero-balance entries are removed immediately.
+ if (!state.get().pendingQuPayouts.get(input.recipient, output.remainingAmount))
+ {
+ return;
+ }
+
+ locals.chunkIndex = 0;
+ // Bound both transfer size and iteration count so one payout attempt cannot exhaust contract execution time.
+ while (output.remainingAmount > 0 && locals.chunkIndex < input.maxChunks)
+ {
+ locals.chunkAmount = min(output.remainingAmount, static_cast(MAX_AMOUNT));
+ locals.transferResult = qpi.transfer(input.recipient, static_cast(locals.chunkAmount));
+ // A failed transfer stops delivery without decrementing the durable obligation.
+ if (locals.transferResult < 0)
+ {
+ break;
+ }
+ output.remainingAmount -= locals.chunkAmount;
+ output.transferredAmount = sadd(output.transferredAmount, locals.chunkAmount);
+ state.mut().totalPendingQuPayouts -= locals.chunkAmount;
+ ++locals.chunkIndex;
+ }
+
+ // Fully discharged entries release map capacity; partial delivery persists the exact remainder for retry.
+ if (output.remainingAmount == 0)
+ {
+ state.mut().pendingQuPayouts.removeByKey(input.recipient);
+ }
+ else
+ {
+ state.mut().pendingQuPayouts.replace(input.recipient, output.remainingAmount);
+ }
+ output.success = 1;
+ }
+
+ /**
+ * @brief Retries a bounded set of pending QU payouts and advances the persistent round-robin cursor.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(ProcessPendingQuPayouts)
+ {
+ locals.payoutScanIndex = mod(state.get().pendingPayoutScanCursor, state.get().pendingQuPayouts.capacity());
+ locals.payoutTargetRecipientCount = min(state.get().pendingQuPayouts.population(), NOST_END_EPOCH_PAYOUT_RECIPIENT_NUM);
+ locals.processedPayoutRecipientCount = 0;
+ locals.payoutElementIndex = state.get().pendingQuPayouts.nextElementIndex(static_cast(locals.payoutScanIndex) - 1);
+ // Round-robin scanning bounds epoch work and prevents a permanently failing wallet from starving later map slots.
+ while (locals.processedPayoutRecipientCount < locals.payoutTargetRecipientCount)
+ {
+ // Wrap once the physical end is reached; the initial population snapshot prevents duplicate processing.
+ if (locals.payoutElementIndex == NULL_INDEX)
+ {
+ locals.payoutElementIndex = state.get().pendingQuPayouts.nextElementIndex(NULL_INDEX);
+ if (locals.payoutElementIndex == NULL_INDEX)
+ {
+ break;
+ }
+ }
+ locals.pendingPayoutRecipient = state.get().pendingQuPayouts.key(locals.payoutElementIndex);
+ locals.payoutScanIndex = mod(sadd(static_cast(locals.payoutElementIndex), 1ULL), state.get().pendingQuPayouts.capacity());
+ locals.flushQuPayoutInput.recipient = locals.pendingPayoutRecipient;
+ locals.flushQuPayoutInput.maxChunks = NOST_END_EPOCH_PAYOUT_CHUNKS_PER_RECIPIENT;
+ CALL(FlushQuPayout, locals.flushQuPayoutInput, locals.flushQuPayoutOutput);
+ locals.processedPayoutRecipientCount = sadd(locals.processedPayoutRecipientCount, 1ULL);
+ locals.payoutElementIndex = state.get().pendingQuPayouts.nextElementIndex(locals.payoutElementIndex);
+ }
+ state.mut().pendingPayoutScanCursor = locals.payoutScanIndex;
+ }
+
+ /**
+ * @brief Registers a payout exactly once for this call and immediately attempts bounded delivery.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(QueueAndFlushQuPayout)
+ {
+ output.success = 0;
+ output.transferredAmount = 0;
+ output.remainingAmount = 0;
+ locals.queueQuPayoutInput.recipient = input.recipient;
+ locals.queueQuPayoutInput.amount = input.amount;
+ CALL(QueueQuPayout, locals.queueQuPayoutInput, locals.queueQuPayoutOutput);
+ // Never attempt delivery unless the complete liability was made durable first.
+ if (!locals.queueQuPayoutOutput.success)
+ {
+ return;
+ }
+ // QueueQuPayout treats zero as success, but there is no map entry for FlushQuPayout to consume.
+ if (input.amount == 0)
+ {
+ output.success = 1;
+ return;
+ }
+ locals.flushQuPayoutInput.recipient = input.recipient;
+ locals.flushQuPayoutInput.maxChunks = input.maxChunks;
+ CALL(FlushQuPayout, locals.flushQuPayoutInput, locals.flushQuPayoutOutput);
+ output.transferredAmount = locals.flushQuPayoutOutput.transferredAmount;
+ output.remainingAmount = locals.flushQuPayoutOutput.remainingAmount;
+ output.success = locals.flushQuPayoutOutput.success;
+ }
+
+ /**
+ * @brief Appends a participant snapshot to bounded history.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(ArchiveParticipant)
+ {
+ locals.historyIndex = mod(state.get().participantHistoryCounter, state.get().participantHistory.capacity());
+ state.mut().participantHistory.set(locals.historyIndex, input.participantData);
+ state.mut().participantHistoryCounter = sadd(state.get().participantHistoryCounter, 1ULL);
+ }
+
+ /**
+ * @brief Archives a closed auction and releases its active hash-map slot.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(ArchiveClosedAuction)
+ {
+ locals.historyIndex = mod(state.get().closedAuctionHistoryCounter, state.get().closedAuctionHistory.capacity());
+ state.mut().closedAuctionHistory.set(locals.historyIndex, input.auction);
+ state.mut().closedAuctionHistoryCounter = sadd(state.get().closedAuctionHistoryCounter, 1ULL);
+ state.mut().auctionList.removeByKey(input.auction.core.auctionIndex);
+ }
+
+ /**
+ * @brief Finds a live auction or a retained closed-auction snapshot.
+ */
+ PRIVATE_FUNCTION_WITH_LOCALS(FindAuction)
+ {
+ output.found = state.get().auctionList.get(input.auctionIndex, output.auction);
+ // Active storage is authoritative and avoids the bounded linear archive scan for live auctions.
+ if (output.found)
+ {
+ return;
+ }
+ // Closed auctions remain queryable only while their full snapshot is retained in the ring buffer.
+ for (locals.historyIndex = 0; locals.historyIndex < state.get().closedAuctionHistory.capacity(); ++locals.historyIndex)
+ {
+ locals.archivedAuction = state.get().closedAuctionHistory.get(locals.historyIndex);
+ if (locals.archivedAuction.core.status != EAuctionStatus::None && locals.archivedAuction.core.auctionIndex == input.auctionIndex)
+ {
+ output.auction = locals.archivedAuction;
+ output.found = 1;
+ return;
+ }
+ }
+ }
+
+ /**
+ * @brief Tests retained closed history without copying an auction into the caller's locals.
+ */
+ PRIVATE_FUNCTION_WITH_LOCALS(IsClosedAuctionRetained)
+ {
+ output.found = 0;
+ locals.retainedClosedAuctionCount = min(state.get().closedAuctionHistoryCounter, state.get().closedAuctionHistory.capacity());
+ // Only initialized ring-buffer entries can match; inspect the const snapshot in place to keep this lookup lightweight.
+ for (locals.historyIndex = 0; locals.historyIndex < locals.retainedClosedAuctionCount; ++locals.historyIndex)
+ {
+ if (state.get().closedAuctionHistory.get(locals.historyIndex).core.status != EAuctionStatus::None &&
+ state.get().closedAuctionHistory.get(locals.historyIndex).core.auctionIndex == input.auctionIndex)
+ {
+ output.found = 1;
+ return;
+ }
+ }
+ }
+
+ /**
+ * @brief Selects the smallest retained auction index after an optional cursor.
+ */
+ PRIVATE_FUNCTION_WITH_LOCALS(SelectNextRetainedAuction)
+ {
+ output.found = 0;
+ // Hash-map iteration is not creation ordered, so retain the smallest eligible live index beyond the cursor.
+ for (locals.auctionElementIndex = state.get().auctionList.nextElementIndex(NULL_INDEX); locals.auctionElementIndex != NULL_INDEX;
+ locals.auctionElementIndex = state.get().auctionList.nextElementIndex(locals.auctionElementIndex))
+ {
+ locals.candidateAuction = state.get().auctionList.value(locals.auctionElementIndex);
+ // Apply the cursor and optional seller filter before comparing creation indices.
+ if ((input.hasAfterAuctionIndex && locals.candidateAuction.core.auctionIndex <= input.afterAuctionIndex) ||
+ (input.filterBySeller && locals.candidateAuction.core.seller != input.seller))
+ {
+ continue;
+ }
+ if (!output.found || locals.candidateAuction.core.auctionIndex < output.auction.core.auctionIndex)
+ {
+ output.auction = locals.candidateAuction;
+ output.found = 1;
+ }
+ }
+ // Live-only callers avoid the archive scan entirely.
+ if (!input.includeClosedAuctions)
+ {
+ return;
+ }
+
+ locals.retainedClosedAuctionCount = min(state.get().closedAuctionHistoryCounter, state.get().closedAuctionHistory.capacity());
+ // Merge only retained closed snapshots without assuming physical ring order.
+ for (locals.historyIndex = 0; locals.historyIndex < locals.retainedClosedAuctionCount; ++locals.historyIndex)
+ {
+ locals.candidateAuction = state.get().closedAuctionHistory.get(locals.historyIndex);
+ // Apply the same cursor and seller filter to archived candidates.
+ if (locals.candidateAuction.core.status == EAuctionStatus::None ||
+ (input.hasAfterAuctionIndex && locals.candidateAuction.core.auctionIndex <= input.afterAuctionIndex) ||
+ (input.filterBySeller && locals.candidateAuction.core.seller != input.seller))
+ {
+ continue;
+ }
+ if (!output.found || locals.candidateAuction.core.auctionIndex < output.auction.core.auctionIndex)
+ {
+ output.auction = locals.candidateAuction;
+ output.found = 1;
+ }
+ }
+ }
+
+ /**
+ * @brief Counts retained live and closed auctions belonging to one seller without reconstructing creation order.
+ */
+ PRIVATE_FUNCTION_WITH_LOCALS(CountRetainedAuctionsBySeller)
+ {
+ output.count = 0;
+ // A physical live-map pass is sufficient because counting does not depend on creation order.
+ for (locals.auctionElementIndex = state.get().auctionList.nextElementIndex(NULL_INDEX); locals.auctionElementIndex != NULL_INDEX;
+ locals.auctionElementIndex = state.get().auctionList.nextElementIndex(locals.auctionElementIndex))
+ {
+ locals.candidateAuction = state.get().auctionList.value(locals.auctionElementIndex);
+ if (locals.candidateAuction.core.seller == input.seller)
+ {
+ output.count = sadd(output.count, 1ULL);
+ }
+ }
+
+ locals.retainedClosedAuctionCount = min(state.get().closedAuctionHistoryCounter, state.get().closedAuctionHistory.capacity());
+ // Only initialized ring slots can contribute to the retained seller count.
+ for (locals.historyIndex = 0; locals.historyIndex < locals.retainedClosedAuctionCount; ++locals.historyIndex)
+ {
+ locals.candidateAuction = state.get().closedAuctionHistory.get(locals.historyIndex);
+ if (locals.candidateAuction.core.status != EAuctionStatus::None && locals.candidateAuction.core.seller == input.seller)
+ {
+ output.count = sadd(output.count, 1ULL);
+ }
+ }
+ }
+
+ /**
+ * @brief Finds the smallest retained auction index whose complete fixed-size metadata CID matches the input.
+ */
+ PRIVATE_FUNCTION_WITH_LOCALS(FindFirstRetainedAuctionByMetadataCid)
+ {
+ output.found = 0;
+ // Select the minimum matching live index directly instead of repeatedly reconstructing global order.
+ for (locals.auctionElementIndex = state.get().auctionList.nextElementIndex(NULL_INDEX); locals.auctionElementIndex != NULL_INDEX;
+ locals.auctionElementIndex = state.get().auctionList.nextElementIndex(locals.auctionElementIndex))
+ {
+ locals.candidateAuction = state.get().auctionList.value(locals.auctionElementIndex);
+ locals.metadataMatches = 1;
+ // Compare the complete fixed CID field, including zero padding.
+ for (locals.metadataIndex = 0; locals.metadataIndex < NOST_AUCTION_METADATA_CID_LENGTH; ++locals.metadataIndex)
+ {
+ if (locals.candidateAuction.core.metadataIpfsCid.get(locals.metadataIndex) != input.metadataIpfsCid.get(locals.metadataIndex))
+ {
+ locals.metadataMatches = 0;
+ break;
+ }
+ }
+ if (locals.metadataMatches && (!output.found || locals.candidateAuction.core.auctionIndex < output.auction.core.auctionIndex))
+ {
+ output.auction = locals.candidateAuction;
+ output.found = 1;
+ }
+ }
+
+ locals.retainedClosedAuctionCount = min(state.get().closedAuctionHistoryCounter, state.get().closedAuctionHistory.capacity());
+ // Closed snapshots share the same index ordering but occupy unordered ring slots.
+ for (locals.historyIndex = 0; locals.historyIndex < locals.retainedClosedAuctionCount; ++locals.historyIndex)
+ {
+ locals.candidateAuction = state.get().closedAuctionHistory.get(locals.historyIndex);
+ if (locals.candidateAuction.core.status == EAuctionStatus::None)
+ {
+ continue;
+ }
+ locals.metadataMatches = 1;
+ // Compare the complete fixed CID field, including zero padding.
+ for (locals.metadataIndex = 0; locals.metadataIndex < NOST_AUCTION_METADATA_CID_LENGTH; ++locals.metadataIndex)
+ {
+ if (locals.candidateAuction.core.metadataIpfsCid.get(locals.metadataIndex) != input.metadataIpfsCid.get(locals.metadataIndex))
+ {
+ locals.metadataMatches = 0;
+ break;
+ }
+ }
+ if (locals.metadataMatches && (!output.found || locals.candidateAuction.core.auctionIndex < output.auction.core.auctionIndex))
+ {
+ output.auction = locals.candidateAuction;
+ output.found = 1;
+ }
+ }
+ }
+
+ /**
+ * @brief Pays auction sale proceeds to the seller and records every fee for end-of-epoch settlement.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(DistributeAuctionRevenue)
+ {
+ output.sellerPayout = input.grossAmount;
+ output.success = 0;
+
+ // Zero-gross settlements still report success so callers can close no-sale auctions cleanly.
+ if (input.grossAmount == 0)
+ {
+ output.success = 1;
+ return;
+ }
+ // Only the seller is queued during settlement; fee recipients are handled by END_EPOCH.
+ if (state.get().pendingQuPayouts.population() > state.get().pendingQuPayouts.capacity() - NOST_AUCTION_REVENUE_MAX_PAYOUT_RECIPIENTS)
+ {
+ return;
+ }
+
+ calculateAuctionRevenueBreakdown(input.grossAmount, state, locals.auctionRevenueBreakdown);
+ output.sellerPayout = locals.auctionRevenueBreakdown.sellerPayout;
+
+ // Register the seller liability before recording fees so a queue-capacity failure cannot duplicate fee accrual on retry.
+ locals.payoutInput.recipient = input.seller;
+ locals.payoutInput.amount = output.sellerPayout;
+ locals.payoutInput.maxChunks = NOST_MAX_QU_TRANSFER_CHUNKS_PER_CALL;
+ CALL(QueueAndFlushQuPayout, locals.payoutInput, locals.payoutOutput);
+ if (!locals.payoutOutput.success)
+ {
+ return;
+ }
+
+ locals.feePool = state.get().feePool;
+ // The routing decision and fee configuration are captured when revenue is settled; recipient wallets are resolved at END_EPOCH.
+ if (routeAllFeesToDevelopment(state))
+ {
+ locals.feePool.developmentAmount = sadd(locals.feePool.developmentAmount, input.grossAmount - output.sellerPayout);
+ }
+ else
+ {
+ locals.shareholderFeeTierIndex = getAuctionShareholderFeeTierIndex(input.grossAmount);
+ switch (locals.shareholderFeeTierIndex)
+ {
+ case 0:
+ locals.feePool.shareholderDividendTier1Amount =
+ sadd(locals.feePool.shareholderDividendTier1Amount, locals.auctionRevenueBreakdown.shareholderDividendAmount);
+ break;
+ case 1:
+ locals.feePool.shareholderDividendTier2Amount =
+ sadd(locals.feePool.shareholderDividendTier2Amount, locals.auctionRevenueBreakdown.shareholderDividendAmount);
+ break;
+ case 2:
+ locals.feePool.shareholderDividendTier3Amount =
+ sadd(locals.feePool.shareholderDividendTier3Amount, locals.auctionRevenueBreakdown.shareholderDividendAmount);
+ break;
+ default:
+ locals.feePool.shareholderDividendTier4Amount =
+ sadd(locals.feePool.shareholderDividendTier4Amount, locals.auctionRevenueBreakdown.shareholderDividendAmount);
+ break;
+ }
+
+ locals.feePool.managementAmount = sadd(locals.feePool.managementAmount, locals.auctionRevenueBreakdown.managementFeeAmount);
+ locals.feePool.developmentAmount = sadd(locals.feePool.developmentAmount, locals.auctionRevenueBreakdown.developmentFeeAmount);
+ locals.feePool.takeoverCoordinatorAmount =
+ sadd(locals.feePool.takeoverCoordinatorAmount, locals.auctionRevenueBreakdown.takeoverCoordinatorFeeAmount);
+ }
+
+ state.mut().feePool = locals.feePool;
+ output.success = 1;
+ }
+
+ /**
+ * @brief Accumulates a service fee using the routing mode active when the fee is charged.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(AccumulateAuctionServiceFee)
+ {
+ output.success = 0;
+
+ // Creation, bidding, and cancellation paths may call this with zero after fee configuration changes.
+ if (input.feeAmount == 0)
+ {
+ output.success = 1;
+ return;
+ }
+
+ locals.feePool = state.get().feePool;
+ if (routeAllFeesToDevelopment(state))
+ {
+ locals.feePool.developmentAmount = sadd(locals.feePool.developmentAmount, input.feeAmount);
+ }
+ else
+ {
+ locals.feePool.commonServiceFeeAmount = sadd(locals.feePool.commonServiceFeeAmount, input.feeAmount);
+ }
+ state.mut().feePool = locals.feePool;
+ output.success = 1;
+ }
+
+ /**
+ * @brief Materializes compatible service fees and settles every shared pool accumulator using the recipients active at `END_EPOCH`.
+ * @note Each accumulator is cleared only after its value has moved to dividend dust or a durable payout liability.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(DistributeNostromoFeePool)
+ {
+ output.success = 0;
+ locals.feePool = state.get().feePool;
+
+ if (locals.feePool.commonServiceFeeAmount > 0)
+ {
+ calculateAuctionServiceFeeBreakdown(locals.feePool.commonServiceFeeAmount, locals.auctionServiceFeeBreakdown);
+ locals.feePool.shareholderDividendAmount =
+ sadd(locals.feePool.shareholderDividendAmount, locals.auctionServiceFeeBreakdown.shareholderDividendAmount);
+ locals.feePool.managementAmount = sadd(locals.feePool.managementAmount, locals.auctionServiceFeeBreakdown.managementFeeAmount);
+ locals.feePool.developmentAmount = sadd(locals.feePool.developmentAmount, locals.auctionServiceFeeBreakdown.developmentFeeAmount);
+ locals.feePool.takeoverCoordinatorAmount =
+ sadd(locals.feePool.takeoverCoordinatorAmount, locals.auctionServiceFeeBreakdown.takeoverCoordinatorFeeAmount);
+ locals.feePool.commonServiceFeeAmount = 0;
+ state.mut().feePool = locals.feePool;
+ }
+
+ locals.shareholderDividendAmount =
+ sadd(sadd(sadd(locals.feePool.shareholderDividendTier1Amount, locals.feePool.shareholderDividendTier2Amount),
+ sadd(locals.feePool.shareholderDividendTier3Amount, locals.feePool.shareholderDividendTier4Amount)),
+ locals.feePool.shareholderDividendAmount);
+ if (locals.shareholderDividendAmount > 0)
+ {
+ state.mut().auctionShareholderDividendPool = sadd(state.get().auctionShareholderDividendPool, locals.shareholderDividendAmount);
+ locals.feePool.shareholderDividendTier1Amount = 0;
+ locals.feePool.shareholderDividendTier2Amount = 0;
+ locals.feePool.shareholderDividendTier3Amount = 0;
+ locals.feePool.shareholderDividendTier4Amount = 0;
+ locals.feePool.shareholderDividendAmount = 0;
+ state.mut().feePool = locals.feePool;
+ }
+
+ locals.dividendPerShare = div(state.get().auctionShareholderDividendPool, NUMBER_OF_COMPUTORS);
+ if (locals.dividendPerShare > 0 && qpi.distributeDividends(locals.dividendPerShare))
+ {
+ locals.distributedDividendAmount = smul(locals.dividendPerShare, static_cast(NUMBER_OF_COMPUTORS));
+ state.mut().auctionShareholderDividendPool -= locals.distributedDividendAmount;
+ }
+
+ if (state.get().feePool.managementAmount > 0)
+ {
+ locals.payoutInput.recipient = state.get().management;
+ locals.payoutInput.amount = state.get().feePool.managementAmount;
+ locals.payoutInput.maxChunks = NOST_MAX_QU_TRANSFER_CHUNKS_PER_CALL;
+ CALL(QueueAndFlushQuPayout, locals.payoutInput, locals.payoutOutput);
+ if (!locals.payoutOutput.success)
+ {
+ return;
+ }
+ state.mut().feePool.managementAmount = 0;
+ }
+ if (state.get().feePool.developmentAmount > 0)
+ {
+ locals.payoutInput.recipient = state.get().development;
+ locals.payoutInput.amount = state.get().feePool.developmentAmount;
+ locals.payoutInput.maxChunks = NOST_MAX_QU_TRANSFER_CHUNKS_PER_CALL;
+ CALL(QueueAndFlushQuPayout, locals.payoutInput, locals.payoutOutput);
+ if (!locals.payoutOutput.success)
+ {
+ return;
+ }
+ state.mut().feePool.developmentAmount = 0;
+ }
+ if (state.get().feePool.takeoverCoordinatorAmount > 0)
+ {
+ locals.payoutInput.recipient = state.get().takeoverCoordinator;
+ locals.payoutInput.amount = state.get().feePool.takeoverCoordinatorAmount;
+ locals.payoutInput.maxChunks = NOST_MAX_QU_TRANSFER_CHUNKS_PER_CALL;
+ CALL(QueueAndFlushQuPayout, locals.payoutInput, locals.payoutOutput);
+ if (!locals.payoutOutput.success)
+ {
+ return;
+ }
+ state.mut().feePool.takeoverCoordinatorAmount = 0;
+ }
+
+ output.success = 1;
+ }
+
+ /**
+ * @brief Counts non-empty wallet entries allowed to bid in a private auction.
+ */
+ PRIVATE_FUNCTION_WITH_LOCALS(CountAllowedBidderWallets)
+ {
+ output.allowedWalletCount = 0;
+ for (locals.allowedWalletIndex = 0; locals.allowedWalletIndex < input.allowedBidderWallets.capacity(); ++locals.allowedWalletIndex)
+ {
+ if (!isZero(input.allowedBidderWallets.get(locals.allowedWalletIndex)))
+ {
+ output.allowedWalletCount = sadd(output.allowedWalletCount, 1ULL);
+ }
+ }
+ }
+
+ /**
+ * @brief Counts valid access-asset requirements for private auction gating.
+ */
+ PRIVATE_FUNCTION_WITH_LOCALS(CountRequiredAccessAssets)
+ {
+ output.requiredAccessAssetCount = 0;
+ output.isValid = 1;
+ // Empty asset slots are allowed only when their quantity is also empty.
+ for (locals.requiredAccessAssetIndex = 0; locals.requiredAccessAssetIndex < input.requiredAccessAssets.capacity();
+ ++locals.requiredAccessAssetIndex)
+ {
+ locals.requiredAccessAsset = input.requiredAccessAssets.get(locals.requiredAccessAssetIndex);
+ if (isZeroAsset(locals.requiredAccessAsset.asset))
+ {
+ if (locals.requiredAccessAsset.quantity != 0)
+ {
+ output.isValid = 0;
+ return;
+ }
+ continue;
+ }
+
+ if (locals.requiredAccessAsset.quantity <= 0)
+ {
+ output.isValid = 0;
+ return;
+ }
+
+ output.requiredAccessAssetCount = sadd(output.requiredAccessAssetCount, 1ULL);
+ }
+ }
+
+ /**
+ * @brief Checks whether the invocator owns at least one configured access asset.
+ */
+ PRIVATE_FUNCTION_WITH_LOCALS(HasRequiredAccessAsset)
+ {
+ output.hasRequiredAccessAsset = 0;
+ if (!state.get().auctionList.get(input.auctionIndex, locals.auction))
+ {
+ return;
+ }
+
+ // Owning any one configured access asset at the required quantity grants private auction access.
+ for (locals.requiredAccessAssetSetIndex = locals.auction.requiredAccessAssets.nextElementIndex(NULL_INDEX);
+ locals.requiredAccessAssetSetIndex != NULL_INDEX;
+ locals.requiredAccessAssetSetIndex = locals.auction.requiredAccessAssets.nextElementIndex(locals.requiredAccessAssetSetIndex))
+ {
+ locals.requiredAccessAsset.asset = locals.auction.requiredAccessAssets.key(locals.requiredAccessAssetSetIndex);
+ locals.requiredAccessAsset.quantity = locals.auction.requiredAccessAssets.value(locals.requiredAccessAssetSetIndex);
+ locals.possessedAccessShares = qpi.numberOfShares(locals.requiredAccessAsset.asset, AssetOwnershipSelect::byOwner(qpi.invocator()),
+ AssetPossessionSelect::byPossessor(qpi.invocator()));
+ if (locals.possessedAccessShares >= locals.requiredAccessAsset.quantity)
+ {
+ output.hasRequiredAccessAsset = 1;
+ return;
+ }
+ }
+ }
+
+ /**
+ * @brief Recomputes the displayed highest active Batch Auction bid.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(RecomputeBatchHighestBid)
+ {
+ locals.bestParticipantFound = 0;
+
+ if (!state.get().auctionList.get(input.auctionIndex, locals.auction))
+ {
+ return;
+ }
+
+ if (locals.auction.core.type != EAuctionType::Batch)
+ {
+ return;
+ }
+
+ // Batch auctions expose the highest active price, with FIFO tie-breaking for equal bids.
+ for (locals.participantIndex = 0; locals.participantIndex < state.get().participants.capacity(); ++locals.participantIndex)
+ {
+ locals.participantData = state.get().participants.get(locals.participantIndex);
+ if (!locals.participantData.isUsed || locals.participantData.auctionIndex != input.auctionIndex)
+ {
+ continue;
+ }
+
+ if (!locals.participantData.isActive || locals.participantData.escrowedAmount == 0)
+ {
+ continue;
+ }
+
+ if (!locals.bestParticipantFound || locals.participantData.bidAmount > locals.bestParticipantData.bidAmount ||
+ (locals.participantData.bidAmount == locals.bestParticipantData.bidAmount &&
+ locals.participantData.bidIndex < locals.bestParticipantData.bidIndex))
+ {
+ locals.bestParticipantFound = 1;
+ locals.bestParticipantData = locals.participantData;
+ locals.bestParticipantSlotIndex = locals.participantIndex;
+ }
+ }
+
+ if (locals.bestParticipantFound)
+ {
+ locals.auction.core.highestBidder = locals.bestParticipantData.participant;
+ locals.auction.core.highestBidPrice = locals.bestParticipantData.bidAmount;
+ locals.auction.core.highestBidQuantity = locals.bestParticipantData.requestedQuantity;
+ locals.auction.core.highestBidAmount = locals.bestParticipantData.escrowedAmount;
+ locals.auction.core.highestBidSlotIndex = locals.bestParticipantSlotIndex;
+ }
+ else
+ {
+ locals.auction.core.highestBidAmount = 0;
+ locals.auction.core.highestBidPrice = 0;
+ locals.auction.core.highestBidQuantity = 0;
+ locals.auction.core.highestBidder = NULL_ID;
+ locals.auction.core.highestBidSlotIndex = NOST_INVALID_PARTICIPANT_SLOT;
+ }
+
+ state.mut().auctionList.replace(locals.auction.core.auctionIndex, locals.auction);
+ }
+
+ /**
+ * @brief Computes the price and quantity still available for a Batch Auction bid.
+ */
+ PRIVATE_FUNCTION_WITH_LOCALS(ComputeBatchBidAvailability)
+ {
+ output.found = 0;
+ output.isAcceptingBids = 0;
+ output.minimumBidPrice = 0;
+ output.availableQuantity = 0;
+ locals.lowestWinningPriceFound = 0;
+ locals.lowestWinningPrice = 0;
+ locals.salePriorityQuantity = 0;
+ locals.priorityQuantity = 0;
+
+ // Availability is defined only for a retained live auction; closed snapshots never accept bids.
+ if (!state.get().auctionList.get(input.auctionIndex, locals.auction))
+ {
+ return;
+ }
+
+ output.found = 1;
+ if (locals.auction.core.type != EAuctionType::Batch || locals.auction.core.status != EAuctionStatus::Active ||
+ locals.auction.core.quantityForSale < locals.auction.core.minimumPurchaseQuantity)
+ {
+ return;
+ }
+
+ // Existing sale-price-or-better bids reserve priority quantity before a new bid can enter.
+ for (locals.participantIndex = 0; locals.participantIndex < state.get().participants.capacity(); ++locals.participantIndex)
+ {
+ locals.participantData = state.get().participants.get(locals.participantIndex);
+ if (!locals.participantData.isUsed || locals.participantData.auctionIndex != input.auctionIndex)
+ {
+ continue;
+ }
+
+ if (!locals.participantData.isActive || locals.participantData.escrowedAmount == 0 || locals.participantData.requestedQuantity == 0)
+ {
+ continue;
+ }
+
+ if (!locals.lowestWinningPriceFound || locals.participantData.bidAmount < locals.lowestWinningPrice)
+ {
+ locals.lowestWinningPriceFound = 1;
+ locals.lowestWinningPrice = locals.participantData.bidAmount;
+ }
+
+ if (locals.participantData.bidAmount >= locals.auction.core.salePrice)
+ {
+ locals.salePriorityQuantity = sadd(locals.salePriorityQuantity, locals.participantData.requestedQuantity);
+ }
+ }
+
+ locals.effectiveCoverageQuantity =
+ locals.auction.core.quantityForSale - locals.auction.core.minimumPurchaseQuantity + NOST_BATCH_COVERAGE_THRESHOLD_OFFSET;
+ // Once less than one minimum allocation remains, report no sale-price capacity instead of an unusable fragment.
+ if (locals.salePriorityQuantity >= locals.effectiveCoverageQuantity)
+ {
+ output.availableQuantity = 0;
+ }
+ else
+ {
+ // Otherwise expose the full unreserved quantity; the minimum check below decides whether bidding remains viable.
+ output.availableQuantity = locals.auction.core.quantityForSale - locals.salePriorityQuantity;
+ }
+
+ // If sale-price capacity is exhausted, new bids must improve the current lowest winning price.
+ if (output.availableQuantity >= locals.auction.core.minimumPurchaseQuantity)
+ {
+ output.minimumBidPrice = locals.auction.core.salePrice;
+ output.isAcceptingBids = 1;
+ }
+ else
+ {
+ // A full book can still accept a strictly better bid that displaces the current lowest-priced allocation.
+ output.availableQuantity = 0;
+ if (!locals.lowestWinningPriceFound || locals.lowestWinningPrice == UINT64_MAX)
+ {
+ return;
+ }
+
+ output.minimumBidPrice = sadd(locals.lowestWinningPrice, 1ULL);
+ output.isAcceptingBids = 1;
+ if (input.bidAmount == 0)
+ {
+ return;
+ }
+ }
+
+ locals.outputPrice = input.bidAmount > 0 ? input.bidAmount : output.minimumBidPrice;
+ if (locals.outputPrice < output.minimumBidPrice)
+ {
+ output.availableQuantity = 0;
+ return;
+ }
+
+ // Recompute capacity at the requested price so callers know the maximum acceptable quantity.
+ locals.priorityQuantity = 0;
+ for (locals.participantIndex = 0; locals.participantIndex < state.get().participants.capacity(); ++locals.participantIndex)
+ {
+ locals.participantData = state.get().participants.get(locals.participantIndex);
+ if (!locals.participantData.isUsed || locals.participantData.auctionIndex != input.auctionIndex)
+ {
+ continue;
+ }
+
+ if (!locals.participantData.isActive || locals.participantData.escrowedAmount == 0 || locals.participantData.requestedQuantity == 0)
+ {
+ continue;
+ }
+
+ if (locals.participantData.bidAmount > locals.outputPrice || locals.participantData.bidAmount == locals.outputPrice)
+ {
+ locals.priorityQuantity = sadd(locals.priorityQuantity, locals.participantData.requestedQuantity);
+ }
+ }
+
+ // Equal-priced existing bids have FIFO priority, so a candidate at that price receives only later capacity.
+ if (locals.priorityQuantity >= locals.auction.core.quantityForSale)
+ {
+ output.availableQuantity = 0;
+ return;
+ }
+
+ output.availableQuantity = locals.auction.core.quantityForSale - locals.priorityQuantity;
+ }
+
+ /**
+ * @brief Validates, escrows, and ranks a new Batch Auction bid.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(ProcessBatchBid)
+ {
+ output.escrowedAmount = 0;
+ output.refundedAmount = 0;
+ output.errorCode = EAuctionError::Success;
+ output.success = 0;
+ if (!state.get().auctionList.get(input.auctionIndex, locals.auction))
+ {
+ output.refundedAmount = static_cast(qpi.invocationReward());
+ output.errorCode = EAuctionError::AuctionNotFound;
+ return;
+ }
+
+ if (input.effectiveQuantity < locals.auction.core.minimumPurchaseQuantity || input.bidAmount == 0)
+ {
+ output.refundedAmount = static_cast(qpi.invocationReward());
+ output.errorCode = EAuctionError::InvalidInput;
+ return;
+ }
+ // Retain enough payout slots to refund every active participant plus the caller's possible overpayment.
+ if (state.get().pendingQuPayouts.population() >
+ state.get().pendingQuPayouts.capacity() - state.get().participants.capacity() - NOST_BATCH_BID_CALLER_PAYOUT_RECIPIENTS)
+ {
+ output.refundedAmount = static_cast(qpi.invocationReward());
+ output.errorCode = EAuctionError::PayoutQueueFull;
+ return;
+ }
+
+ calculateBatchAuctionBidFee(input.effectiveQuantity, input.bidAmount, locals.bidFeeCalculation);
+ if (locals.bidFeeCalculation.escrowAmount == 0)
+ {
+ output.refundedAmount = static_cast(qpi.invocationReward());
+ output.errorCode = EAuctionError::InvalidInput;
+ return;
+ }
+
+ if (input.bidAmount < locals.auction.core.salePrice)
+ {
+ output.refundedAmount = static_cast(qpi.invocationReward());
+ output.errorCode = EAuctionError::BidTooLow;
+ return;
+ }
+
+ locals.computeBatchBidAvailabilityInput.auctionIndex = input.auctionIndex;
+ locals.computeBatchBidAvailabilityInput.bidAmount = input.bidAmount;
+ CALL(ComputeBatchBidAvailability, locals.computeBatchBidAvailabilityInput, locals.computeBatchBidAvailabilityOutput);
+ if (!locals.computeBatchBidAvailabilityOutput.isAcceptingBids || input.bidAmount < locals.computeBatchBidAvailabilityOutput.minimumBidPrice)
+ {
+ output.refundedAmount = static_cast(qpi.invocationReward());
+ output.errorCode = EAuctionError::BidTooLow;
+ return;
+ }
+ if (input.effectiveQuantity > locals.computeBatchBidAvailabilityOutput.availableQuantity)
+ {
+ output.refundedAmount = static_cast(qpi.invocationReward());
+ output.errorCode = EAuctionError::QuantityUnavailable;
+ return;
+ }
+
+ if (static_cast(qpi.invocationReward()) < locals.bidFeeCalculation.requiredReward)
+ {
+ output.refundedAmount = static_cast(qpi.invocationReward());
+ output.errorCode = EAuctionError::InsufficientFunds;
+ return;
+ }
+
+ // Batch bids consume live slots only; displaced and settled records move to the history ring.
+ locals.freeParticipantSlotFound = 0;
+ for (locals.participantIndex = 0; locals.participantIndex < state.get().participants.capacity(); ++locals.participantIndex)
+ {
+ locals.participantData = state.get().participants.get(locals.participantIndex);
+ if (!locals.participantData.isUsed)
+ {
+ locals.freeParticipantSlotFound = 1;
+ locals.freeParticipantSlotIndex = locals.participantIndex;
+ break;
+ }
+ }
+
+ if (!locals.freeParticipantSlotFound || locals.auction.core.nextBidIndex == UINT64_MAX)
+ {
+ output.refundedAmount = static_cast(qpi.invocationReward());
+ output.errorCode = EAuctionError::StorageFull;
+ return;
+ }
+
+ locals.participantData.escrowedAmount = locals.bidFeeCalculation.escrowAmount;
+ locals.participantData.requestedQuantity = input.effectiveQuantity;
+ locals.participantData.allocatedQuantity = 0;
+ locals.participantData.bidAmount = input.bidAmount;
+ locals.participantData.lastBidTime = input.currentDate;
+ locals.participantData.participant = qpi.invocator();
+ locals.participantData.auctionIndex = input.auctionIndex;
+ locals.participantData.bidIndex = locals.auction.core.nextBidIndex;
+ locals.participantData.isUsed = 1;
+ locals.participantData.isActive = 1;
+ locals.participantData.isWinningBid = 1;
+
+ // Accepted bids near deadline extend the auction to reduce last-moment sniping.
+ locals.auction.core.lastBidAt = input.currentDate;
+ if ((locals.auction.core.auctionDurationSeconds - input.elapsedSeconds) <= NOST_AUCTION_EXTENSION_SECONDS)
+ {
+ locals.auction.core.auctionDurationSeconds = sadd(locals.auction.core.auctionDurationSeconds, NOST_AUCTION_EXTENSION_SECONDS);
+ }
+
+ locals.auction.core.nextBidIndex = sadd(locals.auction.core.nextBidIndex, 1ULL);
+ state.mut().participants.set(locals.freeParticipantSlotIndex, locals.participantData);
+ state.mut().auctionList.replace(input.auctionIndex, locals.auction);
+
+ // Keep only the highest-priority quantity active; displaced escrow is refunded immediately.
+ locals.activeQuantity = 0;
+ for (locals.participantIndex = 0; locals.participantIndex < state.get().participants.capacity(); ++locals.participantIndex)
+ {
+ locals.participantData = state.get().participants.get(locals.participantIndex);
+ if (!locals.participantData.isUsed || locals.participantData.auctionIndex != input.auctionIndex)
+ {
+ continue;
+ }
+ if (locals.participantData.isActive && locals.participantData.escrowedAmount > 0 && locals.participantData.requestedQuantity > 0)
+ {
+ locals.activeQuantity = sadd(locals.activeQuantity, locals.participantData.requestedQuantity);
+ }
+ }
+
+ // Repeatedly evict the lowest-priority tail until active demand fits the finite lot supply.
+ while (locals.activeQuantity > locals.auction.core.quantityForSale)
+ {
+ locals.worstParticipantFound = 0;
+ // Lowest price loses first; for equal prices the newest bid loses to preserve FIFO priority.
+ for (locals.participantIndex = 0; locals.participantIndex < state.get().participants.capacity(); ++locals.participantIndex)
+ {
+ locals.participantData = state.get().participants.get(locals.participantIndex);
+ if (!locals.participantData.isUsed || locals.participantData.auctionIndex != input.auctionIndex)
+ {
+ continue;
+ }
+
+ if (!locals.participantData.isActive || locals.participantData.escrowedAmount == 0 || locals.participantData.requestedQuantity == 0)
+ {
+ continue;
+ }
+
+ if (!locals.worstParticipantFound || locals.participantData.bidAmount < locals.worstParticipantData.bidAmount ||
+ (locals.participantData.bidAmount == locals.worstParticipantData.bidAmount &&
+ locals.participantData.bidIndex > locals.worstParticipantData.bidIndex))
+ {
+ locals.worstParticipantFound = 1;
+ locals.worstParticipantData = locals.participantData;
+ locals.worstParticipantSlotIndex = locals.participantIndex;
+ }
+ }
+
+ if (!locals.worstParticipantFound)
+ {
+ break;
+ }
+
+ locals.excessQuantity = locals.activeQuantity - locals.auction.core.quantityForSale;
+ locals.displacedQuantity = min(locals.excessQuantity, locals.worstParticipantData.requestedQuantity);
+ locals.displacedRefund = smul(locals.displacedQuantity, locals.worstParticipantData.bidAmount);
+ locals.remainingWorstQuantity = locals.worstParticipantData.requestedQuantity - locals.displacedQuantity;
+ // A partial order smaller than the minimum is removed in full; keeping it would create an invalid final allocation.
+ if (locals.remainingWorstQuantity > 0 && locals.remainingWorstQuantity < locals.auction.core.minimumPurchaseQuantity)
+ {
+ locals.displacedQuantity = locals.worstParticipantData.requestedQuantity;
+ locals.displacedRefund = locals.worstParticipantData.escrowedAmount;
+ }
+ // Full displacement retires the live slot; partial displacement keeps a valid minimum-sized order active.
+ if (locals.displacedQuantity >= locals.worstParticipantData.requestedQuantity)
+ {
+ locals.worstParticipantData.escrowedAmount = 0;
+ locals.worstParticipantData.requestedQuantity = 0;
+ locals.worstParticipantData.allocatedQuantity = 0;
+ locals.worstParticipantData.isActive = 0;
+ locals.worstParticipantData.isWinningBid = 0;
+ }
+ else
+ {
+ locals.worstParticipantData.requestedQuantity -= locals.displacedQuantity;
+ locals.worstParticipantData.escrowedAmount -= locals.displacedRefund;
+ locals.worstParticipantData.isWinningBid = 1;
+ }
+
+ if (locals.displacedRefund > 0)
+ {
+ locals.payoutInput.recipient = locals.worstParticipantData.participant;
+ locals.payoutInput.amount = locals.displacedRefund;
+ locals.payoutInput.maxChunks = NOST_IMMEDIATE_QU_TRANSFER_CHUNKS_PER_CALL;
+ CALL(QueueAndFlushQuPayout, locals.payoutInput, locals.payoutOutput);
+ output.refundedAmount = sadd(output.refundedAmount, locals.displacedRefund);
+ }
+ locals.activeQuantity -= locals.displacedQuantity;
+ // Archive only retired orders; partially displaced orders remain in the live priority book.
+ if (!locals.worstParticipantData.isActive)
+ {
+ locals.archiveParticipantInput.participantData = locals.worstParticipantData;
+ CALL(ArchiveParticipant, locals.archiveParticipantInput, locals.archiveParticipantOutput);
+ locals.worstParticipantData = {};
+ }
+ state.mut().participants.set(locals.worstParticipantSlotIndex, locals.worstParticipantData);
+ }
+
+ locals.recomputeBatchHighestBidInput.auctionIndex = input.auctionIndex;
+ CALL(RecomputeBatchHighestBid, locals.recomputeBatchHighestBidInput, locals.recomputeBatchHighestBidOutput);
+
+ // Small-bid service fees are retained even if the bid is later displaced.
+ if (locals.bidFeeCalculation.fee > 0)
+ {
+ locals.accumulateAuctionServiceFeeInput.feeAmount = locals.bidFeeCalculation.fee;
+ CALL(AccumulateAuctionServiceFee, locals.accumulateAuctionServiceFeeInput, locals.accumulateAuctionServiceFeeOutput);
+ }
+
+ if (static_cast(qpi.invocationReward()) > locals.bidFeeCalculation.requiredReward)
+ {
+ locals.payoutInput.recipient = qpi.invocator();
+ locals.payoutInput.amount = static_cast(qpi.invocationReward()) - locals.bidFeeCalculation.requiredReward;
+ locals.payoutInput.maxChunks = NOST_IMMEDIATE_QU_TRANSFER_CHUNKS_PER_CALL;
+ CALL(QueueAndFlushQuPayout, locals.payoutInput, locals.payoutOutput);
+ output.refundedAmount =
+ sadd(output.refundedAmount, static_cast(qpi.invocationReward()) - locals.bidFeeCalculation.requiredReward);
+ }
+
+ output.escrowedAmount = locals.bidFeeCalculation.escrowAmount;
+ output.success = 1;
+ }
+
+ /**
+ * @brief Validates and records a Standard Auction bid, refunding replaced escrow.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(ProcessStandardBid)
+ {
+ output.escrowedAmount = 0;
+ output.refundedAmount = 0;
+ output.errorCode = EAuctionError::Success;
+ output.success = 0;
+ locals.highestBidderExists = 0;
+ locals.finalizeImmediately = 0;
+ locals.participantExists = 0;
+ locals.freeParticipantSlotFound = 0;
+ if (!state.get().auctionList.get(input.auctionIndex, locals.auction))
+ {
+ output.errorCode = EAuctionError::AuctionNotFound;
+ return;
+ }
+
+ if (locals.auction.core.quantityForSale == 0 || locals.auction.core.quantityForSale < locals.auction.core.minimumPurchaseQuantity ||
+ input.bidAmount == 0)
+ {
+ output.errorCode = EAuctionError::InvalidInput;
+ return;
+ }
+ // Reserve distinct entries for a replaced bidder, bidder change, three fee wallets, and the seller.
+ // This also guarantees that an accepted Buy Now bid can complete settlement in the same call.
+ if (state.get().pendingQuPayouts.population() > state.get().pendingQuPayouts.capacity() - NOST_STANDARD_BID_MAX_PAYOUT_RECIPIENTS)
+ {
+ output.errorCode = EAuctionError::PayoutQueueFull;
+ return;
+ }
+
+ locals.requiredEscrow = input.bidAmount;
+ if (static_cast(qpi.invocationReward()) < locals.requiredEscrow)
+ {
+ output.errorCode = EAuctionError::InsufficientFunds;
+ return;
+ }
+
+ if (locals.auction.core.highestBidPrice == 0)
+ {
+ if (input.bidAmount < locals.auction.core.initialPrice)
+ {
+ output.errorCode = EAuctionError::BidTooLow;
+ return;
+ }
+ }
+ else if (input.bidAmount < sadd(locals.auction.core.highestBidPrice, locals.auction.core.minimumBidIncrement))
+ {
+ output.errorCode = EAuctionError::BidTooLow;
+ return;
+ }
+
+ // Standard bidders update their own active slot, while a new bidder needs one reusable slot.
+ for (locals.participantSlotIndex = 0; locals.participantSlotIndex < state.get().participants.capacity(); ++locals.participantSlotIndex)
+ {
+ locals.participantData = state.get().participants.get(locals.participantSlotIndex);
+ if (locals.participantData.isUsed && locals.participantData.isActive && locals.participantData.auctionIndex == input.auctionIndex &&
+ locals.participantData.participant == qpi.invocator())
+ {
+ locals.participantExists = 1;
+ break;
+ }
+ if (!locals.freeParticipantSlotFound && !locals.participantData.isUsed)
+ {
+ locals.freeParticipantSlotFound = 1;
+ locals.freeParticipantSlotIndex = locals.participantSlotIndex;
+ }
+ }
+ locals.previousEscrow = locals.participantExists ? locals.participantData.escrowedAmount : 0;
+ if (!locals.participantExists && !locals.freeParticipantSlotFound)
+ {
+ output.errorCode = EAuctionError::StorageFull;
+ return;
+ }
+ if (!locals.participantExists)
+ {
+ locals.participantSlotIndex = locals.freeParticipantSlotIndex;
+ if (locals.auction.core.nextBidIndex == UINT64_MAX)
+ {
+ output.errorCode = EAuctionError::StorageFull;
+ return;
+ }
+ }
+
+ locals.participantData.escrowedAmount = locals.requiredEscrow;
+ locals.participantData.requestedQuantity = locals.auction.core.quantityForSale;
+ locals.participantData.allocatedQuantity = 0;
+ locals.participantData.bidAmount = input.bidAmount;
+ locals.participantData.lastBidTime = input.currentDate;
+ locals.participantData.participant = qpi.invocator();
+ locals.participantData.auctionIndex = input.auctionIndex;
+ locals.participantData.bidIndex = locals.participantExists ? locals.participantData.bidIndex : locals.auction.core.nextBidIndex;
+ locals.participantData.isUsed = 1;
+ locals.participantData.isActive = 1;
+ locals.participantData.isWinningBid = 0;
+ if (!locals.participantExists)
+ {
+ locals.auction.core.nextBidIndex = sadd(locals.auction.core.nextBidIndex, 1ULL);
+ }
+
+ // A new highest bid releases the previous bidder's escrow before storing the replacement.
+ locals.highestBidderSlotIndex = locals.auction.core.highestBidSlotIndex;
+ if (locals.highestBidderSlotIndex < state.get().participants.capacity())
+ {
+ locals.previousHighestBidderData = state.get().participants.get(locals.highestBidderSlotIndex);
+ locals.highestBidderExists = locals.previousHighestBidderData.isUsed && locals.previousHighestBidderData.isActive &&
+ locals.previousHighestBidderData.auctionIndex == input.auctionIndex;
+ }
+ if (locals.highestBidderExists && locals.previousHighestBidderData.participant != qpi.invocator())
+ {
+ locals.payoutInput.recipient = locals.previousHighestBidderData.participant;
+ locals.payoutInput.amount = locals.previousHighestBidderData.escrowedAmount;
+ locals.payoutInput.maxChunks = NOST_IMMEDIATE_QU_TRANSFER_CHUNKS_PER_CALL;
+ CALL(QueueAndFlushQuPayout, locals.payoutInput, locals.payoutOutput);
+ output.refundedAmount = sadd(output.refundedAmount, locals.previousHighestBidderData.escrowedAmount);
+ locals.previousHighestBidderData.escrowedAmount = 0;
+ locals.previousHighestBidderData.requestedQuantity = 0;
+ locals.previousHighestBidderData.isActive = 0;
+ locals.previousHighestBidderData.isWinningBid = 0;
+ locals.archiveParticipantInput.participantData = locals.previousHighestBidderData;
+ CALL(ArchiveParticipant, locals.archiveParticipantInput, locals.archiveParticipantOutput);
+ locals.previousHighestBidderData = {};
+ state.mut().participants.set(locals.highestBidderSlotIndex, locals.previousHighestBidderData);
+ }
+
+ locals.participantData.isWinningBid = 1;
+ locals.auction.core.highestBidder = qpi.invocator();
+ locals.auction.core.highestBidPrice = input.bidAmount;
+ locals.auction.core.highestBidQuantity = locals.auction.core.quantityForSale;
+ locals.auction.core.highestBidAmount = locals.requiredEscrow;
+ locals.auction.core.highestBidSlotIndex = locals.participantSlotIndex;
+
+ locals.auction.core.lastBidAt = input.currentDate;
+ if ((locals.auction.core.auctionDurationSeconds - input.elapsedSeconds) <= NOST_AUCTION_EXTENSION_SECONDS)
+ {
+ locals.auction.core.auctionDurationSeconds = sadd(locals.auction.core.auctionDurationSeconds, NOST_AUCTION_EXTENSION_SECONDS);
+ }
+ if (locals.auction.core.buyNowPrice > 0 && input.bidAmount >= locals.auction.core.buyNowPrice)
+ {
+ locals.finalizeImmediately = 1;
+ }
+
+ state.mut().participants.set(locals.participantSlotIndex, locals.participantData);
+ state.mut().auctionList.replace(input.auctionIndex, locals.auction);
+
+ // Refund replaced self-escrow and excess reward after the new bid state is durable.
+ if (locals.previousEscrow > 0)
+ {
+ locals.payoutInput.recipient = qpi.invocator();
+ locals.payoutInput.amount = locals.previousEscrow;
+ locals.payoutInput.maxChunks = NOST_IMMEDIATE_QU_TRANSFER_CHUNKS_PER_CALL;
+ CALL(QueueAndFlushQuPayout, locals.payoutInput, locals.payoutOutput);
+ output.refundedAmount = sadd(output.refundedAmount, locals.previousEscrow);
+ }
+ if (static_cast(qpi.invocationReward()) > locals.requiredEscrow)
+ {
+ locals.payoutInput.recipient = qpi.invocator();
+ locals.payoutInput.amount = static_cast(qpi.invocationReward()) - locals.requiredEscrow;
+ locals.payoutInput.maxChunks = NOST_IMMEDIATE_QU_TRANSFER_CHUNKS_PER_CALL;
+ CALL(QueueAndFlushQuPayout, locals.payoutInput, locals.payoutOutput);
+ output.refundedAmount = sadd(output.refundedAmount, static_cast(qpi.invocationReward()) - locals.requiredEscrow);
+ }
+
+ output.escrowedAmount = locals.requiredEscrow;
+ output.success = 1;
+
+ // Buy Now closes the auction in the same procedure after the winning bid is recorded.
+ if (locals.finalizeImmediately)
+ {
+ locals.finalizeStandardAuctionInput.auctionIndex = input.auctionIndex;
+ locals.finalizeStandardAuctionInput.currentDate = input.currentDate;
+ CALL(FinalizeStandardAuction, locals.finalizeStandardAuctionInput, locals.finalizeStandardAuctionOutput);
+ }
+ }
+
+ /**
+ * @brief Validates the fixed-size IPFS metadata CID field.
+ */
+ PRIVATE_FUNCTION_WITH_LOCALS(ValidateMetadataCid)
+ {
+ output.isValid = 0;
+ locals.hasPayloadCharacters = 0;
+ locals.reachedTerminator = 0;
+
+ // Nostromo stores lowercase base32 CIDv1 values, which begin with the multibase prefix `b`.
+ if (input.metadataIpfsCid.get(0) != QPI::Ch::b)
+ {
+ return;
+ }
+
+ // After the first zero byte, the fixed-size CID field must remain zero-padded.
+ for (locals.cidIndex = 1; locals.cidIndex < input.metadataIpfsCid.capacity(); ++locals.cidIndex)
+ {
+ locals.cidChar = input.metadataIpfsCid.get(locals.cidIndex);
+ if (locals.cidChar == 0)
+ {
+ locals.reachedTerminator = 1;
+ continue;
+ }
+
+ if (locals.reachedTerminator)
+ {
+ return;
+ }
+
+ if ((locals.cidChar >= QPI::Ch::a && locals.cidChar <= QPI::Ch::z) || (locals.cidChar >= QPI::Ch::_2 && locals.cidChar <= QPI::Ch::_7))
+ {
+ locals.hasPayloadCharacters = 1;
+ continue;
+ }
+
+ return;
+ }
+
+ if (!locals.hasPayloadCharacters)
+ {
+ return;
+ }
+
+ output.isValid = 1;
+ }
+
+ /**
+ * @brief Verifies that the invocator can escrow every non-empty lot asset.
+ */
+ PRIVATE_FUNCTION_WITH_LOCALS(VerifyAuctionLotBalances)
+ {
+ output.hasEnoughBalance = 1;
+ // Creation validates possession before attempting escrow so failures can refund without rollback.
+ for (locals.lotItemIndex = 0; locals.lotItemIndex < input.auctionLotItems.capacity(); ++locals.lotItemIndex)
+ {
+ locals.lotItem = input.auctionLotItems.get(locals.lotItemIndex);
+ if (isZeroAsset(locals.lotItem.asset) || locals.lotItem.quantity <= 0)
+ {
+ continue;
+ }
+
+ locals.possessedShares = qpi.numberOfPossessedShares(locals.lotItem.asset.assetName, locals.lotItem.asset.issuer, qpi.invocator(),
+ qpi.invocator(), SELF_INDEX, SELF_INDEX);
+ if (locals.possessedShares < locals.lotItem.quantity)
+ {
+ output.hasEnoughBalance = 0;
+ return;
+ }
+ }
+ }
+
+ /**
+ * @brief Returns escrowed lot assets to the specified recipient.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(RollbackAuctionLotAssets)
+ {
+ // Rollback is shared by cancellation, failed creation, rejected standard sales, and no-sale finalization.
+ for (locals.lotItemIndex = 0; locals.lotItemIndex < input.auctionLotItems.capacity(); ++locals.lotItemIndex)
+ {
+ locals.lotItem = input.auctionLotItems.get(locals.lotItemIndex);
+ if (isZeroAsset(locals.lotItem.asset) || locals.lotItem.quantity <= 0)
+ {
+ continue;
+ }
+ qpi.transferShareOwnershipAndPossession(locals.lotItem.asset.assetName, locals.lotItem.asset.issuer, SELF, SELF, locals.lotItem.quantity,
+ input.recipient);
+ }
+ }
+
+ /**
+ * @brief Settles a Batch Auction by allocating winning quantities and closing the auction.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(FinalizeBatchAuction)
+ {
+ output.success = 0;
+ locals.bestParticipantFound = 0;
+ locals.lotItemFound = 0;
+ locals.soldQuantity = 0;
+ locals.totalGrossAmount = 0;
+
+ // Abort if the auction no longer exists or is no longer an active batch auction.
+ if (!state.get().auctionList.get(input.auctionIndex, locals.auction))
+ {
+ return;
+ }
+
+ if (locals.auction.core.type != EAuctionType::Batch || locals.auction.core.status != EAuctionStatus::Active)
+ {
+ return;
+ }
+ if (state.get().pendingQuPayouts.population() >
+ state.get().pendingQuPayouts.capacity() - state.get().participants.capacity() - NOST_AUCTION_REVENUE_MAX_PAYOUT_RECIPIENTS)
+ {
+ return;
+ }
+
+ // Resolve the single sellable lot entry that represents the batch asset and quantity in escrow.
+ for (locals.lotItemIndex = 0; locals.lotItemIndex < locals.auction.core.auctionLotItems.capacity(); ++locals.lotItemIndex)
+ {
+ locals.batchLotItem = locals.auction.core.auctionLotItems.get(locals.lotItemIndex);
+ if (!isZeroAsset(locals.batchLotItem.asset) && locals.batchLotItem.quantity > 0)
+ {
+ locals.lotItemFound = 1;
+ break;
+ }
+ }
+ if (!locals.lotItemFound)
+ {
+ return;
+ }
+
+ // Stop before producing a fragment below the auction minimum; the remainder stays with the seller.
+ locals.remainingQuantity = locals.auction.core.quantityForSale;
+ while (locals.remainingQuantity >= locals.auction.core.minimumPurchaseQuantity)
+ {
+ locals.bestParticipantFound = 0;
+ locals.participantIndex = 0;
+
+ // Price priority is descending; the monotonic bid index is the only FIFO tie-breaker.
+ while (locals.participantIndex < state.get().participants.capacity())
+ {
+ locals.participantData = state.get().participants.get(locals.participantIndex);
+ if (locals.participantData.isUsed && locals.participantData.auctionIndex == input.auctionIndex)
+ {
+ if (locals.participantData.isActive && locals.participantData.escrowedAmount > 0)
+ {
+ if (!locals.bestParticipantFound || locals.participantData.bidAmount > locals.bestParticipantData.bidAmount ||
+ (locals.participantData.bidAmount == locals.bestParticipantData.bidAmount &&
+ locals.participantData.bidIndex < locals.bestParticipantData.bidIndex))
+ {
+ locals.bestParticipantFound = 1;
+ locals.bestParticipantData = locals.participantData;
+ locals.bestParticipantSlotIndex = locals.participantIndex;
+ }
+ }
+ }
+ ++locals.participantIndex;
+ }
+
+ if (!locals.bestParticipantFound)
+ {
+ break;
+ }
+
+ // Price the winning allocation and compute any escrow surplus that must be returned immediately.
+ locals.allocatedQuantity = min(locals.remainingQuantity, locals.bestParticipantData.requestedQuantity);
+ locals.requiredPayment = smul(locals.allocatedQuantity, locals.bestParticipantData.bidAmount);
+ locals.refundAmount = 0;
+ if (locals.bestParticipantData.escrowedAmount > locals.requiredPayment)
+ {
+ locals.refundAmount = locals.bestParticipantData.escrowedAmount - locals.requiredPayment;
+ }
+
+ // Transfer the awarded shares, mark the participant as a winner, and advance settlement totals.
+ if (locals.allocatedQuantity > 0)
+ {
+ qpi.transferShareOwnershipAndPossession(locals.batchLotItem.asset.assetName, locals.batchLotItem.asset.issuer, SELF, SELF,
+ locals.allocatedQuantity, locals.bestParticipantData.participant);
+ locals.bestParticipantData.allocatedQuantity = locals.allocatedQuantity;
+ locals.bestParticipantData.isWinningBid = 1;
+ locals.soldQuantity = sadd(locals.soldQuantity, locals.allocatedQuantity);
+ locals.totalGrossAmount = sadd(locals.totalGrossAmount, locals.requiredPayment);
+ locals.remainingQuantity -= locals.allocatedQuantity;
+ }
+
+ // Return the unused part of the winner escrow when the participant requested more than the remaining supply.
+ if (locals.refundAmount > 0)
+ {
+ locals.payoutInput.recipient = locals.bestParticipantData.participant;
+ locals.payoutInput.amount = locals.refundAmount;
+ locals.payoutInput.maxChunks = NOST_IMMEDIATE_QU_TRANSFER_CHUNKS_PER_CALL;
+ CALL(QueueAndFlushQuPayout, locals.payoutInput, locals.payoutOutput);
+ if (!locals.payoutOutput.success)
+ {
+ return;
+ }
+ }
+
+ // Archive the completed bid and release its active slot immediately.
+ locals.bestParticipantData.escrowedAmount = 0;
+ locals.bestParticipantData.isActive = 0;
+ locals.archiveParticipantInput.participantData = locals.bestParticipantData;
+ CALL(ArchiveParticipant, locals.archiveParticipantInput, locals.archiveParticipantOutput);
+ locals.bestParticipantData = {};
+ state.mut().participants.set(locals.bestParticipantSlotIndex, locals.bestParticipantData);
+ }
+
+ // Refund every non-winning or non-allocated bid that still has escrow locked after winner selection.
+ locals.participantIndex = 0;
+ while (locals.participantIndex < state.get().participants.capacity())
+ {
+ locals.participantData = state.get().participants.get(locals.participantIndex);
+ if (locals.participantData.isUsed && locals.participantData.auctionIndex == input.auctionIndex)
+ {
+ if (locals.participantData.escrowedAmount > 0)
+ {
+ locals.payoutInput.recipient = locals.participantData.participant;
+ locals.payoutInput.amount = locals.participantData.escrowedAmount;
+ locals.payoutInput.maxChunks = NOST_IMMEDIATE_QU_TRANSFER_CHUNKS_PER_CALL;
+ CALL(QueueAndFlushQuPayout, locals.payoutInput, locals.payoutOutput);
+ if (!locals.payoutOutput.success)
+ {
+ return;
+ }
+ locals.participantData.escrowedAmount = 0;
+ locals.participantData.allocatedQuantity = 0;
+ locals.participantData.isWinningBid = 0;
+ }
+ locals.participantData.isActive = 0;
+ locals.archiveParticipantInput.participantData = locals.participantData;
+ CALL(ArchiveParticipant, locals.archiveParticipantInput, locals.archiveParticipantOutput);
+ locals.participantData = {};
+ state.mut().participants.set(locals.participantIndex, locals.participantData);
+ }
+ ++locals.participantIndex;
+ }
+
+ // Return any unsold batch quantity to the seller when demand did not consume the entire lot.
+ if (locals.soldQuantity < locals.auction.core.quantityForSale)
+ {
+ qpi.transferShareOwnershipAndPossession(locals.batchLotItem.asset.assetName, locals.batchLotItem.asset.issuer, SELF, SELF,
+ locals.auction.core.quantityForSale - locals.soldQuantity, locals.auction.core.seller);
+ }
+
+ // Split the collected proceeds according to Nostromo auction fee rules and pay the seller net amount.
+ locals.distributeAuctionRevenueInput.seller = locals.auction.core.seller;
+ locals.distributeAuctionRevenueInput.grossAmount = locals.totalGrossAmount;
+ CALL(DistributeAuctionRevenue, locals.distributeAuctionRevenueInput, locals.distributeAuctionRevenueOutput);
+ if (!locals.distributeAuctionRevenueOutput.success)
+ {
+ return;
+ }
+
+ // Persist the final sold quantity and close the auction as settled.
+ locals.auction.core.allocatedQuantity = locals.soldQuantity;
+ locals.auction.core.status = EAuctionStatus::Finalized;
+ locals.auction.core.settledAt = input.currentDate;
+ locals.auction.core.highestBidSlotIndex = NOST_INVALID_PARTICIPANT_SLOT;
+ state.mut().totalFinalizedAuctions = sadd(state.get().totalFinalizedAuctions, 1ULL);
+ locals.archiveClosedAuctionInput.auction = locals.auction;
+ CALL(ArchiveClosedAuction, locals.archiveClosedAuctionInput, locals.archiveClosedAuctionOutput);
+ output.success = 1;
+ }
+
+ /**
+ * @brief Settles a Standard Auction by transferring the lot or returning it to the seller.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(FinalizeStandardAuction)
+ {
+ output.success = 0;
+ locals.highestBidderExists = 0;
+ locals.lotSold = 0;
+
+ if (!state.get().auctionList.get(input.auctionIndex, locals.auction))
+ {
+ return;
+ }
+
+ if (locals.auction.core.type != EAuctionType::Standard)
+ {
+ return;
+ }
+ if (state.get().pendingQuPayouts.population() > state.get().pendingQuPayouts.capacity() - NOST_STANDARD_FINALIZATION_MAX_PAYOUT_RECIPIENTS)
+ {
+ return;
+ }
+
+ locals.highestBidderSlotIndex = locals.auction.core.highestBidSlotIndex;
+ if (locals.highestBidderSlotIndex < state.get().participants.capacity())
+ {
+ locals.highestBidderData = state.get().participants.get(locals.highestBidderSlotIndex);
+ locals.highestBidderExists =
+ locals.highestBidderData.isUsed && locals.highestBidderData.isActive && locals.highestBidderData.auctionIndex == input.auctionIndex;
+ }
+
+ // A valid highest bid transfers the whole standard lot and treats escrow as gross proceeds.
+ if (locals.highestBidderExists && locals.highestBidderData.escrowedAmount > 0)
+ {
+ locals.rollbackAuctionLotAssetsInput.auctionLotItems = locals.auction.core.auctionLotItems;
+ locals.rollbackAuctionLotAssetsInput.recipient = locals.highestBidderData.participant;
+ CALL(RollbackAuctionLotAssets, locals.rollbackAuctionLotAssetsInput, locals.rollbackAuctionLotAssetsOutput);
+
+ locals.distributeAuctionRevenueInput.seller = locals.auction.core.seller;
+ locals.distributeAuctionRevenueInput.grossAmount = locals.highestBidderData.escrowedAmount;
+ CALL(DistributeAuctionRevenue, locals.distributeAuctionRevenueInput, locals.distributeAuctionRevenueOutput);
+ if (!locals.distributeAuctionRevenueOutput.success)
+ {
+ return;
+ }
+
+ locals.highestBidderData.allocatedQuantity = locals.auction.core.quantityForSale;
+ locals.highestBidderData.isWinningBid = 1;
+ locals.highestBidderData.escrowedAmount = 0;
+ locals.highestBidderData.isActive = 0;
+ locals.archiveParticipantInput.participantData = locals.highestBidderData;
+ CALL(ArchiveParticipant, locals.archiveParticipantInput, locals.archiveParticipantOutput);
+ locals.highestBidderData = {};
+ state.mut().participants.set(locals.highestBidderSlotIndex, locals.highestBidderData);
+ locals.auction.core.allocatedQuantity = locals.auction.core.quantityForSale;
+ locals.lotSold = 1;
+ }
+ else
+ {
+ // No active funded bid means the seller receives the lot back with no revenue distribution.
+ locals.rollbackAuctionLotAssetsInput.auctionLotItems = locals.auction.core.auctionLotItems;
+ locals.rollbackAuctionLotAssetsInput.recipient = locals.auction.core.seller;
+ CALL(RollbackAuctionLotAssets, locals.rollbackAuctionLotAssetsInput, locals.rollbackAuctionLotAssetsOutput);
+ locals.auction.core.allocatedQuantity = 0;
+ }
+
+ // Closed standard auctions retain winner fields only when the lot actually sold.
+ locals.auction.core.status = EAuctionStatus::Finalized;
+ locals.auction.core.settledAt = input.currentDate;
+ if (!locals.lotSold)
+ {
+ locals.auction.core.highestBidAmount = 0;
+ locals.auction.core.highestBidPrice = 0;
+ locals.auction.core.highestBidQuantity = 0;
+ locals.auction.core.highestBidder = NULL_ID;
+ }
+ locals.auction.core.highestBidSlotIndex = NOST_INVALID_PARTICIPANT_SLOT;
+ state.mut().totalFinalizedAuctions = sadd(state.get().totalFinalizedAuctions, 1ULL);
+ locals.archiveClosedAuctionInput.auction = locals.auction;
+ CALL(ArchiveClosedAuction, locals.archiveClosedAuctionInput, locals.archiveClosedAuctionOutput);
+ output.success = 1;
+ }
+
+ /**
+ * @brief Rejects a pending Standard Auction bid and closes the auction without a sale.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(RejectStandardAuction)
+ {
+ output.refundedAmount = 0;
+ output.success = 0;
+ locals.highestBidderExists = 0;
+
+ if (!state.get().auctionList.get(input.auctionIndex, locals.auction))
+ {
+ return;
+ }
+
+ if (locals.auction.core.type != EAuctionType::Standard || locals.auction.core.status != EAuctionStatus::PendingSellerDecision)
+ {
+ return;
+ }
+ if (state.get().pendingQuPayouts.population() == state.get().pendingQuPayouts.capacity())
+ {
+ return;
+ }
+
+ locals.highestBidderSlotIndex = locals.auction.core.highestBidSlotIndex;
+ if (locals.highestBidderSlotIndex < state.get().participants.capacity())
+ {
+ locals.highestBidderData = state.get().participants.get(locals.highestBidderSlotIndex);
+ locals.highestBidderExists =
+ locals.highestBidderData.isUsed && locals.highestBidderData.isActive && locals.highestBidderData.auctionIndex == input.auctionIndex;
+ }
+
+ // Seller rejection unwinds the pending bid instead of distributing its escrow as proceeds.
+ if (locals.highestBidderExists && locals.highestBidderData.escrowedAmount > 0)
+ {
+ locals.payoutInput.recipient = locals.highestBidderData.participant;
+ locals.payoutInput.amount = locals.highestBidderData.escrowedAmount;
+ locals.payoutInput.maxChunks = NOST_IMMEDIATE_QU_TRANSFER_CHUNKS_PER_CALL;
+ CALL(QueueAndFlushQuPayout, locals.payoutInput, locals.payoutOutput);
+ if (!locals.payoutOutput.success)
+ {
+ return;
+ }
+ output.refundedAmount = locals.highestBidderData.escrowedAmount;
+ locals.highestBidderData.escrowedAmount = 0;
+ locals.highestBidderData.allocatedQuantity = 0;
+ locals.highestBidderData.isActive = 0;
+ locals.highestBidderData.isWinningBid = 0;
+ locals.archiveParticipantInput.participantData = locals.highestBidderData;
+ CALL(ArchiveParticipant, locals.archiveParticipantInput, locals.archiveParticipantOutput);
+ locals.highestBidderData = {};
+ state.mut().participants.set(locals.highestBidderSlotIndex, locals.highestBidderData);
+ }
+
+ // The seller keeps the lot after rejection, and the auction is closed as finalized.
+ locals.rollbackAuctionLotAssetsInput.auctionLotItems = locals.auction.core.auctionLotItems;
+ locals.rollbackAuctionLotAssetsInput.recipient = locals.auction.core.seller;
+ CALL(RollbackAuctionLotAssets, locals.rollbackAuctionLotAssetsInput, locals.rollbackAuctionLotAssetsOutput);
+
+ locals.auction.core.allocatedQuantity = 0;
+ locals.auction.core.highestBidAmount = 0;
+ locals.auction.core.highestBidPrice = 0;
+ locals.auction.core.highestBidQuantity = 0;
+ locals.auction.core.highestBidder = NULL_ID;
+ locals.auction.core.highestBidSlotIndex = NOST_INVALID_PARTICIPANT_SLOT;
+ locals.auction.core.status = EAuctionStatus::Finalized;
+ locals.auction.core.settledAt = input.currentDate;
+ state.mut().totalFinalizedAuctions = sadd(state.get().totalFinalizedAuctions, 1ULL);
+ locals.archiveClosedAuctionInput.auction = locals.auction;
+ CALL(ArchiveClosedAuction, locals.archiveClosedAuctionInput, locals.archiveClosedAuctionOutput);
+ output.success = 1;
+ }
+
+ /**
+ * @brief Transfers auction lot assets into contract escrow during creation.
+ */
+ PRIVATE_PROCEDURE_WITH_LOCALS(EscrowAuctionLotAssets)
+ {
+ output.success = 1;
+ // Escrow entries one by one; a later failure rolls back earlier successful transfers.
+ for (locals.lotItemIndex = 0; locals.lotItemIndex < input.auctionLotItems.capacity(); ++locals.lotItemIndex)
+ {
+ locals.lotItem = input.auctionLotItems.get(locals.lotItemIndex);
+ if (isZeroAsset(locals.lotItem.asset) || locals.lotItem.quantity <= 0)
+ {
+ continue;
+ }
+
+ locals.remainingShares = qpi.transferShareOwnershipAndPossession(locals.lotItem.asset.assetName, locals.lotItem.asset.issuer,
+ qpi.invocator(), qpi.invocator(), locals.lotItem.quantity, SELF);
+ if (locals.remainingShares < 0)
+ {
+ // `transferShareOwnershipAndPossession` returns the remaining number of matching shares after a successful transfer.
+ // Negative values mean the transfer failed without moving the requested lot entry.
+ for (locals.rollbackLotItemIndex = 0; locals.rollbackLotItemIndex < locals.lotItemIndex; ++locals.rollbackLotItemIndex)
+ {
+ locals.lotItem = input.auctionLotItems.get(locals.rollbackLotItemIndex);
+ if (isZeroAsset(locals.lotItem.asset) || locals.lotItem.quantity <= 0)
+ {
+ continue;
+ }
+ qpi.transferShareOwnershipAndPossession(locals.lotItem.asset.assetName, locals.lotItem.asset.issuer, SELF, SELF,
+ locals.lotItem.quantity, qpi.invocator());
+ }
+ output.success = 0;
+ return;
+ }
+ }
+ }
+
+ /**
+ * @brief Creates a new Batch Auction or Standard Auction in the Nostromo Auction House.
+ * @note `CreateAuction_input` defines the IPFS metadata CID stored through Pinata, the auction lot, pricing, duration, and visibility rules.
+ * @note Batch auctions require `minimumPurchaseQuantity` in the range `[1, quantityForSale]`; standard auctions ignore it and store zero.
+ * @note A successful public Batch or Standard Auction accumulates the configured public creation fee, distributed at `END_EPOCH`.
+ * Insufficient payment rejects creation, overpayment is refunded, and failed creation refunds the full reward.
+ * @note Private auctions require the configured private auction fee, which is accumulated and distributed at `END_EPOCH` between shareholders
+ * and the configured fee recipients, and must use at least one access mode. If both modes are configured, either one grants access.
+ */
+ PUBLIC_PROCEDURE_WITH_LOCALS(CreateAuction)
+ {
+ output.errorCode = EAuctionError::InvalidInput;
+
+ // Any rejection before escrow succeeds refunds the full invocation reward.
+ CALL(IsAuctionInteractionPaused, locals.isAuctionInteractionPausedInput, locals.isAuctionInteractionPausedOutput);
+ if (locals.isAuctionInteractionPausedOutput.isPaused)
+ {
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::AuctionPaused;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CreateAuction, output.errorCode, output.auctionIndex,
+ qpi.invocationReward());
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ if (!isSupportedAuctionType(static_cast(input.auctionType)))
+ {
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::InvalidAuctionType;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CreateAuction, output.errorCode, output.auctionIndex,
+ qpi.invocationReward());
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ if (!isSupportedAuctionVisibility(static_cast(input.auctionVisibility)))
+ {
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::InvalidVisibility;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CreateAuction, output.errorCode, output.auctionIndex,
+ qpi.invocationReward());
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ if (state.get().auctionList.population() >= state.get().auctionList.capacity())
+ {
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::StorageFull;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CreateAuction, output.errorCode, output.auctionIndex,
+ qpi.invocationReward());
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ if (state.get().totalAuctionsCreated == UINT64_MAX)
+ {
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::AuctionIndexExhausted;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CreateAuction, output.errorCode, output.auctionIndex,
+ qpi.invocationReward());
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ locals.validateMetadataCidInput.metadataIpfsCid = input.metadataIpfsCid;
+ CALL(ValidateMetadataCid, locals.validateMetadataCidInput, locals.validateMetadataCidOutput);
+ if (!locals.validateMetadataCidOutput.isValid)
+ {
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::InvalidInput;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CreateAuction, output.errorCode, output.auctionIndex,
+ qpi.invocationReward());
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ locals.analyzeAuctionLotInput.auctionLotItems = input.auctionLotItems;
+ locals.analyzeAuctionLotInput.durationDays = input.durationDays;
+ CALL(AnalyzeAuctionLot, locals.analyzeAuctionLotInput, locals.analyzeAuctionLotOutput);
+ if (!locals.analyzeAuctionLotOutput.isValid)
+ {
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::InvalidInput;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CreateAuction, output.errorCode, output.auctionIndex,
+ qpi.invocationReward());
+ logProcedureResult(locals.log);
+ return;
+ }
+ // Resolve auction-type-specific quantity and price invariants before touching assets.
+ locals.resolvedQuantityForSale = 0;
+ locals.resolvedMinimumPurchaseQuantity = 0;
+ switch (static_cast(input.auctionType))
+ {
+ case EAuctionType::Batch:
+
+ if (!resolveBatchAuctionCreateParams(locals.analyzeAuctionLotOutput.lotItemCount, locals.analyzeAuctionLotOutput.totalEscrowQuantity,
+ input.minimumPurchaseQuantity, locals.resolvedQuantityForSale,
+ locals.resolvedMinimumPurchaseQuantity, input.buyNowPrice))
+ {
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::InvalidInput;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CreateAuction, output.errorCode, output.auctionIndex,
+ qpi.invocationReward());
+ logProcedureResult(locals.log);
+ return;
+ }
+ break;
+ case EAuctionType::Standard:
+ if (!resolveStandardAuctionCreateParams(input.minimumBidIncrement, locals.resolvedQuantityForSale,
+ locals.resolvedMinimumPurchaseQuantity, input.buyNowPrice, input.initialPrice,
+ input.salePrice))
+ {
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::InvalidInput;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CreateAuction, output.errorCode, output.auctionIndex,
+ qpi.invocationReward());
+ logProcedureResult(locals.log);
+ return;
+ }
+ break;
+ default:
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::InvalidAuctionType;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CreateAuction, output.errorCode, output.auctionIndex,
+ qpi.invocationReward());
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ // Private auctions require at least one access gate and may combine wallet and asset access.
+ locals.countAllowedBidderWalletsInput.allowedBidderWallets = input.allowedBidderWallets;
+ CALL(CountAllowedBidderWallets, locals.countAllowedBidderWalletsInput, locals.countAllowedBidderWalletsOutput);
+ locals.countRequiredAccessAssetsInput.requiredAccessAssets = input.requiredAccessAssets;
+ CALL(CountRequiredAccessAssets, locals.countRequiredAccessAssetsInput, locals.countRequiredAccessAssetsOutput);
+ if (!locals.countRequiredAccessAssetsOutput.isValid ||
+ !validatePrivateAuctionAccess(static_cast(input.auctionVisibility),
+ locals.countRequiredAccessAssetsOutput.requiredAccessAssetCount,
+ locals.countAllowedBidderWalletsOutput.allowedWalletCount))
+ {
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::InvalidInput;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CreateAuction, output.errorCode, output.auctionIndex,
+ qpi.invocationReward());
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ locals.requiredFee = getCreateAuctionFee(static_cast(input.auctionVisibility), state);
+ if (qpi.invocationReward() < locals.requiredFee)
+ {
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
}
- if (qpi.invocationReward() > NOSTROMO_CREATE_PROJECT_FEE)
+ output.errorCode = EAuctionError::InsufficientFunds;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CreateAuction, output.errorCode, output.auctionIndex,
+ qpi.invocationReward());
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ locals.verifyAuctionLotBalancesInput.auctionLotItems = input.auctionLotItems;
+ CALL(VerifyAuctionLotBalances, locals.verifyAuctionLotBalancesInput, locals.verifyAuctionLotBalancesOutput);
+ if (!locals.verifyAuctionLotBalancesOutput.hasEnoughBalance)
+ {
+ if (qpi.invocationReward() > 0)
{
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - NOSTROMO_CREATE_PROJECT_FEE);
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
}
- state.mut().epochRevenue += NOSTROMO_CREATE_PROJECT_FEE;
+ output.errorCode = EAuctionError::InsufficientAssetBalance;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CreateAuction, output.errorCode, output.auctionIndex,
+ qpi.invocationReward());
+ logProcedureResult(locals.log);
+ return;
+ }
- locals.newProject.creator = qpi.invocator();
- locals.newProject.tokenName = input.tokenName;
- locals.newProject.supplyOfToken = input.supply;
- locals.newProject.startDate = locals.startDate;
- locals.newProject.endDate = locals.endDate;
- locals.newProject.numberOfYes = 0;
- locals.newProject.numberOfNo = 0;
+ // From this point onward, asset escrow may need explicit rollback on storage failure.
+ locals.escrowAuctionLotAssetsInput.auctionLotItems = input.auctionLotItems;
+ CALL(EscrowAuctionLotAssets, locals.escrowAuctionLotAssetsInput, locals.escrowAuctionLotAssetsOutput);
+ if (!locals.escrowAuctionLotAssetsOutput.success)
+ {
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::InsufficientAssetBalance;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CreateAuction, output.errorCode, output.auctionIndex,
+ qpi.invocationReward());
+ logProcedureResult(locals.log);
+ return;
+ }
- output.indexOfProject = state.get().numberOfCreatedProject;
- state.mut().projects.set(state.get().numberOfCreatedProject, locals.newProject);
- state.mut().numberOfCreatedProject++;
- state.mut().tokens.add(input.tokenName);
+ locals.auction.core.auctionIndex = state.get().totalAuctionsCreated;
+ locals.auction.core.quantityForSale = locals.resolvedQuantityForSale;
+ locals.auction.core.minimumPurchaseQuantity = locals.resolvedMinimumPurchaseQuantity;
+ locals.auction.core.initialPrice = input.initialPrice;
+ locals.auction.core.salePrice = input.salePrice;
+ locals.auction.core.minimumBidIncrement = input.minimumBidIncrement;
+ locals.auction.core.buyNowPrice = input.buyNowPrice;
+ locals.auction.core.auctionDurationSeconds = smul(static_cast(input.durationDays), NOST_SECONDS_PER_DAY);
+ locals.auction.core.createdAt = qpi.now();
+ locals.auction.core.lastBidAt = locals.auction.core.createdAt;
+ locals.auction.core.seller = qpi.invocator();
+ locals.auction.core.highestBidSlotIndex = NOST_INVALID_PARTICIPANT_SLOT;
+ // Duplicate required access assets collapse to the highest configured quantity.
+ for (locals.requiredAccessAssetIndex = 0; locals.requiredAccessAssetIndex < input.requiredAccessAssets.capacity();
+ ++locals.requiredAccessAssetIndex)
+ {
+ locals.requiredAccessAsset = input.requiredAccessAssets.get(locals.requiredAccessAssetIndex);
+ if (!isZeroAsset(locals.requiredAccessAsset.asset) &&
+ (!locals.auction.requiredAccessAssets.get(locals.requiredAccessAsset.asset, locals.existingRequiredAccessQuantity) ||
+ locals.requiredAccessAsset.quantity > locals.existingRequiredAccessQuantity))
+ {
+ locals.auction.requiredAccessAssets.set(locals.requiredAccessAsset.asset, locals.requiredAccessAsset.quantity);
+ }
}
- else
+ locals.auction.core.auctionLotItems = input.auctionLotItems;
+ for (locals.allowedWalletIndex = 0; locals.allowedWalletIndex < input.allowedBidderWallets.capacity(); ++locals.allowedWalletIndex)
+ {
+ if (!isZero(input.allowedBidderWallets.get(locals.allowedWalletIndex)))
+ {
+ locals.auction.allowedBidderWallets.add(input.allowedBidderWallets.get(locals.allowedWalletIndex));
+ }
+ }
+ locals.auction.core.metadataIpfsCid = input.metadataIpfsCid;
+ locals.auction.core.type = static_cast(input.auctionType);
+ locals.auction.core.visibility = static_cast(input.auctionVisibility);
+ locals.auction.core.status = EAuctionStatus::Active;
+
+ // If persistent auction storage fails after escrow, return the lot before refunding the fee reward.
+ if (state.mut().auctionList.set(locals.auction.core.auctionIndex, locals.auction) == NULL_INDEX)
{
+ locals.rollbackAuctionLotAssetsInput.auctionLotItems = input.auctionLotItems;
+ locals.rollbackAuctionLotAssetsInput.recipient = qpi.invocator();
+ CALL(RollbackAuctionLotAssets, locals.rollbackAuctionLotAssetsInput, locals.rollbackAuctionLotAssetsOutput);
if (qpi.invocationReward() > 0)
{
qpi.transfer(qpi.invocator(), qpi.invocationReward());
}
- output.indexOfProject = NOSTROMO_MAX_NUMBER_PROJECT;
+ output.errorCode = EAuctionError::StorageFull;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CreateAuction, output.errorCode, output.auctionIndex,
+ qpi.invocationReward());
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ // Creation fees are held until END_EPOCH; overpayment is returned immediately.
+ if (locals.requiredFee > 0)
+ {
+ locals.accumulateAuctionServiceFeeInput.feeAmount = static_cast(locals.requiredFee);
+ CALL(AccumulateAuctionServiceFee, locals.accumulateAuctionServiceFeeInput, locals.accumulateAuctionServiceFeeOutput);
+ }
+
+ if (qpi.invocationReward() > locals.requiredFee)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward() - locals.requiredFee);
}
+
+ output.auctionIndex = locals.auction.core.auctionIndex;
+ state.mut().totalAuctionsCreated = sadd(state.get().totalAuctionsCreated, 1ULL);
+ output.errorCode = EAuctionError::Success;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CreateAuction, output.errorCode, output.auctionIndex, qpi.invocationReward());
+ logProcedureResult(locals.log);
}
- struct voteInProject_locals
+ /**
+ * @brief Places a bid in an active auction.
+ * @note Batch auctions interpret `bidAmount` as price per asset and reject requested `quantity` below `minimumPurchaseQuantity` with a full
+ * refund.
+ * @note An accepted Batch bid escrows `quantity * bidAmount` and accumulates `max(100 - quantity * bidAmount, 0)` qu for distribution at
+ * `END_EPOCH`. Excess reward is refunded; rejected bids refund the full reward. The accumulated fee is not refunded if the bid is later
+ * displaced.
+ * @note Batch final allocations are also at least `minimumPurchaseQuantity`; smaller unsold remainders return to the seller and affected bids are
+ * fully refunded.
+ * @note Standard auctions interpret `bidAmount` as the total price for the whole lot and ignore `quantity`.
+ */
+ PUBLIC_PROCEDURE_WITH_LOCALS(PlaceBid)
{
- projectInfo votedProject;
- Array votedList;
- uint32 elementIndex, curDate, numberOfVotedProject, i;
- bit flag;
- };
+ output.errorCode = EAuctionError::InvalidInput;
- PUBLIC_PROCEDURE_WITH_LOCALS(voteInProject)
- {
- if (input.indexOfProject >= state.get().numberOfCreatedProject)
+ // Common auction gates run before type-specific bid processing; failed gates refund the reward.
+ CALL(IsAuctionInteractionPaused, locals.isAuctionInteractionPausedInput, locals.isAuctionInteractionPausedOutput);
+ if (locals.isAuctionInteractionPausedOutput.isPaused)
+ {
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::AuctionPaused;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::PlaceBid, output.errorCode, input.auctionIndex, output.escrowedAmount);
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ if (!state.get().auctionList.get(input.auctionIndex, locals.auction))
{
- return ;
+ locals.findAuctionInput.auctionIndex = input.auctionIndex;
+ CALL(FindAuction, locals.findAuctionInput, locals.findAuctionOutput);
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = locals.findAuctionOutput.found ? EAuctionError::AuctionClosed : EAuctionError::AuctionNotFound;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::PlaceBid, output.errorCode, input.auctionIndex, output.escrowedAmount);
+ logProcedureResult(locals.log);
+ return;
}
- if (state.get().users.contains(qpi.invocator()) == 0)
+
+ if (locals.auction.core.status != EAuctionStatus::Active)
{
- return ;
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::AuctionClosed;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::PlaceBid, output.errorCode, input.auctionIndex, output.escrowedAmount);
+ logProcedureResult(locals.log);
+ return;
}
- state.get().numberOfVotedProject.get(qpi.invocator(), locals.numberOfVotedProject);
- if (locals.numberOfVotedProject == NOSTROMO_MAX_NUMBER_OF_PROJECT_USER_INVEST)
+
+ if (locals.auction.core.seller == qpi.invocator())
{
- return ;
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::Forbidden;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::PlaceBid, output.errorCode, input.auctionIndex, output.escrowedAmount);
+ logProcedureResult(locals.log);
+ return;
}
- state.get().voteStatus.get(qpi.invocator(), locals.votedList);
- for (locals.i = 0; locals.i < locals.numberOfVotedProject; locals.i++)
+
+ locals.currentDate = qpi.now();
+ diffDateInSecond(locals.auction.core.createdAt, locals.currentDate, locals.elapsedSeconds);
+ if (locals.elapsedSeconds >= locals.auction.core.auctionDurationSeconds)
{
- if (locals.votedList.get(locals.i) == input.indexOfProject)
+ if (qpi.invocationReward() > 0)
{
- return ;
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
}
+ output.errorCode = EAuctionError::AuctionClosed;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::PlaceBid, output.errorCode, input.auctionIndex, output.escrowedAmount);
+ logProcedureResult(locals.log);
+ return;
}
- packNostromoDate(qpi.year(), qpi.month(), qpi.day(), qpi.hour(), qpi.minute(), qpi.second(), locals.curDate);
- if (locals.curDate >= state.get().projects.get(input.indexOfProject).startDate && locals.curDate < state.get().projects.get(input.indexOfProject).endDate)
+
+ // When both gates are configured, satisfying either one grants access.
+ if (locals.auction.core.visibility == EAuctionVisibility::Private)
{
- locals.votedProject = state.get().projects.get(input.indexOfProject);
- if (input.decision)
+ locals.hasAccess = locals.auction.allowedBidderWallets.population() > 0 && locals.auction.allowedBidderWallets.contains(qpi.invocator());
+ if (!locals.hasAccess && locals.auction.requiredAccessAssets.population() > 0)
{
- locals.votedProject.numberOfYes++;
+ locals.hasRequiredAccessAssetInput.auctionIndex = input.auctionIndex;
+ CALL(HasRequiredAccessAsset, locals.hasRequiredAccessAssetInput, locals.hasRequiredAccessAssetOutput);
+ locals.hasAccess = locals.hasRequiredAccessAssetOutput.hasRequiredAccessAsset;
}
- else
+
+ if (!locals.hasAccess)
{
- locals.votedProject.numberOfNo++;
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::PrivateAuctionAccessDenied;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::PlaceBid, output.errorCode, input.auctionIndex,
+ output.escrowedAmount);
+ logProcedureResult(locals.log);
+ return;
}
- state.mut().projects.set(input.indexOfProject, locals.votedProject);
- locals.votedList.set(locals.numberOfVotedProject++, input.indexOfProject);
- state.mut().voteStatus.set(qpi.invocator(), locals.votedList);
- state.mut().numberOfVotedProject.set(qpi.invocator(), locals.numberOfVotedProject);
}
- }
- struct createFundraising_locals
- {
- projectInfo tmpProject;
- fundaraisingInfo newFundraising;
- uint32 curDate, firstPhaseStartDate, firstPhaseEndDate, secondPhaseStartDate, secondPhaseEndDate, thirdPhaseStartDate, thirdPhaseEndDate, listingStartDate, cliffEndDate, vestingEndDate;
- };
+ // Type-specific processors own escrow/refund details once common validation succeeds.
+ switch (locals.auction.core.type)
+ {
+ case EAuctionType::Batch:
+ locals.processBatchBidInput.auctionIndex = input.auctionIndex;
+ locals.processBatchBidInput.effectiveQuantity = input.quantity;
+ locals.processBatchBidInput.bidAmount = input.bidAmount;
+ locals.processBatchBidInput.currentDate = locals.currentDate;
+ locals.processBatchBidInput.elapsedSeconds = locals.elapsedSeconds;
+ CALL(ProcessBatchBid, locals.processBatchBidInput, locals.processBatchBidOutput);
+ if (!locals.processBatchBidOutput.success)
+ {
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.refundedAmount = locals.processBatchBidOutput.refundedAmount;
+ output.errorCode = locals.processBatchBidOutput.errorCode;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::PlaceBid, output.errorCode, input.auctionIndex,
+ output.escrowedAmount);
+ logProcedureResult(locals.log);
+ return;
+ }
+ output.refundedAmount = sadd(output.refundedAmount, locals.processBatchBidOutput.refundedAmount);
+ output.escrowedAmount = locals.processBatchBidOutput.escrowedAmount;
+ break;
+ case EAuctionType::Standard:
+ locals.processStandardBidInput.auctionIndex = input.auctionIndex;
+ locals.processStandardBidInput.bidAmount = input.bidAmount;
+ locals.processStandardBidInput.currentDate = locals.currentDate;
+ locals.processStandardBidInput.elapsedSeconds = locals.elapsedSeconds;
+ CALL(ProcessStandardBid, locals.processStandardBidInput, locals.processStandardBidOutput);
+ if (!locals.processStandardBidOutput.success)
+ {
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = locals.processStandardBidOutput.errorCode;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::PlaceBid, output.errorCode, input.auctionIndex,
+ output.escrowedAmount);
+ logProcedureResult(locals.log);
+ return;
+ }
+ output.refundedAmount = sadd(output.refundedAmount, locals.processStandardBidOutput.refundedAmount);
+ output.escrowedAmount = locals.processStandardBidOutput.escrowedAmount;
+ break;
+ default:
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+ output.errorCode = EAuctionError::InvalidAuctionType;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::PlaceBid, output.errorCode, input.auctionIndex,
+ output.escrowedAmount);
+ logProcedureResult(locals.log);
+ return;
+ }
+ output.errorCode = EAuctionError::Success;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::PlaceBid, output.errorCode, input.auctionIndex, output.escrowedAmount);
+ logProcedureResult(locals.log);
+ }
- PUBLIC_PROCEDURE_WITH_LOCALS(createFundraising)
+ /**
+ * @brief Cancels an active auction before the first accepted bid is placed.
+ * @note Once any bid is accepted, the seller can no longer cancel the auction.
+ * @note The cancellation fee is based on the configured reserve price for the full batch quantity or standard lot and is distributed between
+ * shareholders and the configured fee recipients.
+ */
+ PUBLIC_PROCEDURE_WITH_LOCALS(CancelAuction)
{
- packNostromoDate(qpi.year(), qpi.month(), qpi.day(), qpi.hour(), qpi.minute(), qpi.second(), locals.curDate);
- packNostromoDate(input.firstPhaseStartYear, input.firstPhaseStartMonth, input.firstPhaseStartDay, input.firstPhaseStartHour, 0, 0, locals.firstPhaseStartDate);
- packNostromoDate(input.secondPhaseStartYear, input.secondPhaseStartMonth, input.secondPhaseStartDay, input.secondPhaseStartHour, 0, 0, locals.secondPhaseStartDate);
- packNostromoDate(input.thirdPhaseStartYear, input.thirdPhaseStartMonth, input.thirdPhaseStartDay, input.thirdPhaseStartHour, 0, 0, locals.thirdPhaseStartDate);
- packNostromoDate(input.firstPhaseEndYear, input.firstPhaseEndMonth, input.firstPhaseEndDay, input.firstPhaseEndHour, 0, 0, locals.firstPhaseEndDate);
- packNostromoDate(input.secondPhaseEndYear, input.secondPhaseEndMonth, input.secondPhaseEndDay, input.secondPhaseEndHour, 0, 0, locals.secondPhaseEndDate);
- packNostromoDate(input.thirdPhaseEndYear, input.thirdPhaseEndMonth, input.thirdPhaseEndDay, input.thirdPhaseEndHour, 0, 0, locals.thirdPhaseEndDate);
- packNostromoDate(input.listingStartYear, input.listingStartMonth, input.listingStartDay, input.listingStartHour, 0, 0, locals.listingStartDate);
- packNostromoDate(input.cliffEndYear, input.cliffEndMonth, input.cliffEndDay, input.cliffEndHour, 0, 0, locals.cliffEndDate);
- packNostromoDate(input.vestingEndYear, input.vestingEndMonth, input.vestingEndDay, input.vestingEndHour, 0, 0, locals.vestingEndDate);
+ output.refundedAmount = 0;
+ output.cancellationFee = 0;
+ output.errorCode = EAuctionError::InvalidInput;
- if (locals.curDate > locals.firstPhaseStartDate || locals.firstPhaseStartDate >= locals.firstPhaseEndDate || locals.firstPhaseEndDate > locals.secondPhaseStartDate || locals.secondPhaseStartDate >= locals.secondPhaseEndDate || locals.secondPhaseEndDate > locals.thirdPhaseStartDate || locals.thirdPhaseStartDate >= locals.thirdPhaseEndDate || locals.thirdPhaseEndDate > locals.listingStartDate || locals.listingStartDate > locals.cliffEndDate || locals.cliffEndDate > locals.vestingEndDate)
+ // Cancellation is blocked during emergency pause but does not use the scheduled auction timer pause.
+ if (state.get().isEmergencyPaused)
{
if (qpi.invocationReward() > 0)
{
qpi.transfer(qpi.invocator(), qpi.invocationReward());
}
- return ;
+ output.errorCode = EAuctionError::AuctionPaused;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CancelAuction, output.errorCode, input.auctionIndex,
+ output.cancellationFee);
+ logProcedureResult(locals.log);
+ return;
}
- if (checkValidNostDateTime(locals.firstPhaseStartDate) == 0 || checkValidNostDateTime(locals.firstPhaseEndDate) == 0 || checkValidNostDateTime(locals.secondPhaseStartDate) == 0 || checkValidNostDateTime(locals.secondPhaseEndDate) == 0 || checkValidNostDateTime(locals.thirdPhaseStartDate) == 0 || checkValidNostDateTime(locals.thirdPhaseEndDate) == 0 || checkValidNostDateTime(locals.listingStartDate) == 0 || checkValidNostDateTime(locals.cliffEndDate) == 0 || checkValidNostDateTime(locals.vestingEndDate) == 0)
+
+ if (!state.get().auctionList.get(input.auctionIndex, locals.auction))
{
+ locals.findAuctionInput.auctionIndex = input.auctionIndex;
+ CALL(FindAuction, locals.findAuctionInput, locals.findAuctionOutput);
if (qpi.invocationReward() > 0)
{
qpi.transfer(qpi.invocator(), qpi.invocationReward());
}
- return ;
+ output.errorCode = locals.findAuctionOutput.found ? EAuctionError::AuctionClosed : EAuctionError::AuctionNotFound;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CancelAuction, output.errorCode, input.auctionIndex,
+ output.cancellationFee);
+ logProcedureResult(locals.log);
+ return;
}
- if (input.stepOfVesting == 0 || input.stepOfVesting > 12 || input.TGE > 50 || input.threshold > 50 || input.indexOfProject >= state.get().numberOfCreatedProject)
+ if (locals.auction.core.status != EAuctionStatus::Active)
{
if (qpi.invocationReward() > 0)
{
qpi.transfer(qpi.invocator(), qpi.invocationReward());
}
- return ;
+ output.errorCode = EAuctionError::AuctionClosed;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CancelAuction, output.errorCode, input.auctionIndex,
+ output.cancellationFee);
+ logProcedureResult(locals.log);
+ return;
}
-
- if (state.get().projects.get(input.indexOfProject).creator != qpi.invocator())
+ if (locals.auction.core.seller != qpi.invocator())
{
if (qpi.invocationReward() > 0)
{
qpi.transfer(qpi.invocator(), qpi.invocationReward());
}
- return ;
+ output.errorCode = EAuctionError::Forbidden;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CancelAuction, output.errorCode, input.auctionIndex,
+ output.cancellationFee);
+ logProcedureResult(locals.log);
+ return;
}
- if (input.soldAmount > state.get().projects.get(input.indexOfProject).supplyOfToken)
+ if (locals.auction.core.nextBidIndex != 0)
{
if (qpi.invocationReward() > 0)
{
qpi.transfer(qpi.invocator(), qpi.invocationReward());
}
- return ;
+ output.errorCode = EAuctionError::AuctionHasAcceptedBid;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CancelAuction, output.errorCode, input.auctionIndex,
+ output.cancellationFee);
+ logProcedureResult(locals.log);
+ return;
}
- if (locals.curDate <= state.get().projects.get(input.indexOfProject).endDate || state.get().projects.get(input.indexOfProject).numberOfYes <= state.get().projects.get(input.indexOfProject).numberOfNo || state.get().projects.get(input.indexOfProject).isCreatedFundarasing == 1)
+ // The fee base represents the full reserve value of the lot being withdrawn.
+ locals.cancellationBaseAmount = locals.auction.core.salePrice;
+ if (locals.auction.core.type == EAuctionType::Batch)
{
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
+ locals.cancellationBaseAmount = smul(locals.auction.core.salePrice, locals.auction.core.quantityForSale);
}
+ output.cancellationFee = calculateBasisPointAmount(locals.cancellationBaseAmount, state.get().auctionCancellationFeeBasisPoints);
- if (input.tokenPrice * input.soldAmount < input.requiredFunds + div(input.requiredFunds * input.threshold, 100ULL))
+ if (static_cast(qpi.invocationReward()) < output.cancellationFee)
{
if (qpi.invocationReward() > 0)
{
qpi.transfer(qpi.invocator(), qpi.invocationReward());
}
- return ;
+ output.errorCode = EAuctionError::InsufficientFunds;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CancelAuction, output.errorCode, input.auctionIndex,
+ output.cancellationFee);
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ locals.rollbackAuctionLotAssetsInput.auctionLotItems = locals.auction.core.auctionLotItems;
+ locals.rollbackAuctionLotAssetsInput.recipient = locals.auction.core.seller;
+ CALL(RollbackAuctionLotAssets, locals.rollbackAuctionLotAssetsInput, locals.rollbackAuctionLotAssetsOutput);
+
+ // Cancellation closes the auction and records it in the same history ring as finalized auctions.
+ locals.currentDate = qpi.now();
+ locals.auction.core.status = EAuctionStatus::Cancelled;
+ locals.auction.core.settledAt = locals.currentDate;
+ locals.auction.core.allocatedQuantity = 0;
+ locals.auction.core.highestBidAmount = 0;
+ locals.auction.core.highestBidPrice = 0;
+ locals.auction.core.highestBidQuantity = 0;
+ locals.auction.core.highestBidder = NULL_ID;
+ locals.auction.core.highestBidSlotIndex = NOST_INVALID_PARTICIPANT_SLOT;
+ state.mut().totalCancelledAuctions = sadd(state.get().totalCancelledAuctions, 1ULL);
+ locals.archiveClosedAuctionInput.auction = locals.auction;
+ CALL(ArchiveClosedAuction, locals.archiveClosedAuctionInput, locals.archiveClosedAuctionOutput);
+
+ // Cancellation fees use the same epoch pool as creation and small-bid service fees.
+ locals.accumulateAuctionServiceFeeInput.feeAmount = output.cancellationFee;
+ CALL(AccumulateAuctionServiceFee, locals.accumulateAuctionServiceFeeInput, locals.accumulateAuctionServiceFeeOutput);
+
+ if (static_cast(qpi.invocationReward()) > output.cancellationFee)
+ {
+ qpi.transfer(qpi.invocator(), static_cast(qpi.invocationReward()) - output.cancellationFee);
+ }
+
+ output.errorCode = EAuctionError::Success;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::CancelAuction, output.errorCode, input.auctionIndex, output.cancellationFee);
+ logProcedureResult(locals.log);
+ }
+
+ /**
+ * @brief Lets the seller accept or reject a pending standard auction whose highest bid stayed below the sale price.
+ * @note The manual decision window lasts one week; after expiry the contract finalizes the sale automatically in favor of the buyer.
+ */
+ PUBLIC_PROCEDURE_WITH_LOCALS(ResolvePendingStandardAuction)
+ {
+ output.refundedAmount = 0;
+ output.errorCode = EAuctionError::InvalidInput;
+
+ // This procedure does not need a reward; return any supplied amount before validation.
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+
+ CALL(IsAuctionInteractionPaused, locals.isAuctionInteractionPausedInput, locals.isAuctionInteractionPausedOutput);
+ if (locals.isAuctionInteractionPausedOutput.isPaused)
+ {
+ output.errorCode = EAuctionError::AuctionPaused;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::ResolvePendingStandardAuction, output.errorCode, input.auctionIndex,
+ output.refundedAmount);
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ if (input.acceptSale > 1)
+ {
+ output.errorCode = EAuctionError::InvalidInput;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::ResolvePendingStandardAuction, output.errorCode, input.auctionIndex,
+ output.refundedAmount);
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ if (!state.get().auctionList.get(input.auctionIndex, locals.auction))
+ {
+ locals.findAuctionInput.auctionIndex = input.auctionIndex;
+ CALL(FindAuction, locals.findAuctionInput, locals.findAuctionOutput);
+ output.errorCode = locals.findAuctionOutput.found ? EAuctionError::AuctionClosed : EAuctionError::AuctionNotFound;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::ResolvePendingStandardAuction, output.errorCode, input.auctionIndex,
+ output.refundedAmount);
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ if (locals.auction.core.seller != qpi.invocator())
+ {
+ output.errorCode = EAuctionError::Forbidden;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::ResolvePendingStandardAuction, output.errorCode, input.auctionIndex,
+ output.refundedAmount);
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ if (locals.auction.core.type != EAuctionType::Standard || locals.auction.core.status != EAuctionStatus::PendingSellerDecision)
+ {
+ output.errorCode = EAuctionError::AuctionClosed;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::ResolvePendingStandardAuction, output.errorCode, input.auctionIndex,
+ output.refundedAmount);
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ // If the decision window has expired, the automatic sale wins over the seller action.
+ locals.currentDate = qpi.now();
+ if (!state.get().isAuctionTimerPaused && locals.auction.core.sellerDecisionDeadline <= locals.currentDate)
+ {
+ locals.finalizeStandardAuctionInput.auctionIndex = input.auctionIndex;
+ locals.finalizeStandardAuctionInput.currentDate = locals.currentDate;
+ CALL(FinalizeStandardAuction, locals.finalizeStandardAuctionInput, locals.finalizeStandardAuctionOutput);
+
+ output.errorCode = EAuctionError::AuctionClosed;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::ResolvePendingStandardAuction, output.errorCode, input.auctionIndex,
+ output.refundedAmount);
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ // Accepting finalizes the sale; rejecting refunds the bidder and returns the lot to the seller.
+ if (input.acceptSale)
+ {
+ locals.finalizeStandardAuctionInput.auctionIndex = input.auctionIndex;
+ locals.finalizeStandardAuctionInput.currentDate = locals.currentDate;
+ CALL(FinalizeStandardAuction, locals.finalizeStandardAuctionInput, locals.finalizeStandardAuctionOutput);
+ output.errorCode = locals.finalizeStandardAuctionOutput.success ? EAuctionError::Success : EAuctionError::AuctionClosed;
+ }
+ else
+ {
+ locals.rejectStandardAuctionInput.auctionIndex = input.auctionIndex;
+ locals.rejectStandardAuctionInput.currentDate = locals.currentDate;
+ CALL(RejectStandardAuction, locals.rejectStandardAuctionInput, locals.rejectStandardAuctionOutput);
+ output.refundedAmount = locals.rejectStandardAuctionOutput.refundedAmount;
+ output.errorCode = locals.rejectStandardAuctionOutput.success ? EAuctionError::Success : EAuctionError::AuctionClosed;
+ }
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::ResolvePendingStandardAuction, output.errorCode, input.auctionIndex,
+ output.refundedAmount);
+ logProcedureResult(locals.log);
+ }
+
+ /**
+ * @brief Overwrites the full auction fee configuration.
+ * @note Only the configured takeover coordinator can call this procedure.
+ */
+ PUBLIC_PROCEDURE_WITH_LOCALS(SetAuctionFees)
+ {
+ output.errorCode = EAuctionError::InvalidInput;
+ // Administrative procedures never consume invocation rewards.
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+
+ if (qpi.invocator() != state.get().takeoverCoordinator)
+ {
+ output.errorCode = EAuctionError::Forbidden;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::SetAuctionFees, output.errorCode, 0, 0);
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ // Validate all fee tiers together so no gross-proceeds tier can exceed 100 percent.
+ if (!isValidAuctionFeeConfiguration(input.privateAuctionFee, input.publicAuctionCreationFee, input.auctionCancellationFeeBasisPoints,
+ input.managementFeeBasisPoints, input.developmentFeeBasisPoints, input.takeoverCoordinatorFeeBasisPoints,
+ input.shareholderDividendBasisPoints, input.shareholderFeeBasisPointsTier1,
+ input.shareholderFeeBasisPointsTier2, input.shareholderFeeBasisPointsTier3,
+ input.shareholderFeeBasisPointsTier4))
+ {
+ output.errorCode = EAuctionError::InvalidInput;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::SetAuctionFees, output.errorCode, 0, 0);
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ state.mut().privateAuctionFee = input.privateAuctionFee;
+ state.mut().publicAuctionCreationFee = input.publicAuctionCreationFee;
+ state.mut().auctionCancellationFeeBasisPoints = input.auctionCancellationFeeBasisPoints;
+ state.mut().managementFeeBasisPoints = input.managementFeeBasisPoints;
+ state.mut().developmentFeeBasisPoints = input.developmentFeeBasisPoints;
+ state.mut().takeoverCoordinatorFeeBasisPoints = input.takeoverCoordinatorFeeBasisPoints;
+ state.mut().shareholderDividendBasisPoints = input.shareholderDividendBasisPoints;
+ state.mut().shareholderFeeBasisPointsTier1 = input.shareholderFeeBasisPointsTier1;
+ state.mut().shareholderFeeBasisPointsTier2 = input.shareholderFeeBasisPointsTier2;
+ state.mut().shareholderFeeBasisPointsTier3 = input.shareholderFeeBasisPointsTier3;
+ state.mut().shareholderFeeBasisPointsTier4 = input.shareholderFeeBasisPointsTier4;
+ output.errorCode = EAuctionError::Success;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::SetAuctionFees, output.errorCode, 0, 0);
+ logProcedureResult(locals.log);
+ }
+
+ /**
+ * @brief Updates every auction fee except the takeover coordinator-specific splits.
+ * @note Only the configured management wallet can call this procedure.
+ */
+ PUBLIC_PROCEDURE_WITH_LOCALS(SetAuctionFeesByManagement)
+ {
+ output.errorCode = EAuctionError::InvalidInput;
+
+ // Management can update operational fees, but takeover-specific fee parameters stay unchanged.
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+
+ if (qpi.invocator() != state.get().management)
+ {
+ output.errorCode = EAuctionError::Forbidden;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::SetAuctionFeesByManagement, output.errorCode, 0, 0);
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ if (!isValidAuctionFeeConfiguration(input.privateAuctionFee, input.publicAuctionCreationFee, input.auctionCancellationFeeBasisPoints,
+ input.managementFeeBasisPoints, input.developmentFeeBasisPoints,
+ state.get().takeoverCoordinatorFeeBasisPoints, state.get().shareholderDividendBasisPoints,
+ input.shareholderFeeBasisPointsTier1, input.shareholderFeeBasisPointsTier2,
+ input.shareholderFeeBasisPointsTier3, input.shareholderFeeBasisPointsTier4))
+ {
+ output.errorCode = EAuctionError::InvalidInput;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::SetAuctionFeesByManagement, output.errorCode, 0, 0);
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ state.mut().privateAuctionFee = input.privateAuctionFee;
+ state.mut().publicAuctionCreationFee = input.publicAuctionCreationFee;
+ state.mut().auctionCancellationFeeBasisPoints = input.auctionCancellationFeeBasisPoints;
+ state.mut().managementFeeBasisPoints = input.managementFeeBasisPoints;
+ state.mut().developmentFeeBasisPoints = input.developmentFeeBasisPoints;
+ state.mut().shareholderFeeBasisPointsTier1 = input.shareholderFeeBasisPointsTier1;
+ state.mut().shareholderFeeBasisPointsTier2 = input.shareholderFeeBasisPointsTier2;
+ state.mut().shareholderFeeBasisPointsTier3 = input.shareholderFeeBasisPointsTier3;
+ state.mut().shareholderFeeBasisPointsTier4 = input.shareholderFeeBasisPointsTier4;
+ output.errorCode = EAuctionError::Success;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::SetAuctionFeesByManagement, output.errorCode, 0, 0);
+ logProcedureResult(locals.log);
+ }
+
+ /**
+ * @brief Reassigns the management role to another wallet.
+ * @note Only the configured takeover coordinator can call this procedure.
+ */
+ PUBLIC_PROCEDURE_WITH_LOCALS(SetManagement)
+ {
+ output.errorCode = EAuctionError::InvalidInput;
+
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+
+ if (qpi.invocator() != state.get().takeoverCoordinator)
+ {
+ output.errorCode = EAuctionError::Forbidden;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::SetManagement, output.errorCode, 0, 0);
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ if (isZero(input.management))
+ {
+ output.errorCode = EAuctionError::InvalidInput;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::SetManagement, output.errorCode, 0, 0);
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ state.mut().management = input.management;
+ output.errorCode = EAuctionError::Success;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::SetManagement, output.errorCode, 0, 0);
+ logProcedureResult(locals.log);
+ }
+
+ /**
+ * @brief Configures the execution fee reserve guard that triggers an emergency pause on a sudden reserve drop.
+ * @note Only the configured takeover coordinator or management wallet can call this procedure.
+ */
+ PUBLIC_PROCEDURE_WITH_LOCALS(SetFeeReserveGuardConfig)
+ {
+ output.errorCode = EAuctionError::InvalidInput;
+ // Resetting the baseline forces the guard to start a fresh observation window.
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+
+ if (qpi.invocator() != state.get().takeoverCoordinator && qpi.invocator() != state.get().management)
+ {
+ output.errorCode = EAuctionError::Forbidden;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::SetFeeReserveGuardConfig, output.errorCode, 0, 0);
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ if (input.dropBasisPoints == 0 || input.dropBasisPoints > NOST_BASIS_POINTS_SCALE || input.windowSeconds == 0)
+ {
+ output.errorCode = EAuctionError::InvalidInput;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::SetFeeReserveGuardConfig, output.errorCode, 0, 0);
+ logProcedureResult(locals.log);
+ return;
+ }
+
+ state.mut().feeReserveGuardDropBasisPoints = input.dropBasisPoints;
+ state.mut().feeReserveGuardWindowSeconds = input.windowSeconds;
+ state.mut().feeReserveBaselineAt.setInvalid();
+ output.errorCode = EAuctionError::Success;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::SetFeeReserveGuardConfig, output.errorCode, 0, 0);
+ logProcedureResult(locals.log);
+ }
+
+ /**
+ * @brief Manually pauses or resumes every auction interaction, overriding the automatic execution fee reserve guard.
+ * @note Only the configured takeover coordinator or management wallet can call this procedure. Resuming clears the guard window so a stale
+ * baseline cannot immediately retrigger the pause.
+ */
+ PUBLIC_PROCEDURE_WITH_LOCALS(SetEmergencyPause)
+ {
+ output.errorCode = EAuctionError::InvalidInput;
+ // Manual pause shares the same state as the automatic reserve guard.
+ if (qpi.invocationReward() > 0)
+ {
+ qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ }
+
+ if (qpi.invocator() != state.get().takeoverCoordinator && qpi.invocator() != state.get().management)
+ {
+ output.errorCode = EAuctionError::Forbidden;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::SetEmergencyPause, output.errorCode, 0, 0);
+ logProcedureResult(locals.log);
+ return;
}
- if (qpi.invocationReward() < NOSTROMO_QX_TOKEN_ISSUANCE_FEE)
+ if (input.paused)
{
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
+ state.mut().isEmergencyPaused = 1;
+ state.mut().emergencyPausedAt = qpi.now();
}
-
- if (qpi.invocationReward() > NOSTROMO_QX_TOKEN_ISSUANCE_FEE)
+ else
{
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - NOSTROMO_QX_TOKEN_ISSUANCE_FEE);
+ state.mut().isEmergencyPaused = 0;
+ state.mut().emergencyPausedAt.setInvalid();
+ state.mut().feeReserveBaselineAt.setInvalid();
}
- locals.tmpProject = state.get().projects.get(input.indexOfProject);
- locals.tmpProject.isCreatedFundarasing = 1;
- state.mut().projects.set(input.indexOfProject, locals.tmpProject);
-
- locals.newFundraising.tokenPrice = input.tokenPrice;
- locals.newFundraising.soldAmount = input.soldAmount;
- locals.newFundraising.requiredFunds = input.requiredFunds;
- locals.newFundraising.raisedFunds = 0;
- locals.newFundraising.indexOfProject = input.indexOfProject;
- locals.newFundraising.firstPhaseStartDate = locals.firstPhaseStartDate;
- locals.newFundraising.firstPhaseEndDate = locals.firstPhaseEndDate;
- locals.newFundraising.secondPhaseStartDate = locals.secondPhaseStartDate;
- locals.newFundraising.secondPhaseEndDate = locals.secondPhaseEndDate;
- locals.newFundraising.thirdPhaseStartDate = locals.thirdPhaseStartDate;
- locals.newFundraising.thirdPhaseEndDate = locals.thirdPhaseEndDate;
- locals.newFundraising.listingStartDate = locals.listingStartDate;
- locals.newFundraising.cliffEndDate = locals.cliffEndDate;
- locals.newFundraising.vestingEndDate = locals.vestingEndDate;
- locals.newFundraising.threshold = input.threshold;
- locals.newFundraising.TGE = input.TGE;
- locals.newFundraising.stepOfVesting = input.stepOfVesting;
-
- state.mut().fundaraisings.set(state.get().numberOfFundraising, locals.newFundraising);
- state.mut().numberOfFundraising++;
+ output.errorCode = EAuctionError::Success;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::SetEmergencyPause, output.errorCode, 0, 0);
+ logProcedureResult(locals.log);
}
- struct investInProject_locals
- {
- QX::IssueAsset_input input;
- QX::IssueAsset_output output;
- QX::TransferShareManagementRights_input TransferShareManagementRightsInput;
- QX::TransferShareManagementRights_output TransferShareManagementRightsOutput;
- investInfo tmpInvestData;
- fundaraisingInfo tmpFundraising;
- uint64 maxCap, minCap, maxInvestmentPerUser, userInvestedAmount;
- uint32 curDate, elementIndex, i, numberOfInvestedProjects;
- uint8 tierLevel;
- };
-
- PUBLIC_PROCEDURE_WITH_LOCALS(investInProject)
+ /**
+ * @brief Returns the stored state of one auction.
+ * @note The response contains a serializable auction view; access-control containers are returned as fixed arrays with counts.
+ */
+ PUBLIC_FUNCTION_WITH_LOCALS(GetAuctionByIndex)
{
- if (input.indexOfFundraising >= state.get().numberOfFundraising || qpi.invocationReward() == 0)
+ output.found = 0;
+ locals.findAuctionInput.auctionIndex = input.auctionIndex;
+ CALL(FindAuction, locals.findAuctionInput, locals.findAuctionOutput);
+ if (!locals.findAuctionOutput.found)
{
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
+ return;
}
+ locals.auction = locals.findAuctionOutput.auction;
- locals.maxCap = state.get().fundaraisings.get(input.indexOfFundraising).requiredFunds + div(state.get().fundaraisings.get(input.indexOfFundraising).requiredFunds * state.get().fundaraisings.get(input.indexOfFundraising).threshold, 100ULL);
- locals.minCap = state.get().fundaraisings.get(input.indexOfFundraising).requiredFunds - div(state.get().fundaraisings.get(input.indexOfFundraising).requiredFunds * state.get().fundaraisings.get(input.indexOfFundraising).threshold, 100ULL);
- if (state.get().numberOfInvestedProjects.get(qpi.invocator(), locals.numberOfInvestedProjects) && locals.numberOfInvestedProjects >= NOSTROMO_MAX_NUMBER_OF_PROJECT_USER_INVEST)
+ output.found = 1;
+ output.auction.core = locals.auction.core;
+
+ // Hash containers are flattened into arrays because they are not part of the public ABI surface.
+ output.auction.requiredAccessAssetCount = 0;
+ for (locals.requiredAccessAssetSetIndex = locals.auction.requiredAccessAssets.nextElementIndex(NULL_INDEX);
+ locals.requiredAccessAssetSetIndex != NULL_INDEX;
+ locals.requiredAccessAssetSetIndex = locals.auction.requiredAccessAssets.nextElementIndex(locals.requiredAccessAssetSetIndex))
{
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
+ locals.requiredAccessAsset.asset = locals.auction.requiredAccessAssets.key(locals.requiredAccessAssetSetIndex);
+ locals.requiredAccessAsset.quantity = locals.auction.requiredAccessAssets.value(locals.requiredAccessAssetSetIndex);
+ output.auction.requiredAccessAssets.set(output.auction.requiredAccessAssetCount, locals.requiredAccessAsset);
+ output.auction.requiredAccessAssetCount = sadd(output.auction.requiredAccessAssetCount, 1ULL);
}
- packNostromoDate(qpi.year(), qpi.month(), qpi.day(), qpi.hour(), qpi.minute(), qpi.second(), locals.curDate);
-
- locals.tmpFundraising = state.get().fundaraisings.get(input.indexOfFundraising);
-
- if (locals.curDate >= state.get().fundaraisings.get(input.indexOfFundraising).firstPhaseStartDate && locals.curDate < state.get().fundaraisings.get(input.indexOfFundraising).firstPhaseEndDate)
+ output.auction.allowedBidderWalletCount = 0;
+ for (locals.allowedBidderWalletSetIndex = locals.auction.allowedBidderWallets.nextElementIndex(NULL_INDEX);
+ locals.allowedBidderWalletSetIndex != NULL_INDEX;
+ locals.allowedBidderWalletSetIndex = locals.auction.allowedBidderWallets.nextElementIndex(locals.allowedBidderWalletSetIndex))
{
- if (state.get().users.contains(qpi.invocator()) == 0)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
- }
-
- state.get().users.get(qpi.invocator(), locals.tierLevel);
- switch (locals.tierLevel)
- {
- case 1:
- locals.maxInvestmentPerUser = div(locals.maxCap * NOSTROMO_TIER_FACEHUGGER_POOL_WEIGHT, state.get().totalPoolWeight);
- break;
- case 2:
- locals.maxInvestmentPerUser = div(locals.maxCap * NOSTROMO_TIER_CHESTBURST_POOL_WEIGHT, state.get().totalPoolWeight);
- break;
- case 3:
- locals.maxInvestmentPerUser = div(locals.maxCap * NOSTROMO_TIER_DOG_POOL_WEIGHT, state.get().totalPoolWeight);
- break;
- case 4:
- locals.maxInvestmentPerUser = div(locals.maxCap * NOSTROMO_TIER_XENOMORPH_POOL_WEIGHT, state.get().totalPoolWeight);
- break;
- case 5:
- locals.maxInvestmentPerUser = div(locals.maxCap * NOSTROMO_TIER_WARRIOR_POOL_WEIGHT, state.get().totalPoolWeight);
- break;
- default:
- break;
- }
-
- state.get().investors.get(qpi.invocator(), state.mut().tmpInvestedList);
- state.get().numberOfInvestedProjects.get(qpi.invocator(), locals.numberOfInvestedProjects);
-
- for (locals.i = 0; locals.i < locals.numberOfInvestedProjects; locals.i++)
- {
- if (state.get().tmpInvestedList.get(locals.i).indexOfFundraising == input.indexOfFundraising)
- {
- locals.userInvestedAmount = state.get().tmpInvestedList.get(locals.i).investedAmount;
- break;
- }
- }
-
- locals.tmpInvestData.indexOfFundraising = input.indexOfFundraising;
-
- if (locals.i < locals.numberOfInvestedProjects)
- {
- if (locals.tmpFundraising.raisedFunds + locals.maxInvestmentPerUser - locals.userInvestedAmount > locals.maxCap)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
- }
- if (qpi.invocationReward() + locals.userInvestedAmount > locals.maxInvestmentPerUser)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward() + locals.userInvestedAmount - locals.maxInvestmentPerUser);
-
- locals.tmpInvestData.investedAmount = locals.maxInvestmentPerUser;
- locals.tmpFundraising.raisedFunds += locals.maxInvestmentPerUser - locals.userInvestedAmount;
- }
- else
- {
- locals.tmpInvestData.investedAmount = qpi.invocationReward() + locals.userInvestedAmount;
- locals.tmpFundraising.raisedFunds += qpi.invocationReward();
- }
- state.mut().tmpInvestedList.set(locals.i, locals.tmpInvestData);
- state.mut().investors.set(qpi.invocator(), state.get().tmpInvestedList);
- }
- else
- {
- if (locals.tmpFundraising.raisedFunds + locals.maxInvestmentPerUser > locals.maxCap)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
- }
- if (qpi.invocationReward() > (sint64)locals.maxInvestmentPerUser)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - locals.maxInvestmentPerUser);
- locals.tmpInvestData.investedAmount = locals.maxInvestmentPerUser;
- locals.tmpFundraising.raisedFunds += locals.maxInvestmentPerUser;
- }
- else
- {
- locals.tmpInvestData.investedAmount = qpi.invocationReward();
- locals.tmpFundraising.raisedFunds += qpi.invocationReward();
- }
-
- state.mut().tmpInvestedList.set(locals.numberOfInvestedProjects, locals.tmpInvestData);
- state.mut().investors.set(qpi.invocator(), state.get().tmpInvestedList);
- if (state.get().numberOfInvestedProjects.get(qpi.invocator(), locals.numberOfInvestedProjects))
- {
- state.mut().numberOfInvestedProjects.set(qpi.invocator(), locals.numberOfInvestedProjects + 1);
- }
- else
- {
- state.mut().numberOfInvestedProjects.set(qpi.invocator(), 1);
- }
- }
+ locals.allowedBidderWallet = locals.auction.allowedBidderWallets.key(locals.allowedBidderWalletSetIndex);
+ output.auction.allowedBidderWallets.set(output.auction.allowedBidderWalletCount, locals.allowedBidderWallet);
+ output.auction.allowedBidderWalletCount = sadd(output.auction.allowedBidderWalletCount, 1ULL);
}
- else if (locals.curDate >= state.get().fundaraisings.get(input.indexOfFundraising).secondPhaseStartDate && locals.curDate < state.get().fundaraisings.get(input.indexOfFundraising).secondPhaseEndDate)
- {
- if (state.get().users.contains(qpi.invocator()) == 0)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
- }
-
- state.get().users.get(qpi.invocator(), locals.tierLevel);
- if (locals.tierLevel < 4)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
- }
- switch (locals.tierLevel)
- {
- case 4:
- locals.maxInvestmentPerUser = div(locals.maxCap * NOSTROMO_TIER_XENOMORPH_POOL_WEIGHT, state.get().totalPoolWeight);
- break;
- case 5:
- locals.maxInvestmentPerUser = div(locals.maxCap * NOSTROMO_TIER_WARRIOR_POOL_WEIGHT, state.get().totalPoolWeight);
- break;
- default:
- break;
- }
-
- state.get().investors.get(qpi.invocator(), state.mut().tmpInvestedList);
- state.get().numberOfInvestedProjects.get(qpi.invocator(), locals.numberOfInvestedProjects);
+ }
- for (locals.i = 0; locals.i < locals.numberOfInvestedProjects; locals.i++)
+ /**
+ * @brief Returns the stored bid state of one wallet in one auction.
+ * @note The response indicates whether a participant record exists for the requested auction and wallet.
+ */
+ PUBLIC_FUNCTION_WITH_LOCALS(GetAuctionParticipant)
+ {
+ output.found = 0;
+ locals.bestParticipantFound = 0;
+ // A wallet can have multiple historical batch bid slots; return the newest matching record.
+ for (locals.participantSlotIndex = 0; locals.participantSlotIndex < state.get().participants.capacity(); ++locals.participantSlotIndex)
+ {
+ locals.participantData = state.get().participants.get(locals.participantSlotIndex);
+ if (!locals.participantData.isUsed || locals.participantData.auctionIndex != input.auctionIndex ||
+ locals.participantData.participant != input.participant)
{
- if (state.get().tmpInvestedList.get(locals.i).indexOfFundraising == input.indexOfFundraising)
- {
- locals.userInvestedAmount = state.get().tmpInvestedList.get(locals.i).investedAmount;
- break;
- }
+ continue;
}
- locals.tmpInvestData.indexOfFundraising = input.indexOfFundraising;
-
- if (locals.i < locals.numberOfInvestedProjects)
- {
- if (locals.tmpFundraising.raisedFunds + locals.maxInvestmentPerUser - locals.userInvestedAmount > locals.maxCap)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
- }
- if (qpi.invocationReward() + locals.userInvestedAmount > locals.maxInvestmentPerUser)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward() + locals.userInvestedAmount - locals.maxInvestmentPerUser);
-
- locals.tmpInvestData.investedAmount = locals.maxInvestmentPerUser;
- locals.tmpFundraising.raisedFunds += locals.maxInvestmentPerUser - locals.userInvestedAmount;
- }
- else
- {
- locals.tmpInvestData.investedAmount = qpi.invocationReward() + locals.userInvestedAmount;
- locals.tmpFundraising.raisedFunds += qpi.invocationReward();
- }
- state.mut().tmpInvestedList.set(locals.i, locals.tmpInvestData);
- state.mut().investors.set(qpi.invocator(), state.get().tmpInvestedList);
- }
- else
+ if (!locals.bestParticipantFound || locals.participantData.bidIndex > output.participantData.bidIndex)
{
- if (locals.tmpFundraising.raisedFunds + locals.maxInvestmentPerUser > locals.maxCap)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
- }
- if (qpi.invocationReward() > (sint64)locals.maxInvestmentPerUser)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - locals.maxInvestmentPerUser);
- locals.tmpInvestData.investedAmount = locals.maxInvestmentPerUser;
- locals.tmpFundraising.raisedFunds += locals.maxInvestmentPerUser;
- }
- else
- {
- locals.tmpInvestData.investedAmount = qpi.invocationReward();
- locals.tmpFundraising.raisedFunds += qpi.invocationReward();
- }
-
- state.mut().tmpInvestedList.set(locals.numberOfInvestedProjects, locals.tmpInvestData);
- state.mut().investors.set(qpi.invocator(), state.get().tmpInvestedList);
- if (state.get().numberOfInvestedProjects.get(qpi.invocator(), locals.numberOfInvestedProjects))
- {
- state.mut().numberOfInvestedProjects.set(qpi.invocator(), locals.numberOfInvestedProjects + 1);
- }
- else
- {
- state.mut().numberOfInvestedProjects.set(qpi.invocator(), 1);
- }
+ locals.bestParticipantFound = 1;
+ locals.bestParticipantSlotIndex = locals.participantSlotIndex;
+ output.participantData = locals.participantData;
+ output.found = 1;
}
}
- else if (locals.curDate >= state.get().fundaraisings.get(input.indexOfFundraising).thirdPhaseStartDate && locals.curDate < state.get().fundaraisings.get(input.indexOfFundraising).thirdPhaseEndDate)
+ // Search archived slots as well because displaced and settled bids are removed from the live array.
+ for (locals.participantSlotIndex = 0; locals.participantSlotIndex < state.get().participantHistory.capacity(); ++locals.participantSlotIndex)
{
- if (locals.tmpFundraising.raisedFunds + qpi.invocationReward() > locals.maxCap)
+ locals.participantData = state.get().participantHistory.get(locals.participantSlotIndex);
+ if (!locals.participantData.isUsed || locals.participantData.auctionIndex != input.auctionIndex ||
+ locals.participantData.participant != input.participant)
{
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
+ continue;
}
- state.get().investors.get(qpi.invocator(), state.mut().tmpInvestedList);
- state.get().numberOfInvestedProjects.get(qpi.invocator(), locals.numberOfInvestedProjects);
-
- for (locals.i = 0; locals.i < locals.numberOfInvestedProjects; locals.i++)
+ if (!locals.bestParticipantFound || locals.participantData.bidIndex > output.participantData.bidIndex)
{
- if (state.get().tmpInvestedList.get(locals.i).indexOfFundraising == input.indexOfFundraising)
- {
- locals.userInvestedAmount = state.get().tmpInvestedList.get(locals.i).investedAmount;
- break;
- }
+ locals.bestParticipantFound = 1;
+ output.participantData = locals.participantData;
+ output.found = 1;
}
+ }
+ }
- locals.tmpInvestData.indexOfFundraising = input.indexOfFundraising;
-
- if (locals.i < locals.numberOfInvestedProjects)
- {
- locals.tmpInvestData.investedAmount = qpi.invocationReward() + locals.userInvestedAmount;
- state.mut().tmpInvestedList.set(locals.i, locals.tmpInvestData);
- state.mut().investors.set(qpi.invocator(), state.get().tmpInvestedList);
- }
- else
- {
- locals.tmpInvestData.investedAmount = qpi.invocationReward();
+ /**
+ * @brief Returns the remaining post-BEGIN_EPOCH pause before auction interactions resume.
+ * @note This getter exposes the 500-tick launch pause referenced by the auction timing rules.
+ */
+ PUBLIC_FUNCTION_WITH_LOCALS(GetTicksBeforeAuctionLaunch)
+ {
+ output.ticks = 0;
- state.mut().tmpInvestedList.set(locals.numberOfInvestedProjects, locals.tmpInvestData);
- state.mut().investors.set(qpi.invocator(), state.get().tmpInvestedList);
- if (state.get().numberOfInvestedProjects.get(qpi.invocator(), locals.numberOfInvestedProjects))
- {
- state.mut().numberOfInvestedProjects.set(qpi.invocator(), locals.numberOfInvestedProjects + 1);
- }
- else
- {
- state.mut().numberOfInvestedProjects.set(qpi.invocator(), 1);
- }
- }
- locals.tmpFundraising.raisedFunds += qpi.invocationReward();
- }
- else
+ if (!state.get().isPostBeginEpochPauseArmed)
{
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return ;
+ return;
}
- if (locals.minCap <= locals.tmpFundraising.raisedFunds && locals.tmpFundraising.isCreatedToken == 0)
- {
- locals.input.assetName = state.get().projects.get(locals.tmpFundraising.indexOfProject).tokenName;
- locals.input.numberOfDecimalPlaces = 0;
- locals.input.numberOfShares = state.get().projects.get(locals.tmpFundraising.indexOfProject).supplyOfToken;
- locals.input.unitOfMeasurement = 0;
- INVOKE_OTHER_CONTRACT_PROCEDURE(QX, IssueAsset, locals.input, locals.output, NOSTROMO_QX_TOKEN_ISSUANCE_FEE);
+ output.ticks = static_cast(max(static_cast(NOST_AUCTION_POST_BEGIN_EPOCH_PAUSE_TICKS) -
+ (static_cast(qpi.tick()) - static_cast(qpi.initialTick())),
+ 0));
+ }
- if (locals.output.issuedNumberOfShares == state.get().projects.get(locals.tmpFundraising.indexOfProject).supplyOfToken)
- {
- locals.tmpFundraising.isCreatedToken = 1;
+ /**
+ * @brief Returns the current auction fee configuration stored in contract state.
+ * @note The response includes creation, cancellation, revenue split, and tier-based shareholder fee parameters.
+ */
+ PUBLIC_FUNCTION(GetAuctionFees)
+ {
+ output.privateAuctionFee = state.get().privateAuctionFee;
+ output.auctionCancellationFeeBasisPoints = state.get().auctionCancellationFeeBasisPoints;
+ output.managementFeeBasisPoints = state.get().managementFeeBasisPoints;
+ output.developmentFeeBasisPoints = state.get().developmentFeeBasisPoints;
+ output.takeoverCoordinatorFeeBasisPoints = state.get().takeoverCoordinatorFeeBasisPoints;
+ output.shareholderDividendBasisPoints = state.get().shareholderDividendBasisPoints;
+ output.shareholderFeeBasisPointsTier1 = state.get().shareholderFeeBasisPointsTier1;
+ output.shareholderFeeBasisPointsTier2 = state.get().shareholderFeeBasisPointsTier2;
+ output.shareholderFeeBasisPointsTier3 = state.get().shareholderFeeBasisPointsTier3;
+ output.shareholderFeeBasisPointsTier4 = state.get().shareholderFeeBasisPointsTier4;
+ output.publicAuctionCreationFee = state.get().publicAuctionCreationFee;
+ }
- locals.TransferShareManagementRightsInput.asset.assetName = state.get().projects.get(locals.tmpFundraising.indexOfProject).tokenName;
- locals.TransferShareManagementRightsInput.asset.issuer = SELF;
- locals.TransferShareManagementRightsInput.newManagingContractIndex = SELF_INDEX;
- locals.TransferShareManagementRightsInput.numberOfShares = state.get().projects.get(locals.tmpFundraising.indexOfProject).supplyOfToken;
+ /**
+ * @brief Calculates the escrow, accumulated fee, and reward required by Batch Auction bid arithmetic.
+ * @param input Prospective bid quantity and price per asset; zero values are accepted for arithmetic inspection.
+ * @param output Saturating escrow product, small-bid fee, and saturating total reward.
+ * @note Non-zero escrow pays enough fee to reach `NOST_BATCH_BID_FEE_CUTOFF`; escrow at or above the cutoff pays no bid fee.
+ * @note This function does not validate whether `PlaceBid` would accept the bid or mutate contract state.
+ */
+ PUBLIC_FUNCTION(CalculateBatchAuctionBidFee) { calculateBatchAuctionBidFee(input.bidQuantity, input.bidAmount, output); }
- INVOKE_OTHER_CONTRACT_PROCEDURE(QX, TransferShareManagementRights, locals.TransferShareManagementRightsInput, locals.TransferShareManagementRightsOutput, 0);
+ /**
+ * @brief Returns the current wallets that receive auction fee transfers.
+ * @note The response exposes the configured management, development, and takeover coordinator addresses.
+ */
+ PUBLIC_FUNCTION(GetFeeRecipients)
+ {
+ output.management = state.get().management;
+ output.development = state.get().development;
+ output.takeoverCoordinator = state.get().takeoverCoordinator;
+ }
- qpi.transferShareOwnershipAndPossession(state.get().projects.get(locals.tmpFundraising.indexOfProject).tokenName, SELF, SELF, SELF, state.get().projects.get(locals.tmpFundraising.indexOfProject).supplyOfToken - locals.tmpFundraising.soldAmount, state.get().projects.get(locals.tmpFundraising.indexOfProject).creator);
+ /**
+ * @brief Returns the ring buffer with recently closed auctions.
+ * @note The buffer stores auction identifiers for both finalized and cancelled auctions.
+ * @note When `totalEntries` exceeds `NOST_AUCTION_HISTORY_NUM`, older entries are overwritten in ring-buffer order.
+ */
+ PUBLIC_FUNCTION_WITH_LOCALS(GetClosedAuctionHistory)
+ {
+ // Preserve physical ring positions to keep the existing auctionIndices ABI stable for clients.
+ for (locals.historyIndex = 0; locals.historyIndex < state.get().closedAuctionHistory.capacity(); ++locals.historyIndex)
+ {
+ locals.auction = state.get().closedAuctionHistory.get(locals.historyIndex);
+ if (locals.auction.core.status != EAuctionStatus::None)
+ {
+ output.auctionIndices.set(locals.historyIndex, locals.auction.core.auctionIndex);
}
}
+ output.totalEntries = state.get().closedAuctionHistoryCounter;
+ }
- state.mut().fundaraisings.set(input.indexOfFundraising, locals.tmpFundraising);
+ /**
+ * @brief Returns whether the temporary fee override routes every fee to development.
+ */
+ PUBLIC_FUNCTION(GetRouteAllFeesToDevelopment) { output.enabled = state.get().routeAllFeesToDevelopment; }
+
+ /**
+ * @brief Returns the aggregate shared fee amount awaiting `END_EPOCH` settlement.
+ * @note The legacy field name is retained for ABI compatibility.
+ */
+ PUBLIC_FUNCTION(GetPendingServiceFeePool) { output.pendingServiceFeePool = getNostromoFeePoolTotal(state.get().feePool); }
+ /** @brief Returns every accumulator in the shared Nostromo fee pool. */
+ PUBLIC_FUNCTION(GetNostromoFeePool)
+ {
+ output.feePool = state.get().feePool;
+ output.totalAmount = getNostromoFeePoolTotal(state.get().feePool);
}
- struct claimToken_locals
+ /** @brief Returns the QU obligation currently registered for one wallet. */
+ PUBLIC_FUNCTION(GetPendingPayout)
{
- investInfo tmpInvestData;
- uint64 maxClaimAmount, investedAmount, dayA, dayB, start_cur_diffSecond, cur_end_diffSecond, claimedAmount;
- uint32 curDate, tmpDate, numberOfInvestedProjects;
- sint32 i, j;
- uint8 curVestingStep, vestingPercent;
- };
+ output.amount = 0;
+ state.get().pendingQuPayouts.get(input.account, output.amount);
+ }
- PUBLIC_PROCEDURE_WITH_LOCALS(claimToken)
+ /**
+ * @brief Returns the current state of the execution fee reserve guard, including a live reserve reading.
+ */
+ PUBLIC_FUNCTION(GetFeeReserveGuardState)
{
- packNostromoDate(qpi.year(), qpi.month(), qpi.day(), qpi.hour(), qpi.minute(), qpi.second(), locals.curDate);
+ output.currentFeeReserve = qpi.queryFeeReserve(SELF_INDEX);
+ output.feeReserveBaseline = state.get().feeReserveBaseline;
+ output.feeReserveBaselineAt = state.get().feeReserveBaselineAt;
+ output.emergencyPausedAt = state.get().emergencyPausedAt;
+ output.dropBasisPoints = state.get().feeReserveGuardDropBasisPoints;
+ output.windowSeconds = state.get().feeReserveGuardWindowSeconds;
+ output.isEmergencyPaused = state.get().isEmergencyPaused;
+ }
- if (input.indexOfFundraising >= state.get().numberOfFundraising)
+ /**
+ * @brief Returns aggregate auction, participant, fee, and pause counters.
+ */
+ PUBLIC_FUNCTION_WITH_LOCALS(GetContractStats)
+ {
+ output.stats.totalAuctionsCreated = state.get().totalAuctionsCreated;
+ output.stats.closedAuctionHistoryCounter = state.get().closedAuctionHistoryCounter;
+ output.stats.auctionShareholderDividendPool = state.get().auctionShareholderDividendPool;
+ output.stats.pendingServiceFeePool = getNostromoFeePoolTotal(state.get().feePool);
+ output.stats.totalPendingQuPayouts = state.get().totalPendingQuPayouts;
+ output.stats.retainedClosedAuctionCount = min(state.get().closedAuctionHistoryCounter, state.get().closedAuctionHistory.capacity());
+ output.stats.retainedParticipantHistoryCount = min(state.get().participantHistoryCounter, state.get().participantHistory.capacity());
+ output.stats.finalizedAuctionCount = state.get().totalFinalizedAuctions;
+ output.stats.cancelledAuctionCount = state.get().totalCancelledAuctions;
+ output.stats.qxTransferFee = state.get().qxTransferFee;
+ output.stats.routeAllFeesToDevelopment = state.get().routeAllFeesToDevelopment;
+ output.stats.isAuctionTimerPaused = state.get().isAuctionTimerPaused;
+ output.stats.isPostBeginEpochPauseArmed = state.get().isPostBeginEpochPauseArmed;
+ output.stats.isEmergencyPaused = state.get().isEmergencyPaused;
+
+ // Stats scan fixed storage because participant slots and auction records are not separately indexed by status.
+ for (locals.participantSlotIndex = 0; locals.participantSlotIndex < state.get().participants.capacity(); ++locals.participantSlotIndex)
{
- return ;
+ locals.participantData = state.get().participants.get(locals.participantSlotIndex);
+ if (locals.participantData.isUsed)
+ {
+ output.stats.participantCount = sadd(output.stats.participantCount, 1ULL);
+ }
}
- state.get().investors.get(qpi.invocator(), state.mut().tmpInvestedList);
- if (state.get().numberOfInvestedProjects.get(qpi.invocator(), locals.numberOfInvestedProjects) == 0)
+ for (locals.auctionElementIndex = state.get().auctionList.nextElementIndex(NULL_INDEX); locals.auctionElementIndex != NULL_INDEX;
+ locals.auctionElementIndex = state.get().auctionList.nextElementIndex(locals.auctionElementIndex))
{
- return ;
+ locals.auction = state.get().auctionList.value(locals.auctionElementIndex);
+ switch (locals.auction.core.status)
+ {
+ case EAuctionStatus::Active: output.stats.activeAuctionCount = sadd(output.stats.activeAuctionCount, 1ULL); break;
+ case EAuctionStatus::PendingSellerDecision:
+ output.stats.pendingSellerDecisionAuctionCount = sadd(output.stats.pendingSellerDecisionAuctionCount, 1ULL);
+ break;
+ default: break;
+ }
}
+ }
- for (locals.i = 0; locals.i < (sint32)locals.numberOfInvestedProjects; locals.i++)
+ /**
+ * @brief Returns a page of auction summaries ordered by creation index.
+ */
+ PUBLIC_FUNCTION_WITH_LOCALS(GetAuctionSummaries)
+ {
+ // Live and archived records are disjoint, so the retained total does not require an ordered scan.
+ output.totalCount =
+ sadd(state.get().auctionList.population(), min(state.get().closedAuctionHistoryCounter, state.get().closedAuctionHistory.capacity()));
+ output.returnedCount = 0;
+ locals.boundedLimit = min(input.limit, NOST_AUCTION_GETTER_PAGE_SIZE);
+ if (locals.boundedLimit == 0 || input.offset >= output.totalCount)
+ {
+ return;
+ }
+ locals.scannedAuctionCount = 0;
+ locals.selectNextAuctionInput.hasAfterAuctionIndex = 0;
+ locals.selectNextAuctionInput.includeClosedAuctions = 1;
+ locals.selectNextAuctionInput.filterBySeller = 0;
+ // Cursor selection reconstructs creation order across unordered live storage and the closed-history ring.
+ while (output.returnedCount < locals.boundedLimit && locals.scannedAuctionCount < output.totalCount)
{
- if (state.get().tmpInvestedList.get(locals.i).indexOfFundraising == input.indexOfFundraising)
+ CALL(SelectNextRetainedAuction, locals.selectNextAuctionInput, locals.selectNextAuctionOutput);
+ if (!locals.selectNextAuctionOutput.found)
{
- locals.investedAmount = state.get().tmpInvestedList.get(locals.i).investedAmount;
- locals.claimedAmount = state.get().tmpInvestedList.get(locals.i).claimedAmount;
- locals.tmpInvestData = state.get().tmpInvestedList.get(locals.i);
break;
}
+ locals.auction = locals.selectNextAuctionOutput.auction;
+ // Skip only the requested prefix; the exact total is already available without scanning the remainder.
+ if (locals.scannedAuctionCount >= input.offset)
+ {
+ fillAuctionSummary(locals.auction, locals.auctionSummary);
+ output.auctions.set(output.returnedCount, locals.auctionSummary);
+ output.returnedCount = sadd(output.returnedCount, 1ULL);
+ }
+ locals.scannedAuctionCount = sadd(locals.scannedAuctionCount, 1ULL);
+ locals.selectNextAuctionInput.afterAuctionIndex = locals.auction.core.auctionIndex;
+ locals.selectNextAuctionInput.hasAfterAuctionIndex = 1;
}
+ }
- if (locals.i == locals.numberOfInvestedProjects)
+ /**
+ * @brief Returns a page of active or pending-seller-decision auction indices.
+ */
+ PUBLIC_FUNCTION_WITH_LOCALS(GetActiveAuctionIndices)
+ {
+ // Invariant: terminal auctions are archived and removed, so every live-map entry is active or awaiting a seller decision.
+ output.totalCount = state.get().auctionList.population();
+ output.returnedCount = 0;
+ locals.boundedLimit = min(input.limit, NOST_AUCTION_GETTER_PAGE_SIZE);
+ if (locals.boundedLimit == 0 || input.offset >= output.totalCount)
{
- return ;
+ return;
}
- if (locals.curDate >= state.get().fundaraisings.get(input.indexOfFundraising).listingStartDate && locals.curDate < state.get().fundaraisings.get(input.indexOfFundraising).cliffEndDate)
+ locals.scannedAuctionCount = 0;
+ locals.selectNextAuctionInput.hasAfterAuctionIndex = 0;
+ locals.selectNextAuctionInput.includeClosedAuctions = 0;
+ locals.selectNextAuctionInput.filterBySeller = 0;
+ // Select only the requested live-map prefix and page; closed history cannot contain active auctions.
+ while (output.returnedCount < locals.boundedLimit && locals.scannedAuctionCount < output.totalCount)
{
- locals.maxClaimAmount = div(div(locals.investedAmount, state.get().fundaraisings.get(input.indexOfFundraising).tokenPrice) * state.get().fundaraisings.get(input.indexOfFundraising).TGE, 100ULL);
+ CALL(SelectNextRetainedAuction, locals.selectNextAuctionInput, locals.selectNextAuctionOutput);
+ if (!locals.selectNextAuctionOutput.found)
+ {
+ break;
+ }
+ locals.selectNextAuctionInput.afterAuctionIndex = locals.selectNextAuctionOutput.auction.core.auctionIndex;
+ locals.selectNextAuctionInput.hasAfterAuctionIndex = 1;
+ if (locals.scannedAuctionCount >= input.offset)
+ {
+ output.auctionIndices.set(output.returnedCount, locals.selectNextAuctionOutput.auction.core.auctionIndex);
+ output.returnedCount = sadd(output.returnedCount, 1ULL);
+ }
+ locals.scannedAuctionCount = sadd(locals.scannedAuctionCount, 1ULL);
}
- else if (locals.curDate >= state.get().fundaraisings.get(input.indexOfFundraising).cliffEndDate && locals.curDate < state.get().fundaraisings.get(input.indexOfFundraising).vestingEndDate)
- {
- locals.tmpDate = state.get().fundaraisings.get(input.indexOfFundraising).cliffEndDate;
- diffDateInSecond(locals.tmpDate, locals.curDate, locals.j, locals.dayA, locals.dayB, locals.start_cur_diffSecond);
- locals.tmpDate = state.get().fundaraisings.get(input.indexOfFundraising).vestingEndDate;
- diffDateInSecond(locals.curDate, locals.tmpDate, locals.j, locals.dayA, locals.dayB, locals.cur_end_diffSecond);
+ }
- locals.curVestingStep = (uint8)div(locals.start_cur_diffSecond, div(locals.start_cur_diffSecond + locals.cur_end_diffSecond, state.get().fundaraisings.get(input.indexOfFundraising).stepOfVesting * 1ULL)) + 1;
- locals.vestingPercent = (uint8)div(100ULL - state.get().fundaraisings.get(input.indexOfFundraising).TGE, state.get().fundaraisings.get(input.indexOfFundraising).stepOfVesting * 1ULL) * locals.curVestingStep;
- locals.maxClaimAmount = div(div(locals.investedAmount, state.get().fundaraisings.get(input.indexOfFundraising).tokenPrice) * (state.get().fundaraisings.get(input.indexOfFundraising).TGE + locals.vestingPercent), 100ULL);
- }
- else if (locals.curDate >= state.get().fundaraisings.get(input.indexOfFundraising).vestingEndDate)
+ /**
+ * @brief Returns a page of auction summaries created by a seller.
+ */
+ PUBLIC_FUNCTION_WITH_LOCALS(GetAuctionsBySeller)
+ {
+ output.returnedCount = 0;
+ locals.countAuctionsInput.seller = input.seller;
+ CALL(CountRetainedAuctionsBySeller, locals.countAuctionsInput, locals.countAuctionsOutput);
+ output.totalCount = locals.countAuctionsOutput.count;
+ locals.boundedLimit = min(input.limit, NOST_AUCTION_GETTER_PAGE_SIZE);
+ if (locals.boundedLimit == 0 || input.offset >= output.totalCount)
{
- locals.maxClaimAmount = div(locals.investedAmount, state.get().fundaraisings.get(input.indexOfFundraising).tokenPrice);
+ return;
}
- if (input.amount + locals.claimedAmount > locals.maxClaimAmount)
- {
- return ;
- }
- else
+ locals.scannedAuctionCount = 0;
+ locals.selectNextAuctionInput.seller = input.seller;
+ locals.selectNextAuctionInput.hasAfterAuctionIndex = 0;
+ locals.selectNextAuctionInput.includeClosedAuctions = 1;
+ locals.selectNextAuctionInput.filterBySeller = 1;
+ // The selector skips other sellers, so only the requested seller's prefix and page are ordered.
+ while (output.returnedCount < locals.boundedLimit && locals.scannedAuctionCount < output.totalCount)
{
- qpi.transferShareOwnershipAndPossession(state.get().projects.get(state.get().fundaraisings.get(input.indexOfFundraising).indexOfProject).tokenName, SELF, SELF, SELF, input.amount, qpi.invocator());
- if (input.amount + locals.claimedAmount == locals.maxClaimAmount && state.get().fundaraisings.get(input.indexOfFundraising).vestingEndDate <= locals.curDate)
+ CALL(SelectNextRetainedAuction, locals.selectNextAuctionInput, locals.selectNextAuctionOutput);
+ if (!locals.selectNextAuctionOutput.found)
{
- state.mut().tmpInvestedList.set(locals.i, state.get().tmpInvestedList.get(locals.numberOfInvestedProjects - 1));
- state.mut().numberOfInvestedProjects.set(qpi.invocator(), locals.numberOfInvestedProjects - 1);
- }
- else
- {
- locals.tmpInvestData.claimedAmount = input.amount + locals.claimedAmount;
- state.mut().tmpInvestedList.set(locals.i, locals.tmpInvestData);
+ break;
}
- state.mut().investors.set(qpi.invocator(), state.get().tmpInvestedList);
- state.get().numberOfInvestedProjects.get(qpi.invocator(), locals.numberOfInvestedProjects);
- if (locals.numberOfInvestedProjects == 0)
+ locals.auction = locals.selectNextAuctionOutput.auction;
+ locals.selectNextAuctionInput.afterAuctionIndex = locals.auction.core.auctionIndex;
+ locals.selectNextAuctionInput.hasAfterAuctionIndex = 1;
+ if (locals.scannedAuctionCount >= input.offset)
{
- state.mut().investors.removeByKey(qpi.invocator());
- state.mut().numberOfInvestedProjects.removeByKey(qpi.invocator());
+ fillAuctionSummary(locals.auction, locals.auctionSummary);
+ output.auctions.set(output.returnedCount, locals.auctionSummary);
+ output.returnedCount = sadd(output.returnedCount, 1ULL);
}
- output.claimedAmount = input.amount;
+ locals.scannedAuctionCount = sadd(locals.scannedAuctionCount, 1ULL);
}
}
- struct upgradeTier_locals
+ /**
+ * @brief Looks up the first auction matching a metadata CID.
+ */
+ PUBLIC_FUNCTION_WITH_LOCALS(GetAuctionByMetadataCid)
{
- uint64 deltaAmount;
- uint32 i, deltaPoolWeight;
- uint8 currentTierLevel;
- };
+ output.found = 0;
+ output.auctionIndex = 0;
+ locals.findAuctionInput.metadataIpfsCid = input.metadataIpfsCid;
+ CALL(FindFirstRetainedAuctionByMetadataCid, locals.findAuctionInput, locals.findAuctionOutput);
+ // The helper compares all retained candidates and returns the smallest matching creation index.
+ if (!locals.findAuctionOutput.found)
+ {
+ return;
+ }
+ output.found = 1;
+ output.auctionIndex = locals.findAuctionOutput.auction.core.auctionIndex;
+ fillAuctionSummary(locals.findAuctionOutput.auction, output.auction);
+ }
- PUBLIC_PROCEDURE_WITH_LOCALS(upgradeTier)
+ /**
+ * @brief Returns auction summaries for a batch of requested indices.
+ */
+ PUBLIC_FUNCTION_WITH_LOCALS(GetAuctionSummariesByIndexBatch)
{
- if (state.get().users.contains(qpi.invocator()) == 0)
+ output.returnedCount = 0;
+ locals.boundedLimit = min(input.count, NOST_AUCTION_GETTER_PAGE_SIZE);
+ // Preserve input positions so callers can correlate each requested index with its found flag.
+ for (locals.requestedIndex = 0; locals.requestedIndex < locals.boundedLimit; ++locals.requestedIndex)
{
- if (qpi.invocationReward() > 0)
+ locals.auctionIndex = input.auctionIndices.get(locals.requestedIndex);
+ locals.findAuctionInput.auctionIndex = locals.auctionIndex;
+ CALL(FindAuction, locals.findAuctionInput, locals.findAuctionOutput);
+ if (locals.findAuctionOutput.found)
{
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ locals.auction = locals.findAuctionOutput.auction;
+ fillAuctionSummary(locals.auction, locals.auctionSummary);
+ output.auctions.set(locals.requestedIndex, locals.auctionSummary);
+ output.found.set(locals.requestedIndex, 1);
+ output.returnedCount = sadd(output.returnedCount, 1ULL);
}
- return ;
}
+ }
- state.get().users.get(qpi.invocator(), locals.currentTierLevel);
-
- switch (locals.currentTierLevel)
- {
- case 1:
- locals.deltaAmount = NOSTROMO_TIER_CHESTBURST_STAKE_AMOUNT - NOSTROMO_TIER_FACEHUGGER_STAKE_AMOUNT;
- locals.deltaPoolWeight = NOSTROMO_TIER_CHESTBURST_POOL_WEIGHT - NOSTROMO_TIER_FACEHUGGER_POOL_WEIGHT;
- break;
- case 2:
- locals.deltaAmount = NOSTROMO_TIER_DOG_STAKE_AMOUNT - NOSTROMO_TIER_CHESTBURST_STAKE_AMOUNT;
- locals.deltaPoolWeight = NOSTROMO_TIER_DOG_POOL_WEIGHT - NOSTROMO_TIER_CHESTBURST_POOL_WEIGHT;
- break;
- case 3:
- locals.deltaAmount = NOSTROMO_TIER_XENOMORPH_STAKE_AMOUNT - NOSTROMO_TIER_DOG_STAKE_AMOUNT;
- locals.deltaPoolWeight = NOSTROMO_TIER_XENOMORPH_POOL_WEIGHT - NOSTROMO_TIER_DOG_POOL_WEIGHT;
- break;
- case 4:
- locals.deltaAmount = NOSTROMO_TIER_WARRIOR_STAKE_AMOUNT - NOSTROMO_TIER_XENOMORPH_STAKE_AMOUNT;
- locals.deltaPoolWeight = NOSTROMO_TIER_WARRIOR_POOL_WEIGHT - NOSTROMO_TIER_XENOMORPH_POOL_WEIGHT;
- break;
- default:
- break;
- }
- if (input.newTierLevel != locals.currentTierLevel + 1 || qpi.invocationReward() < (sint64)locals.deltaAmount)
+ /**
+ * @brief Returns a page of participants for one auction.
+ */
+ PUBLIC_FUNCTION_WITH_LOCALS(GetAuctionParticipants)
+ {
+ output.totalCount = 0;
+ output.returnedCount = 0;
+ locals.boundedLimit = min(input.limit, NOST_AUCTION_GETTER_PAGE_SIZE);
+ // Participant storage is global, so auction participant pages are built by scanning all slots.
+ for (locals.participantSlotIndex = 0; locals.participantSlotIndex < state.get().participants.capacity(); ++locals.participantSlotIndex)
{
- if (qpi.invocationReward() > 0)
+ locals.participantData = state.get().participants.get(locals.participantSlotIndex);
+ if (!locals.participantData.isUsed || locals.participantData.auctionIndex != input.auctionIndex)
{
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ continue;
+ }
+ if (output.totalCount >= input.offset && output.returnedCount < locals.boundedLimit)
+ {
+ fillParticipantSummary(locals.participantData, locals.participantSummary);
+ output.participants.set(output.returnedCount, locals.participantSummary);
+ output.returnedCount = sadd(output.returnedCount, 1ULL);
}
- return ;
+ output.totalCount = sadd(output.totalCount, 1ULL);
}
- else
+ // Append archived records after live records so an offset spans both storage tiers deterministically.
+ for (locals.participantSlotIndex = 0; locals.participantSlotIndex < state.get().participantHistory.capacity(); ++locals.participantSlotIndex)
{
- state.mut().users.set(qpi.invocator(), input.newTierLevel);
- if (qpi.invocationReward() > (sint64)locals.deltaAmount)
+ locals.participantData = state.get().participantHistory.get(locals.participantSlotIndex);
+ if (!locals.participantData.isUsed || locals.participantData.auctionIndex != input.auctionIndex)
+ {
+ continue;
+ }
+ if (output.totalCount >= input.offset && output.returnedCount < locals.boundedLimit)
{
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - locals.deltaAmount);
+ fillParticipantSummary(locals.participantData, locals.participantSummary);
+ output.participants.set(output.returnedCount, locals.participantSummary);
+ output.returnedCount = sadd(output.returnedCount, 1ULL);
}
- state.mut().totalPoolWeight += locals.deltaPoolWeight;
+ output.totalCount = sadd(output.totalCount, 1ULL);
}
}
- PUBLIC_PROCEDURE(TransferShareManagementRights)
+ /**
+ * @brief Returns a page of historical auction participations for one wallet.
+ */
+ PUBLIC_FUNCTION_WITH_LOCALS(GetUserParticipations)
{
- if (qpi.invocationReward() < state.get().transferRightsFee)
- {
- return ;
- }
-
- if (qpi.numberOfPossessedShares(input.asset.assetName, input.asset.issuer,qpi.invocator(), qpi.invocator(), SELF_INDEX, SELF_INDEX) < input.numberOfShares)
+ output.totalCount = 0;
+ output.returnedCount = 0;
+ locals.boundedLimit = min(input.limit, NOST_AUCTION_GETTER_PAGE_SIZE);
+ // User participation history includes inactive records so settled and displaced bids remain visible.
+ for (locals.participantSlotIndex = 0; locals.participantSlotIndex < state.get().participants.capacity(); ++locals.participantSlotIndex)
{
- // not enough shares available
- output.transferredNumberOfShares = 0;
- if (qpi.invocationReward() > 0)
+ locals.participantData = state.get().participants.get(locals.participantSlotIndex);
+ if (!locals.participantData.isUsed || locals.participantData.participant != input.participant)
{
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
+ continue;
+ }
+ if (output.totalCount >= input.offset && output.returnedCount < locals.boundedLimit)
+ {
+ fillUserParticipationSummary(locals.participantData.auctionIndex, locals.participantData, locals.userParticipationSummary);
+ output.participations.set(output.returnedCount, locals.userParticipationSummary);
+ output.returnedCount = sadd(output.returnedCount, 1ULL);
}
+ output.totalCount = sadd(output.totalCount, 1ULL);
}
- else
+ // Continue the same page over archived bids after accounting for matching live entries.
+ for (locals.participantSlotIndex = 0; locals.participantSlotIndex < state.get().participantHistory.capacity(); ++locals.participantSlotIndex)
{
- if (qpi.releaseShares(input.asset, qpi.invocator(), qpi.invocator(), input.numberOfShares,
- input.newManagingContractIndex, input.newManagingContractIndex, state.get().transferRightsFee) < 0)
+ locals.participantData = state.get().participantHistory.get(locals.participantSlotIndex);
+ if (!locals.participantData.isUsed || locals.participantData.participant != input.participant)
{
- // error
- output.transferredNumberOfShares = 0;
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
+ continue;
}
- else
+ if (output.totalCount >= input.offset && output.returnedCount < locals.boundedLimit)
{
- // success
- output.transferredNumberOfShares = input.numberOfShares;
- if (qpi.invocationReward() > state.get().transferRightsFee)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - state.get().transferRightsFee);
- }
+ fillUserParticipationSummary(locals.participantData.auctionIndex, locals.participantData, locals.userParticipationSummary);
+ output.participations.set(output.returnedCount, locals.userParticipationSummary);
+ output.returnedCount = sadd(output.returnedCount, 1ULL);
}
+ output.totalCount = sadd(output.totalCount, 1ULL);
}
}
- PUBLIC_FUNCTION(getStats)
+ /**
+ * @brief Returns the most recently created auction index when one exists.
+ */
+ PUBLIC_FUNCTION(GetLatestAuctionIndex)
{
- output.epochRevenue = state.get().epochRevenue;
- output.numberOfCreatedProject = state.get().numberOfCreatedProject;
- output.numberOfFundraising = state.get().numberOfFundraising;
- output.numberOfRegister = state.get().numberOfRegister;
- output.totalPoolWeight = state.get().totalPoolWeight;
+ output.found = state.get().totalAuctionsCreated > 0;
+ output.auctionIndex = output.found ? state.get().totalAuctionsCreated - 1 : 0;
}
- PUBLIC_FUNCTION(getTierLevelByUser)
+ /**
+ * @brief Counts auctions created by a seller.
+ */
+ PUBLIC_FUNCTION_WITH_LOCALS(GetAuctionCountBySeller)
{
- state.get().users.get(input.userId, output.tierLevel);
+ locals.countAuctionsInput.seller = input.seller;
+ CALL(CountRetainedAuctionsBySeller, locals.countAuctionsInput, locals.countAuctionsOutput);
+ output.count = locals.countAuctionsOutput.count;
}
- PUBLIC_FUNCTION(getUserVoteStatus)
+ /**
+ * @brief Returns immutable creation-time fields for an auction.
+ */
+ PUBLIC_FUNCTION_WITH_LOCALS(GetAuctionAtCreationSnapshot)
{
- state.get().numberOfVotedProject.get(input.userId, output.numberOfVotedProjects);
- state.get().voteStatus.get(input.userId, output.projectIndexList);
+ output.found = 0;
+ locals.findAuctionInput.auctionIndex = input.auctionIndex;
+ CALL(FindAuction, locals.findAuctionInput, locals.findAuctionOutput);
+ if (!locals.findAuctionOutput.found)
+ {
+ return;
+ }
+ locals.auction = locals.findAuctionOutput.auction;
+ output.found = 1;
+ output.seller = locals.auction.core.seller;
+ output.createdAt = locals.auction.core.createdAt;
+ output.auctionIndex = locals.auction.core.auctionIndex;
+ output.quantityForSale = locals.auction.core.quantityForSale;
+ output.initialPrice = locals.auction.core.initialPrice;
+ output.salePrice = locals.auction.core.salePrice;
+ output.minimumBidIncrement = locals.auction.core.minimumBidIncrement;
+ output.buyNowPrice = locals.auction.core.buyNowPrice;
+ output.auctionDurationSeconds = locals.auction.core.auctionDurationSeconds;
+ output.type = static_cast(locals.auction.core.type);
+ output.visibility = static_cast(locals.auction.core.visibility);
}
- PUBLIC_FUNCTION(checkTokenCreatability)
+ /**
+ * @brief Returns current read-only guidance for the next valid Batch Auction bid.
+ * @note `found` also covers closed auctions while their snapshots remain in retained history.
+ * @note `PlaceBid` re-runs the same availability validation before accepting a bid.
+ */
+ PUBLIC_FUNCTION_WITH_LOCALS(GetBatchAuctionBidAvailability)
{
- output.result = state.get().tokens.contains(input.tokenName);
- }
+ locals.computeBatchBidAvailabilityInput.auctionIndex = input.auctionIndex;
+ locals.computeBatchBidAvailabilityInput.bidAmount = 0;
+ CALL(ComputeBatchBidAvailability, locals.computeBatchBidAvailabilityInput, output);
+ // Live auctions are fully classified by the availability helper, including non-Batch auctions.
+ if (output.found)
+ {
+ return;
+ }
- PUBLIC_FUNCTION(getNumberOfInvestedProjects)
- {
- state.get().numberOfInvestedProjects.get(input.userId, output.numberOfInvestedProjects);
+ // A retained closed auction still exists for lookup purposes, but can never accept another bid.
+ locals.isClosedAuctionRetainedInput.auctionIndex = input.auctionIndex;
+ CALL(IsClosedAuctionRetained, locals.isClosedAuctionRetainedInput, locals.isClosedAuctionRetainedOutput);
+ output.found = locals.isClosedAuctionRetainedOutput.found;
}
-public:
- struct getProjectByIndex_input
+ /**
+ * @brief Transfers share management rights for an asset position to another managing contract.
+ * @note The caller must currently possess at least the requested number of shares.
+ * @note The caller must send the destination contract's required transfer fee as invocation reward. This contract cannot query that
+ * fee before calling `releaseShares`, so callers must resolve it from `newManagingContractIndex`.
+ */
+ PUBLIC_PROCEDURE_WITH_LOCALS(TransferShareManagementRights)
{
- uint32 indexOfProject;
- };
+ locals.reward = qpi.invocationReward();
+ locals.refundAmount = locals.reward;
+ locals.success = false;
+ output.transferredNumberOfShares = 0;
+ output.errorCode = EAuctionError::InvalidInput;
+
+ // Emergency pause blocks cross-contract share release and returns the caller's fee budget.
+ if (state.get().isEmergencyPaused)
+ {
+ if (locals.refundAmount > 0)
+ {
+ qpi.transfer(qpi.invocator(), locals.refundAmount);
+ }
+ output.errorCode = EAuctionError::AuctionPaused;
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::TransferShareManagementRights, output.errorCode, 0,
+ output.transferredNumberOfShares);
+ logProcedureResult(locals.log);
+ return;
+ }
- struct getProjectByIndex_output
- {
- projectInfo project;
- };
+ // `releaseShares` consumes only the destination transfer fee; any unused reward is refunded below.
+ if (input.numberOfShares > 0 && qpi.numberOfPossessedShares(input.asset.assetName, input.asset.issuer, qpi.invocator(), qpi.invocator(),
+ SELF_INDEX, SELF_INDEX) >= input.numberOfShares)
+ {
+ locals.result = qpi.releaseShares(input.asset, qpi.invocator(), qpi.invocator(), input.numberOfShares, input.newManagingContractIndex,
+ input.newManagingContractIndex, locals.reward);
+ if (locals.result != INVALID_AMOUNT && locals.result >= 0)
+ {
+ locals.success = true;
+ locals.refundAmount = locals.reward - locals.result;
+ }
+ }
- PUBLIC_FUNCTION(getProjectByIndex)
- {
- output.project = state.get().projects.get(input.indexOfProject);
+ if (locals.success)
+ {
+ output.transferredNumberOfShares = input.numberOfShares;
+ output.errorCode = EAuctionError::Success;
+ }
+
+ if (locals.refundAmount > 0)
+ {
+ qpi.transfer(qpi.invocator(), locals.refundAmount);
+ }
+ setProcedureLogInput(locals.log, qpi.invocator(), EProcedureId::TransferShareManagementRights, output.errorCode, 0,
+ output.transferredNumberOfShares);
+
+ logProcedureResult(locals.log);
}
- struct getFundarasingByIndex_input
+protected:
+ /**
+ * @brief Emits a procedure log as success or error based on its error code.
+ */
+ static void logProcedureResult(const NostromoProcedureLog& log)
{
- uint32 indexOfFundarasing;
- };
+ if (log.errorCode == static_cast(EAuctionError::Success))
+ {
+ LOG_INFO(log);
+ }
+ else
+ {
+ LOG_ERROR(log);
+ }
+ }
- struct getFundarasingByIndex_output
+ /**
+ * @brief Fills the common procedure log payload.
+ */
+ static void setProcedureLogInput(NostromoProcedureLog& log, const id& actor, EProcedureId procedure, EAuctionError errorCode, uint64 auctionIndex,
+ sint64 amount)
{
- fundaraisingInfo fundarasing;
- };
+ log.contractIndex = SELF_INDEX;
+ log.procedure = static_cast(procedure);
+ log.errorCode = static_cast(errorCode);
+ log.auctionIndex = auctionIndex;
+ log.actor = actor;
+ log.amount = amount;
+ log._terminator = 0;
+ }
- PUBLIC_FUNCTION(getFundarasingByIndex)
+ /**
+ * @brief Copies persisted auction data into a compact summary.
+ */
+ static void fillAuctionSummary(const AuctionData& auction, AuctionSummary& summary)
{
- output.fundarasing = state.get().fundaraisings.get(input.indexOfFundarasing);
+ summary.metadataIpfsCid = auction.core.metadataIpfsCid;
+ summary.seller = auction.core.seller;
+ summary.highestBidder = auction.core.highestBidder;
+ summary.createdAt = auction.core.createdAt;
+ summary.settledAt = auction.core.settledAt;
+ summary.auctionIndex = auction.core.auctionIndex;
+ summary.quantityForSale = auction.core.quantityForSale;
+ summary.allocatedQuantity = auction.core.allocatedQuantity;
+ summary.initialPrice = auction.core.initialPrice;
+ summary.salePrice = auction.core.salePrice;
+ summary.buyNowPrice = auction.core.buyNowPrice;
+ summary.highestBidPrice = auction.core.highestBidPrice;
+ summary.highestBidQuantity = auction.core.highestBidQuantity;
+ summary.highestBidAmount = auction.core.highestBidAmount;
+ summary.type = static_cast(auction.core.type);
+ summary.visibility = static_cast(auction.core.visibility);
+ summary.status = static_cast(auction.core.status);
}
- struct getProjectIndexListByCreator_input
+ /**
+ * @brief Copies participant storage data into an auction participant summary.
+ */
+ static void fillParticipantSummary(const AuctionParticipantData& participantData, ParticipantSummary& summary)
{
- id creator;
- };
+ summary.participant = participantData.participant;
+ summary.lastBidTime = participantData.lastBidTime;
+ summary.bidAmount = participantData.bidAmount;
+ summary.escrowedAmount = participantData.escrowedAmount;
+ summary.requestedQuantity = participantData.requestedQuantity;
+ summary.allocatedQuantity = participantData.allocatedQuantity;
+ summary.isWinningBid = participantData.isWinningBid;
+ }
- struct getProjectIndexListByCreator_output
+ /**
+ * @brief Copies participant storage data into a user participation summary.
+ */
+ static void fillUserParticipationSummary(uint64 auctionIndex, const AuctionParticipantData& participantData, UserParticipationSummary& summary)
{
- Array indexListForProjects;
- };
+ summary.participant = participantData.participant;
+ summary.lastBidTime = participantData.lastBidTime;
+ summary.auctionIndex = auctionIndex;
+ summary.bidAmount = participantData.bidAmount;
+ summary.escrowedAmount = participantData.escrowedAmount;
+ summary.requestedQuantity = participantData.requestedQuantity;
+ summary.allocatedQuantity = participantData.allocatedQuantity;
+ summary.isWinningBid = participantData.isWinningBid;
+ }
- struct getProjectIndexListByCreator_locals
+ /**
+ * @brief Returns the smaller of two values.
+ */
+ template
+ static constexpr T min(const T& a, const T& b)
{
- uint32 i, countOfProject;
- };
+ return (a < b) ? a : b;
+ }
+ /**
+ * @brief Returns the larger of two values.
+ */
+ template
+ static constexpr T max(const T& a, const T& b)
+ {
+ return a > b ? a : b;
+ }
- PUBLIC_FUNCTION_WITH_LOCALS(getProjectIndexListByCreator)
+ /**
+ * @brief Resolves Batch Auction quantity invariants from creation input.
+ */
+ static bool resolveBatchAuctionCreateParams(uint64 lotItemCount, uint64 totalEscrowQuantity, uint64 minimumPurchaseQuantity,
+ uint64& quantityForSale, uint64& resolvedMinimumPurchaseQuantity, uint64 buyNowPrice)
{
- for (locals.i = 0; locals.i < state.get().numberOfCreatedProject; locals.i++)
- {
- if (state.get().projects.get(locals.i).creator == input.creator)
- {
- output.indexListForProjects.set(locals.countOfProject++, locals.i);
- }
- }
- for (locals.i = locals.countOfProject; locals.i < NOSTROMO_MAX_NUMBER_OF_PROJECT_USER_INVEST; locals.i++)
+ quantityForSale = 0;
+ resolvedMinimumPurchaseQuantity = 0;
+ if (lotItemCount != NOST_BATCH_AUCTION_LOT_ITEM_NUM || totalEscrowQuantity == 0 || minimumPurchaseQuantity == 0 ||
+ minimumPurchaseQuantity > totalEscrowQuantity || buyNowPrice != 0)
{
- output.indexListForProjects.set(locals.i, NOSTROMO_MAX_NUMBER_PROJECT);
+ return false;
}
+ quantityForSale = totalEscrowQuantity;
+ resolvedMinimumPurchaseQuantity = minimumPurchaseQuantity;
+ return true;
}
- struct getInfoUserInvested_input
+ /**
+ * @brief Resolves Standard Auction quantity and price invariants from creation input.
+ */
+ static bool resolveStandardAuctionCreateParams(uint64 minimumBidIncrement, uint64& quantityForSale, uint64& resolvedMinimumPurchaseQuantity,
+ uint64 buyNowPrice, uint64 initialPrice, uint64 salePrice)
{
- id investorId;
- };
+ quantityForSale = 0;
+ resolvedMinimumPurchaseQuantity = 0;
+ if (initialPrice < NOST_STANDARD_MIN_PRICE || salePrice < NOST_STANDARD_MIN_PRICE || minimumBidIncrement < NOST_STANDARD_MIN_BID_INCREMENT)
+ {
+ return false;
+ }
- struct getInfoUserInvested_output
- {
- Array listUserInvested;
- };
+ if (initialPrice > salePrice)
+ {
+ return false;
+ }
- struct getInfoUserInvested_locals
- {
- uint32 i, countOfProject;
- };
+ if (buyNowPrice > 0 && (buyNowPrice < initialPrice || buyNowPrice < salePrice))
+ {
- PUBLIC_FUNCTION_WITH_LOCALS(getInfoUserInvested)
- {
- state.get().investors.get(input.investorId, output.listUserInvested);
- }
+ return false;
+ }
- struct getMaxClaimAmount_input
- {
- id investorId;
- uint32 indexOfFundraising;
- };
+ quantityForSale = NOST_STANDARD_AUCTION_LOT_COUNT;
+ resolvedMinimumPurchaseQuantity = 0;
+ return true;
+ }
- struct getMaxClaimAmount_output
+ /**
+ * @brief Validates that private auctions use at least one supported access mode.
+ */
+ constexpr static bool validatePrivateAuctionAccess(EAuctionVisibility visibility, uint64 requiredAccessAssetCount, uint64 allowedWalletCount)
{
- uint64 amount;
- };
+ return visibility != EAuctionVisibility::Private || requiredAccessAssetCount > 0 || allowedWalletCount > 0;
+ }
- struct getMaxClaimAmount_locals
+ /**
+ * @brief Validates governance fee percentages and fixed service fees.
+ */
+ constexpr static bool isValidAuctionFeeConfiguration(sint64 privateAuctionFee, sint64 publicAuctionCreationFee,
+ uint64 auctionCancellationFeeBasisPoints, uint64 managementFeeBasisPoints,
+ uint64 developmentFeeBasisPoints, uint64 takeoverCoordinatorFeeBasisPoints,
+ uint64 shareholderDividendBasisPoints, uint64 shareholderFeeBasisPointsTier1,
+ uint64 shareholderFeeBasisPointsTier2, uint64 shareholderFeeBasisPointsTier3,
+ uint64 shareholderFeeBasisPointsTier4)
{
- Array tmpInvestedList;
- investInfo tmpInvestData;
- uint64 maxClaimAmount, investedAmount, dayA, dayB, dayC, dayD, start_cur_diffSecond, cur_end_diffSecond, claimedAmount;
- uint32 curDate, tmpDate, numberOfInvestedProjects;
- sint32 i, j, k;
- uint8 curVestingStep, vestingPercent;
- bit flag;
- };
+ return privateAuctionFee >= 0 && publicAuctionCreationFee >= 0 && auctionCancellationFeeBasisPoints <= NOST_BASIS_POINTS_SCALE &&
+ managementFeeBasisPoints <= NOST_BASIS_POINTS_SCALE && developmentFeeBasisPoints <= NOST_BASIS_POINTS_SCALE &&
+ takeoverCoordinatorFeeBasisPoints <= NOST_BASIS_POINTS_SCALE && shareholderDividendBasisPoints <= NOST_BASIS_POINTS_SCALE &&
+ shareholderFeeBasisPointsTier1 <= NOST_BASIS_POINTS_SCALE && shareholderFeeBasisPointsTier2 <= NOST_BASIS_POINTS_SCALE &&
+ shareholderFeeBasisPointsTier3 <= NOST_BASIS_POINTS_SCALE && shareholderFeeBasisPointsTier4 <= NOST_BASIS_POINTS_SCALE &&
+ (shareholderFeeBasisPointsTier1 + managementFeeBasisPoints + developmentFeeBasisPoints + takeoverCoordinatorFeeBasisPoints) <=
+ NOST_BASIS_POINTS_SCALE &&
+ (shareholderFeeBasisPointsTier2 + managementFeeBasisPoints + developmentFeeBasisPoints + takeoverCoordinatorFeeBasisPoints) <=
+ NOST_BASIS_POINTS_SCALE &&
+ (shareholderFeeBasisPointsTier3 + managementFeeBasisPoints + developmentFeeBasisPoints + takeoverCoordinatorFeeBasisPoints) <=
+ NOST_BASIS_POINTS_SCALE &&
+ (shareholderFeeBasisPointsTier4 + managementFeeBasisPoints + developmentFeeBasisPoints + takeoverCoordinatorFeeBasisPoints) <=
+ NOST_BASIS_POINTS_SCALE;
+ }
- PUBLIC_FUNCTION_WITH_LOCALS(getMaxClaimAmount)
+ /**
+ * @brief Selects the shareholder fee tier for a gross auction amount.
+ */
+ static uint64 getAuctionShareholderFeeBasisPoints(uint64 grossAmount, const StateData& state)
{
- packNostromoDate(qpi.year(), qpi.month(), qpi.day(), qpi.hour(), qpi.minute(), qpi.second(), locals.curDate);
-
- if (input.indexOfFundraising >= state.get().numberOfFundraising)
+ if (grossAmount <= NOST_AUCTION_SHAREHOLDER_FEE_THRESHOLD_TIER_1)
{
- return ;
+ return state.shareholderFeeBasisPointsTier1;
}
-
- state.get().investors.get(input.investorId, locals.tmpInvestedList);
- if (state.get().numberOfInvestedProjects.get(input.investorId, locals.numberOfInvestedProjects) == 0)
+ if (grossAmount <= NOST_AUCTION_SHAREHOLDER_FEE_THRESHOLD_TIER_2)
{
- return ;
+ return state.shareholderFeeBasisPointsTier2;
}
-
- for (locals.i = 0; locals.i < (sint32)locals.numberOfInvestedProjects; locals.i++)
+ if (grossAmount <= NOST_AUCTION_SHAREHOLDER_FEE_THRESHOLD_TIER_3)
{
- if (locals.tmpInvestedList.get(locals.i).indexOfFundraising == input.indexOfFundraising)
- {
- locals.investedAmount = locals.tmpInvestedList.get(locals.i).investedAmount;
- locals.claimedAmount = locals.tmpInvestedList.get(locals.i).claimedAmount;
- locals.tmpInvestData = locals.tmpInvestedList.get(locals.i);
- break;
- }
+ return state.shareholderFeeBasisPointsTier3;
}
+ return state.shareholderFeeBasisPointsTier4;
+ }
- if (locals.i == locals.numberOfInvestedProjects)
- {
- return ;
- }
+ /**
+ * @brief Selects the shareholder fee tier from contract state.
+ */
+ static uint64 getAuctionShareholderFeeBasisPoints(uint64 grossAmount, const ContractState& state)
+ {
+ return getAuctionShareholderFeeBasisPoints(grossAmount, state.get());
+ }
- if (locals.curDate >= state.get().fundaraisings.get(input.indexOfFundraising).listingStartDate && locals.curDate < state.get().fundaraisings.get(input.indexOfFundraising).cliffEndDate)
+ /** @brief Returns the zero-based shareholder fee tier selected by an auction gross amount. */
+ constexpr static uint64 getAuctionShareholderFeeTierIndex(uint64 grossAmount)
+ {
+ if (grossAmount <= NOST_AUCTION_SHAREHOLDER_FEE_THRESHOLD_TIER_1)
{
- output.amount = div(div(locals.investedAmount, state.get().fundaraisings.get(input.indexOfFundraising).tokenPrice) * state.get().fundaraisings.get(input.indexOfFundraising).TGE, 100ULL);
+ return 0;
}
- else if (locals.curDate >= state.get().fundaraisings.get(input.indexOfFundraising).cliffEndDate && locals.curDate < state.get().fundaraisings.get(input.indexOfFundraising).vestingEndDate)
+ if (grossAmount <= NOST_AUCTION_SHAREHOLDER_FEE_THRESHOLD_TIER_2)
{
- locals.tmpDate = state.get().fundaraisings.get(input.indexOfFundraising).cliffEndDate;
- diffDateInSecond(locals.tmpDate, locals.curDate, locals.j, locals.dayA, locals.dayB, locals.start_cur_diffSecond);
- locals.tmpDate = state.get().fundaraisings.get(input.indexOfFundraising).vestingEndDate;
- diffDateInSecond(locals.curDate, locals.tmpDate, locals.k, locals.dayC, locals.dayD, locals.cur_end_diffSecond);
-
- locals.curVestingStep = (uint8)div(locals.start_cur_diffSecond, div(locals.start_cur_diffSecond + locals.cur_end_diffSecond, state.get().fundaraisings.get(input.indexOfFundraising).stepOfVesting * 1ULL)) + 1;
- locals.vestingPercent = (uint8)div(100ULL - state.get().fundaraisings.get(input.indexOfFundraising).TGE, state.get().fundaraisings.get(input.indexOfFundraising).stepOfVesting * 1ULL) * locals.curVestingStep;
- output.amount = div(div(locals.investedAmount, state.get().fundaraisings.get(input.indexOfFundraising).tokenPrice) * (state.get().fundaraisings.get(input.indexOfFundraising).TGE + locals.vestingPercent), 100ULL);
+ return 1;
}
- else if (locals.curDate >= state.get().fundaraisings.get(input.indexOfFundraising).vestingEndDate)
+ if (grossAmount <= NOST_AUCTION_SHAREHOLDER_FEE_THRESHOLD_TIER_3)
{
- output.amount = div(locals.investedAmount, state.get().fundaraisings.get(input.indexOfFundraising).tokenPrice);
+ return 2;
}
+ return 3;
}
- REGISTER_USER_FUNCTIONS_AND_PROCEDURES()
+ /** @brief Returns the saturating aggregate of every unsettled fee-pool accumulator. */
+ static uint64 getNostromoFeePoolTotal(const NostromoFeePool& feePool)
{
- REGISTER_USER_FUNCTION(getStats, 1);
- REGISTER_USER_FUNCTION(getTierLevelByUser, 2);
- REGISTER_USER_FUNCTION(getUserVoteStatus, 3);
- REGISTER_USER_FUNCTION(checkTokenCreatability, 4);
- REGISTER_USER_FUNCTION(getNumberOfInvestedProjects, 5);
- REGISTER_USER_FUNCTION(getProjectByIndex, 6);
- REGISTER_USER_FUNCTION(getFundarasingByIndex, 7);
- REGISTER_USER_FUNCTION(getProjectIndexListByCreator, 8);
- REGISTER_USER_FUNCTION(getInfoUserInvested, 9);
- REGISTER_USER_FUNCTION(getMaxClaimAmount, 10);
-
- REGISTER_USER_PROCEDURE(registerInTier, 1);
- REGISTER_USER_PROCEDURE(logoutFromTier, 2);
- REGISTER_USER_PROCEDURE(createProject, 3);
- REGISTER_USER_PROCEDURE(voteInProject, 4);
- REGISTER_USER_PROCEDURE(createFundraising, 5);
- REGISTER_USER_PROCEDURE(investInProject, 6);
- REGISTER_USER_PROCEDURE(claimToken, 7);
- REGISTER_USER_PROCEDURE(upgradeTier, 8);
- REGISTER_USER_PROCEDURE(TransferShareManagementRights, 9);
+ return sadd(sadd(sadd(feePool.shareholderDividendTier1Amount, feePool.shareholderDividendTier2Amount),
+ sadd(feePool.shareholderDividendTier3Amount, feePool.shareholderDividendTier4Amount)),
+ sadd(sadd(feePool.commonServiceFeeAmount, feePool.shareholderDividendAmount),
+ sadd(sadd(feePool.managementAmount, feePool.developmentAmount), feePool.takeoverCoordinatorAmount)));
}
- INITIALIZE()
+ /**
+ * @brief Computes `floor(amount * basisPoints / 10000)` without overflowing the intermediate product.
+ */
+ static uint64 calculateBasisPointAmount(uint64 amount, uint64 basisPoints)
{
- state.mut().teamAddress = ID(_G, _E, _H, _N, _R, _F, _U, _O, _I, _I, _C, _S, _B, _C, _S, _R, _F, _M, _N, _J, _T, _C, _J, _K, _C, _J, _H, _A, _T, _Z, _X, _A, _X, _Y, _O, _F, _W, _X, _U, _F, _L, _C, _K, _F, _P, _B, _W, _X, _Q, _A, _C, _B, _S, _Z, _F, _F);
- state.mut().transferRightsFee = 100;
+ return sadd(smul(div(amount, NOST_BASIS_POINTS_SCALE), basisPoints),
+ div(smul(mod(amount, NOST_BASIS_POINTS_SCALE), basisPoints), NOST_BASIS_POINTS_SCALE));
}
- struct END_EPOCH_locals
+ /**
+ * @brief Computes the exact auction fee split without performing transfers.
+ * @note Keep this helper pure so tests can reuse the same arithmetic as `DistributeAuctionRevenue`.
+ */
+ static void calculateAuctionRevenueBreakdown(uint64 grossAmount, const ContractState& state,
+ AuctionRevenueBreakdown& output)
{
- fundaraisingInfo tmpFundraising;
- investInfo tmpInvest;
- Array votedList;
- Array clearedVotedList;
- id userId;
- sint64 idx;
- uint32 numberOfVotedProject, clearedNumberOfVotedProject, i, j, curDate, indexOfProject, numberOfInvestedProjects, tierLevel;
- };
+ output.sellerPayout = grossAmount;
+ output.shareholderFeeBasisPoints = getAuctionShareholderFeeBasisPoints(grossAmount, state);
+ output.shareholderFeeAmount = calculateBasisPointAmount(grossAmount, output.shareholderFeeBasisPoints);
+ output.shareholderDividendAmount = calculateBasisPointAmount(output.shareholderFeeAmount, state.get().shareholderDividendBasisPoints);
+ output.managementFeeAmount = calculateBasisPointAmount(grossAmount, state.get().managementFeeBasisPoints);
+ output.developmentFeeAmount = calculateBasisPointAmount(grossAmount, state.get().developmentFeeBasisPoints);
+ output.takeoverCoordinatorBaseAmount = calculateBasisPointAmount(grossAmount, state.get().takeoverCoordinatorFeeBasisPoints);
+ output.takeoverCoordinatorFeeAmount = output.takeoverCoordinatorBaseAmount + (output.shareholderFeeAmount - output.shareholderDividendAmount);
+ output.sellerPayout = grossAmount - output.shareholderFeeAmount - output.managementFeeAmount - output.developmentFeeAmount -
+ output.takeoverCoordinatorBaseAmount;
+ }
- END_EPOCH_WITH_LOCALS()
+ /**
+ * @brief Computes the exact service-fee split without performing transfers.
+ * @note Keep this helper pure so tests can reuse the same arithmetic as `DistributeNostromoFeePool`.
+ */
+ static void calculateAuctionServiceFeeBreakdown(uint64 feeAmount, AuctionServiceFeeBreakdown& output)
{
- packNostromoDate(qpi.year(), qpi.month(), qpi.day(), qpi.hour(), qpi.minute(), qpi.second(), locals.curDate);
+ output.shareholderDividendAmount = calculateBasisPointAmount(feeAmount, NOST_AUCTION_SERVICE_FEE_SHAREHOLDER_BP);
+ output.managementFeeAmount = calculateBasisPointAmount(feeAmount, NOST_AUCTION_SERVICE_FEE_MANAGEMENT_BP);
+ output.developmentFeeAmount = calculateBasisPointAmount(feeAmount, NOST_AUCTION_SERVICE_FEE_DEVELOPMENT_BP);
+ output.takeoverCoordinatorFeeAmount = calculateBasisPointAmount(feeAmount, NOST_AUCTION_SERVICE_FEE_TAKEOVER_COORDINATOR_BP);
+ // Shareholders receive the rounding remainder so the entire collected fee is distributed on-chain.
+ output.shareholderDividendAmount =
+ sadd(output.shareholderDividendAmount, feeAmount - output.shareholderDividendAmount - output.managementFeeAmount -
+ output.developmentFeeAmount - output.takeoverCoordinatorFeeAmount);
+ }
- locals.idx = state.get().investors.nextElementIndex(NULL_INDEX);
- while (locals.idx != NULL_INDEX)
+ /**
+ * @brief Computes escrow, bid fee, and required reward for a Batch Auction bid.
+ */
+ static void calculateBatchAuctionBidFee(uint64 bidQuantity, uint64 bidAmount, CalculateBatchAuctionBidFee_output& output)
+ {
+ output.escrowAmount = smul(bidQuantity, bidAmount);
+ if (output.escrowAmount == 0)
{
- locals.userId = state.get().investors.key(locals.idx);
- state.get().investors.get(locals.userId, state.mut().tmpInvestedList);
- state.get().numberOfInvestedProjects.get(locals.userId, locals.numberOfInvestedProjects);
-
- for (locals.i = 0; locals.i < locals.numberOfInvestedProjects; locals.i++)
- {
- if (state.get().fundaraisings.get(locals.i).thirdPhaseEndDate < locals.curDate && state.get().fundaraisings.get(locals.i).isCreatedToken == 0 && state.get().fundaraisings.get(locals.i).raisedFunds != 0)
- {
- qpi.transfer(locals.userId, state.get().tmpInvestedList.get(locals.i).investedAmount);
- state.mut().tmpInvestedList.set(locals.i, state.get().tmpInvestedList.get(--locals.numberOfInvestedProjects));
- }
- }
- if (locals.numberOfInvestedProjects == 0)
- {
- state.mut().investors.removeByKey(locals.userId);
- state.mut().numberOfInvestedProjects.removeByKey(locals.userId);
- }
- else
- {
- state.mut().investors.set(locals.userId, state.get().tmpInvestedList);
- state.mut().numberOfInvestedProjects.set(locals.userId, locals.numberOfInvestedProjects);
- }
- locals.idx = state.get().investors.nextElementIndex(locals.idx);
+ output.fee = 0;
+ output.requiredReward = 0;
+ return;
}
- for (locals.i = 0; locals.i < state.get().numberOfFundraising; locals.i++)
- {
- if (state.get().fundaraisings.get(locals.i).thirdPhaseEndDate < locals.curDate && state.get().fundaraisings.get(locals.i).isCreatedToken == 0 && state.get().fundaraisings.get(locals.i).raisedFunds != 0)
- {
- locals.tmpFundraising = state.get().fundaraisings.get(locals.i);
- locals.tmpFundraising.raisedFunds = 0;
- state.mut().fundaraisings.set(locals.i, locals.tmpFundraising);
- }
- else if (state.get().fundaraisings.get(locals.i).thirdPhaseEndDate < locals.curDate && state.get().fundaraisings.get(locals.i).isCreatedToken == 1 && state.get().fundaraisings.get(locals.i).raisedFunds != 0)
- {
- locals.tmpFundraising = state.get().fundaraisings.get(locals.i);
+ output.fee = output.escrowAmount <= NOST_BATCH_BID_FEE_CUTOFF ? NOST_BATCH_BID_FEE_CUTOFF - output.escrowAmount : 0;
+ output.requiredReward = sadd(output.escrowAmount, output.fee);
+ }
- state.mut().epochRevenue += div(locals.tmpFundraising.raisedFunds * 5, 100ULL);
- qpi.transfer(state.get().projects.get(locals.tmpFundraising.indexOfProject).creator, locals.tmpFundraising.raisedFunds - div(locals.tmpFundraising.raisedFunds * 5, 100ULL));
+ /**
+ * @brief Returns the service fee required to create an auction.
+ */
+ static sint64 getCreateAuctionFee(EAuctionVisibility visibility, const ContractState& state)
+ {
+ switch (visibility)
+ {
+ case EAuctionVisibility::Public: return state.get().publicAuctionCreationFee; break;
+ case EAuctionVisibility::Private: return state.get().privateAuctionFee; break;
+ default: break;
+ }
+ return 0;
+ }
- qpi.transferShareOwnershipAndPossession(state.get().projects.get(locals.tmpFundraising.indexOfProject).tokenName, SELF, SELF, SELF, state.get().fundaraisings.get(locals.i).soldAmount - div(locals.tmpFundraising.raisedFunds, state.get().fundaraisings.get(locals.i).tokenPrice), state.get().projects.get(locals.tmpFundraising.indexOfProject).creator);
+ /**
+ * @brief Returns whether an auction type is accepted by the contract.
+ */
+ static bool isSupportedAuctionType(EAuctionType auctionType)
+ {
+ return auctionType == EAuctionType::Batch || auctionType == EAuctionType::Standard;
+ }
- locals.tmpFundraising.raisedFunds = 0;
- state.mut().fundaraisings.set(locals.i, locals.tmpFundraising);
- }
- }
+ /**
+ * @brief Returns whether an auction visibility is accepted by the contract.
+ */
+ static bool isSupportedAuctionVisibility(EAuctionVisibility visibility)
+ {
+ return visibility == EAuctionVisibility::Public || visibility == EAuctionVisibility::Private;
+ }
- qpi.transfer(state.get().teamAddress, div(state.get().epochRevenue, 10ULL));
- state.mut().epochRevenue -= div(state.get().epochRevenue, 10ULL);
- qpi.distributeDividends(div(state.get().epochRevenue, 676ULL));
- state.mut().epochRevenue -= div(state.get().epochRevenue, 676ULL) * 676;
+ /**
+ * @brief Returns whether an asset entry is empty.
+ */
+ static bool isZeroAsset(const Asset& asset) { return asset.assetName == 0 && isZero(asset.issuer); }
- locals.idx = state.get().users.nextElementIndex(NULL_INDEX);
- while (locals.idx != NULL_INDEX)
- {
- locals.userId = state.get().users.key(locals.idx);
- locals.tierLevel = state.get().users.value(locals.idx);
+ /** @brief Returns whether the runtime fee override routes every auction fee to the development wallet. */
+ static bool routeAllFeesToDevelopment(const QPI::ContractState& state)
+ {
+ return state.get().routeAllFeesToDevelopment;
+ }
- if (state.get().numberOfVotedProject.get(locals.userId, locals.numberOfVotedProject))
- {
- state.get().voteStatus.get(locals.userId, locals.votedList);
- locals.clearedNumberOfVotedProject = 0;
- for (locals.j = 0; locals.j < locals.numberOfVotedProject; locals.j++)
- {
- locals.indexOfProject = locals.votedList.get(locals.j);
+ /**
+ * @brief Packs year, month, and day into the contract date-stamp format.
+ */
+ static void makeDateStamp(uint8 year, uint8 month, uint8 day, uint32& res)
+ {
+ res = static_cast(year << NOST_DATE_STAMP_YEAR_SHIFT | month << NOST_DATE_STAMP_MONTH_SHIFT | day);
+ }
- if (state.get().projects.get(locals.indexOfProject).endDate > locals.curDate)
- {
- locals.clearedVotedList.set(locals.clearedNumberOfVotedProject++, locals.indexOfProject);
- }
- }
- if (locals.clearedNumberOfVotedProject == 0)
- {
- state.mut().numberOfVotedProject.removeByKey(locals.userId);
- state.mut().voteStatus.removeByKey(locals.userId);
- }
- else
- {
- state.mut().numberOfVotedProject.set(locals.userId, locals.clearedNumberOfVotedProject);
- state.mut().voteStatus.set(locals.userId, locals.clearedVotedList);
- }
- }
+ /**
+ * @brief Expands an accumulated pause window to include a candidate window.
+ */
+ static void accumulatePauseWindow(uint8& hasPauseWindow, DateAndTime& pauseStartedAt, DateAndTime& pauseEndsAt,
+ const DateAndTime& candidatePauseStartedAt, const DateAndTime& candidatePauseEndsAt)
+ {
+ if (!hasPauseWindow)
+ {
+ hasPauseWindow = 1;
+ pauseStartedAt = candidatePauseStartedAt;
+ pauseEndsAt = candidatePauseEndsAt;
+ return;
+ }
- locals.idx = state.get().users.nextElementIndex(locals.idx);
+ if (candidatePauseStartedAt < pauseStartedAt)
+ {
+ pauseStartedAt = candidatePauseStartedAt;
}
+ if (candidatePauseEndsAt > pauseEndsAt)
+ {
+ pauseEndsAt = candidatePauseEndsAt;
+ }
+ }
- if (state.get().users.needsCleanup()) { state.mut().users.cleanup(); }
- if (state.get().investors.needsCleanup()) { state.mut().investors.cleanup(); }
- if (state.get().numberOfInvestedProjects.needsCleanup()) { state.mut().numberOfInvestedProjects.cleanup(); }
- if (state.get().numberOfVotedProject.needsCleanup()) { state.mut().numberOfVotedProject.cleanup(); }
- if (state.get().voteStatus.needsCleanup()) { state.mut().voteStatus.cleanup(); }
+ /**
+ * @brief Compares two Nostromo timestamps.
+ * @param a Left-hand date-time.
+ * @param b Right-hand date-time.
+ * @return `-1` if `a < b`, `0` if `a == b`, `1` if `a > b`.
+ */
+ static sint32 dateCompare(const DateAndTime& a, const DateAndTime& b)
+ {
+ if (a < b)
+ {
+ return -1;
+ }
+ if (a > b)
+ {
+ return 1;
+ }
+ return 0;
}
- PRE_ACQUIRE_SHARES()
- {
- output.allowTransfer = true;
- }
+ /**
+ * @brief Computes the difference in seconds between two `DateAndTime` values.
+ * @param a Start date-time.
+ * @param b End date-time.
+ * @param res Output difference in seconds, or `0` when `A >= B`.
+ */
+ static void diffDateInSecond(const DateAndTime& a, const DateAndTime& b, uint64& res)
+ {
+ if (a >= b)
+ {
+ res = 0;
+ return;
+ }
+ res = div(a.durationMicrosec(b), NOST_MICROSECONDS_PER_SECOND);
+ }
};
diff --git a/src/contracts/QIP.h b/src/contracts/QIP.h
index bec11e1e3..de4483d29 100644
--- a/src/contracts/QIP.h
+++ b/src/contracts/QIP.h
@@ -29,6 +29,7 @@ enum QIPLogInfo {
QIP_invalidIssuer = 15,
QIP_qxAskOrderFound = 16,
QIP_icoAlreadyExists = 17,
+ QIP_returnFundsError = 18,
};
struct QIPLogger
@@ -715,9 +716,16 @@ struct QIP : public ContractBase
}
}
- if (locals.log._type == QIP_success && locals.buyerInfo.isReturned)
+ if (locals.log._type == QIP_success)
{
- locals.log._type = QIPLogInfo::QIP_fundsAlreadyReturned;
+ if (qpi.epoch() <= locals.ico.startEpoch + 2)
+ {
+ locals.log._type = QIPLogInfo::QIP_returnFundsError;
+ }
+ else if (locals.buyerInfo.isReturned)
+ {
+ locals.log._type = QIPLogInfo::QIP_fundsAlreadyReturned;
+ }
}
if (locals.log._type != QIP_success)
diff --git a/src/contracts/QRaffle_old.h b/src/contracts/QRaffle_old.h
deleted file mode 100644
index 453612b3e..000000000
--- a/src/contracts/QRaffle_old.h
+++ /dev/null
@@ -1,2836 +0,0 @@
-using namespace QPI;
-
-constexpr uint64 QRAFFLE_REGISTER_AMOUNT = 1000000000ull;
-constexpr uint64 QRAFFLE_QXMR_REGISTER_AMOUNT = 250000000ull;
-constexpr uint64 QRAFFLE_MAX_QRE_AMOUNT = 1000000000ull;
-constexpr uint64 QRAFFLE_ASSET_NAME = 19505638103142993;
-constexpr uint64 QRAFFLE_QXMR_ASSET_NAME = 1380800593; // QXMR token asset name
-constexpr uint32 QRAFFLE_LOGOUT_FEE = div(QRAFFLE_REGISTER_AMOUNT, 20);
-constexpr uint32 QRAFFLE_QXMR_LOGOUT_FEE = div(QRAFFLE_QXMR_REGISTER_AMOUNT, 20); // QXMR logout fee
-constexpr uint32 QRAFFLE_TRANSFER_SHARE_FEE = 100;
-constexpr uint32 QRAFFLE_BURN_FEE = 5; // percent
-constexpr uint32 QRAFFLE_REGISTER_FEE = 5; // percent
-constexpr uint32 QRAFFLE_FEE = 1; // percent
-constexpr uint32 QRAFFLE_CHARITY_FEE = 1; // percent
-constexpr uint32 QRAFFLE_SHAREHOLDER_FEE = 8; // percent
-constexpr uint32 QRAFFLE_MAX_EPOCH = 65536;
-constexpr uint32 QRAFFLE_MAX_PROPOSAL_EPOCH = 128;
-constexpr uint32 QRAFFLE_MAX_MEMBER = 65536;
-constexpr uint32 QRAFFLE_DEFAULT_QRAFFLE_AMOUNT = 10000000ull;
-constexpr uint32 QRAFFLE_MIN_QRAFFLE_AMOUNT = 1000000ull;
-constexpr uint32 QRAFFLE_MAX_QRAFFLE_AMOUNT = 1000000000ull;
-// Ended token-raffle ring: 16 384 slots × ~96 B ≈ 1.5 MB.
-// At most QRAFFLE_MAX_PROPOSAL_EPOCH (128) raffles/epoch → covers ~128 epochs of history.
-constexpr uint32 QRAFFLE_MAX_TOKEN_RAFFLES = 16384;
-constexpr uint32 QRAFFLE_TOKEN_RAFFLE_SLOT_SIZE = 512; // 2^9, max members per token raffle
-constexpr uint8 QRAFFLE_MAX_PROPOSALS_PER_PROPOSER = 3; // max proposals per user per epoch
-
-constexpr sint32 QRAFFLE_SUCCESS = 0;
-constexpr sint32 QRAFFLE_INSUFFICIENT_FUND = 1;
-constexpr sint32 QRAFFLE_ALREADY_REGISTERED = 2;
-constexpr sint32 QRAFFLE_UNREGISTERED = 3;
-constexpr sint32 QRAFFLE_MAX_PROPOSAL_EPOCH_REACHED = 4;
-constexpr sint32 QRAFFLE_INVALID_PROPOSAL = 5;
-constexpr sint32 QRAFFLE_FAILED_TO_DEPOSIT = 6;
-constexpr sint32 QRAFFLE_ALREADY_VOTED = 7;
-constexpr sint32 QRAFFLE_INVALID_TOKEN_RAFFLE = 8;
-constexpr sint32 QRAFFLE_INVALID_OFFSET_OR_LIMIT = 9;
-constexpr sint32 QRAFFLE_INVALID_EPOCH = 10;
-constexpr sint32 QRAFFLE_MAX_MEMBER_REACHED = 11;
-constexpr sint32 QRAFFLE_INITIAL_REGISTER_CANNOT_LOGOUT = 12;
-constexpr sint32 QRAFFLE_INSUFFICIENT_QXMR = 13;
-constexpr sint32 QRAFFLE_INVALID_TOKEN_TYPE = 14;
-constexpr sint32 QRAFFLE_USER_NOT_FOUND = 15;
-constexpr sint32 QRAFFLE_INVALID_ENTRY_AMOUNT = 16;
-constexpr sint32 QRAFFLE_EMPTY_QU_RAFFLE = 17;
-constexpr sint32 QRAFFLE_EMPTY_TOKEN_RAFFLE = 18;
-constexpr sint32 QRAFFLE_MAX_PROPOSAL_PER_USER_REACHED = 19;
-
-// Asset Raffle return codes
-constexpr sint32 QRAFFLE_INVALID_BUNDLE = 20;
-constexpr sint32 QRAFFLE_INVALID_RESERVE_PRICE = 21;
-constexpr sint32 QRAFFLE_BUNDLE_ESCROW_FAILED = 22;
-constexpr sint32 QRAFFLE_INVALID_ASSET_RAFFLE = 23;
-constexpr sint32 QRAFFLE_ASSET_RAFFLE_FULL = 24;
-constexpr sint32 QRAFFLE_TICKET_LIMIT_REACHED = 25;
-constexpr sint32 QRAFFLE_MAX_ASSET_RAFFLES_REACHED = 26;
-constexpr sint32 QRAFFLE_CANCEL_NOT_ALLOWED = 27;
-
-// Asset Raffle configuration
-constexpr uint64 QRAFFLE_ASSET_RAFFLE_PROPOSAL_FEE = 500000ull; // 500K Qu; non-refundable anti-spam
-constexpr uint32 QRAFFLE_MAX_ASSET_RAFFLES_PER_EPOCH = 64; // concurrent active raffles
-constexpr uint32 QRAFFLE_MAX_ASSETS_PER_BUNDLE = 4; // items per bundle
-constexpr uint32 QRAFFLE_MAX_ASSET_TICKET_BUYERS = 1024; // distinct buyers per raffle
-constexpr uint32 QRAFFLE_MAX_TICKETS_PER_BUYER = 100; // per-buyer cap (anti-griefing)
-constexpr uint32 QRAFFLE_MAX_ASSET_RAFFLES_PER_CREATOR = 2; // per creator per epoch
-constexpr uint32 QRAFFLE_MAX_ENDED_ASSET_RAFFLES = 8192; // history ring buffer
-constexpr uint64 QRAFFLE_MIN_ASSET_TICKET_AMOUNT = 1000000ull; // 1M Qu
-constexpr uint64 QRAFFLE_MAX_ASSET_TICKET_AMOUNT = 1000000000000ull;// 1T Qu
-// Flat array strides: raffle i occupies [i*stride .. i*stride+count)
-constexpr uint32 QRAFFLE_ASSET_RAFFLE_BUNDLE_FLAT_SIZE = QRAFFLE_MAX_ASSET_RAFFLES_PER_EPOCH * QRAFFLE_MAX_ASSETS_PER_BUNDLE; // 256
-constexpr uint32 QRAFFLE_ASSET_RAFFLE_BUYERS_FLAT_SIZE = QRAFFLE_MAX_ASSET_RAFFLES_PER_EPOCH * QRAFFLE_MAX_ASSET_TICKET_BUYERS; // 65536
-
-
-constexpr uint32 QRAFFLE_MAX_SHAREHOLDERS_OLD = 1024;
-
-
-struct QRAFFLE2
-{
-};
-
-struct QRAFFLE : public ContractBase
-{
-public:
- enum LogInfo {
- QRAFFLE_success = 0,
- QRAFFLE_insufficientQubic = 1,
- QRAFFLE_insufficientQXMR = 2,
- QRAFFLE_alreadyRegistered = 3,
- QRAFFLE_unregistered = 4,
- QRAFFLE_maxMemberReached = 5,
- QRAFFLE_maxProposalEpochReached = 6,
- QRAFFLE_invalidProposal = 7,
- QRAFFLE_failedToDeposit = 8,
- QRAFFLE_alreadyVoted = 9,
- QRAFFLE_invalidTokenRaffle = 10,
- QRAFFLE_invalidOffsetOrLimit = 11,
- QRAFFLE_invalidEpoch = 12,
- QRAFFLE_initialRegisterCannotLogout = 13,
- QRAFFLE_invalidTokenType = 14,
- QRAFFLE_invalidEntryAmount = 15,
- QRAFFLE_maxMemberReachedForQuRaffle = 16,
- QRAFFLE_proposalNotFound = 17,
- QRAFFLE_proposalAlreadyEnded = 18,
- QRAFFLE_notEnoughShares = 19,
- QRAFFLE_transferFailed = 20,
- QRAFFLE_epochEnded = 21,
- QRAFFLE_winnerSelected = 22,
- QRAFFLE_revenueDistributed = 23,
- QRAFFLE_tokenRaffleCreated = 24,
- QRAFFLE_tokenRaffleEnded = 25,
- QRAFFLE_proposalSubmitted = 26,
- QRAFFLE_proposalVoted = 27,
- QRAFFLE_quRaffleDeposited = 28,
- QRAFFLE_tokenRaffleDeposited = 29,
- QRAFFLE_shareManagementRightsTransferred = 30,
- QRAFFLE_emptyQuRaffle = 31,
- QRAFFLE_emptyTokenRaffle = 32,
- QRAFFLE_maxProposalPerUserReached = 33,
- // Asset Raffle log types
- QRAFFLE_assetRaffleCreated = 34,
- QRAFFLE_assetRaffleTicketBought = 35,
- QRAFFLE_assetRaffleSucceeded = 36,
- QRAFFLE_assetRaffleRefunded = 37,
- QRAFFLE_assetRaffleBundleEscrowFailed = 38,
- QRAFFLE_assetRaffleBundleDeliveryFailed = 39,
- QRAFFLE_assetRaffleCancelled = 40,
- QRAFFLE_invalidBundle = 41,
- QRAFFLE_invalidReservePrice = 42,
- QRAFFLE_assetRaffleFull = 43,
- QRAFFLE_ticketLimitReached = 44,
- QRAFFLE_maxAssetRafflesReached = 45,
- QRAFFLE_cancelNotAllowed = 46
- };
-
- struct Logger
- {
- uint32 _contractIndex;
- uint32 _type; // Assign a random unique (per contract) number to distinguish messages of different types
- sint8 _terminator; // Only data before "_terminator" are logged
- };
-
- // Enhanced logger for END_EPOCH with detailed information
- struct EndEpochLogger
- {
- uint32 _contractIndex;
- uint32 _type;
- uint32 _epoch; // Current epoch number
- uint32 _memberCount; // Number of QuRaffle members
- uint64 _totalAmount; // Total amount being processed
- uint64 _winnerAmount; // Amount won by winner
- uint32 _winnerIndex; // Index of the winner
- sint8 _terminator;
- };
-
- // Enhanced logger for revenue distribution
- struct RevenueLogger
- {
- uint32 _contractIndex;
- uint32 _type;
- uint64 _burnAmount; // Amount burned
- uint64 _charityAmount; // Amount sent to charity
- uint64 _shareholderAmount; // Amount distributed to shareholders
- uint64 _registerAmount; // Amount distributed to registers
- uint64 _feeAmount; // Amount sent to fee address
- uint64 _winnerAmount; // Amount sent to winner
- sint8 _terminator;
- };
-
- // Enhanced logger for token raffle processing
- struct TokenRaffleLogger
- {
- uint32 _contractIndex;
- uint32 _type;
- uint32 _raffleIndex; // Index of the token raffle
- uint64 _assetName; // Asset name of the token
- uint32 _memberCount; // Number of members in this raffle
- uint64 _entryAmount; // Entry amount for this raffle
- uint32 _winnerIndex; // Winner index for this raffle
- uint64 _winnerAmount; // Amount won in this raffle
- sint8 _terminator;
- };
-
- // Enhanced logger for proposal processing
- struct ProposalLogger
- {
- uint32 _contractIndex;
- uint32 _type;
- uint32 _proposalIndex; // Index of the proposal
- id _proposer; // Proposer of the proposal
- uint32 _yesVotes; // Number of yes votes
- uint32 _noVotes; // Number of no votes
- uint64 _assetName; // Asset name if approved
- uint64 _entryAmount; // Entry amount if approved
- sint8 _terminator;
- };
-
- struct EmptyTokenRaffleLogger
- {
- uint32 _contractIndex;
- uint32 _type;
- uint32 _tokenRaffleIndex; // Index of the token raffle per epoch
- sint8 _terminator;
- };
-
- struct AssetRaffleCreatedLogger
- {
- uint32 _contractIndex;
- uint32 _type;
- uint32 _raffleIndex;
- id _creator;
- uint64 _reservePriceQu;
- uint64 _entryTicketQu;
- uint32 _bundleSize;
- sint8 _terminator;
- };
-
- struct AssetRaffleTicketLogger
- {
- uint32 _contractIndex;
- uint32 _type;
- uint32 _raffleIndex;
- id _buyer;
- uint32 _tickets;
- uint64 _cost;
- sint8 _terminator;
- };
-
- struct AssetRaffleEndedLogger
- {
- uint32 _contractIndex;
- uint32 _type;
- uint32 _raffleIndex;
- id _creator;
- id _winner;
- uint64 _grossPoolQu;
- uint64 _creatorPaidQu;
- uint8 _reserveMet;
- sint8 _terminator;
- };
-
- // One item in an asset raffle bundle (token or SC share + quantity).
- struct AssetRaffleItem
- {
- Asset asset;
- sint64 numberOfShares;
- };
-
- // Active asset raffle state (live during the epoch it was created).
- struct AssetRaffleInfo
- {
- id creator;
- uint64 reservePriceQu; // net Qu creator wants AFTER 20% fee
- uint64 entryTicketQu; // Qu per ticket
- uint64 totalTicketsPaidQu; // gross Qu pool so far
- uint32 numberOfBuyers;
- uint32 totalTickets;
- uint32 bundleSize;
- uint32 epoch;
- };
-
- // Historical record written at END_EPOCH for each settled asset raffle.
- // Field order keeps the largest types first so trailing padding is minimal and
- // deterministic across compilers (no explicit pad needed → no plain C arrays).
- struct EndedAssetRaffleInfo
- {
- id creator;
- id epochWinner; // NULL_ID if reserve was missed
- uint64 reservePriceQu;
- uint64 entryTicketQu;
- uint64 grossPoolQu;
- uint64 creatorPaidQu; // 0 if reserve missed
- uint32 totalTickets;
- uint32 numberOfBuyers;
- uint32 bundleSize;
- uint32 epoch;
- uint32 reserveMet; // 1 = reserve met and winner paid; 0 = refunded (uint32 keeps natural alignment)
- };
-
- struct ProposalInfo {
- Asset token;
- id proposer;
- uint64 entryAmount;
- uint32 nYes;
- uint32 nNo;
- };
-
- struct QuRaffleInfo
- {
- id epochWinner;
- uint64 receivedAmount;
- uint64 entryAmount;
- uint32 numberOfMembers;
- uint32 winnerIndex;
- };
-
- struct TokenRaffleInfo
- {
- id epochWinner;
- Asset token;
- uint64 entryAmount;
- uint32 numberOfMembers;
- uint32 winnerIndex;
- uint32 epoch;
- };
-
- struct ActiveTokenRaffleInfo {
- Asset token;
- uint64 entryAmount;
- };
-
- struct OldStateData
- {
- HashMap registers;
- Array proposals;
-
- HashMap , QRAFFLE_MAX_MEMBER> voteParticipation;
- HashMap , QRAFFLE_MAX_MEMBER> voteValues;
- Array numberOfVotedInProposal;
- Array quRaffleMembers;
- HashSet quRaffleMemberSet;
-
- Array activeTokenRaffle;
- HashMap , QRAFFLE_MAX_MEMBER> tokenRaffleParticipation;
- Array tokenRaffleMemberSlots;
- Array numberOfTokenRaffleMembers;
-
- Array QuRaffles;
- Array tokenRaffle;
- HashMap quRaffleEntryAmount;
- HashSet shareholdersList;
-
- id initialRegister1, initialRegister2, initialRegister3, initialRegister4, initialRegister5;
- id charityAddress, feeAddress, QXMRIssuer;
- uint64 epochRevenue, epochQXMRRevenue, qREAmount, totalBurnAmount, totalCharityAmount, totalShareholderAmount, totalRegisterAmount, totalFeeAmount, totalWinnerAmount, largestWinnerAmount;
- uint32 numberOfRegisters, numberOfQuRaffleMembers, numberOfEntryAmountSubmitted, numberOfProposals, numberOfActiveTokenRaffle, numberOfEndedTokenRaffle;
- Array daoMemberCount;
- HashMap proposalsPerProposer;
- };
-
- struct StateData
- {
- HashMap registers;
- Array proposals;
-
- // Per-user vote tracking with dual BitArray (qRWA pattern).
- // O(1) lookup via id hash, 1 bit per proposal. ~4 MB each, ~8 MB total.
- HashMap , QRAFFLE_MAX_MEMBER> voteParticipation; // bit=1 if user has voted
- HashMap , QRAFFLE_MAX_MEMBER> voteValues; // bit=1 for yes, bit=0 for no
- Array numberOfVotedInProposal;
- Array quRaffleMembers;
- // O(1) duplicate guard for quRaffle entries; mirrors quRaffleMembers for membership tests.
- HashSet quRaffleMemberSet;
-
- Array activeTokenRaffle;
- // Per-user O(1) duplicate check for token raffle deposits. ~4 MB.
- HashMap , QRAFFLE_MAX_MEMBER> tokenRaffleParticipation;
- // Flat indexed member storage: raffle i occupies slots [i*SLOT_SIZE .. i*SLOT_SIZE+count). ~2 MB.
- Array tokenRaffleMemberSlots;
- Array numberOfTokenRaffleMembers;
-
- Array QuRaffles;
- Array tokenRaffle;
- HashMap quRaffleEntryAmount;
-
- id initialRegister1, initialRegister2, initialRegister3, initialRegister4, initialRegister5;
- id charityAddress, feeAddress, QXMRIssuer;
- uint64 epochRevenue, epochQXMRRevenue, qREAmount, totalBurnAmount, totalCharityAmount, totalShareholderAmount, totalRegisterAmount, totalFeeAmount, totalWinnerAmount, largestWinnerAmount;
- uint32 numberOfRegisters, numberOfQuRaffleMembers, numberOfEntryAmountSubmitted, numberOfProposals, numberOfActiveTokenRaffle, numberOfEndedTokenRaffle;
- Array daoMemberCount; // Number of DAO members (registers) at each epoch
- HashMap proposalsPerProposer;
-
- // ── Asset Raffle state ────────────────────────────────────────────────────────
- Array activeAssetRaffles;
- uint32 numberOfActiveAssetRaffles;
-
- // Bundle items: raffle i occupies [i*4 .. i*4+bundleSize).
- Array activeAssetRaffleItems;
-
- // Buyer lists: raffle i occupies [i*1024 .. i*1024+numberOfBuyers).
- Array activeAssetRaffleBuyers;
- Array activeAssetRaffleBuyerTickets;
-
- // O(1) has-bought check: bit[i]=1 means this user has tickets in raffle i.
- HashMap, QRAFFLE_MAX_MEMBER> assetRaffleParticipation;
-
- // O(1) slot lookup: entry[i] = buyer's 0-based position in raffle i's buyer region.
- // Sentinel 0xFFFF = not present. ~8 MB (64 raffles × 2 B × 65536 buyers).
- // Reset each epoch alongside the buyer arrays.
- HashMap, QRAFFLE_MAX_MEMBER> assetRaffleBuyerSlotIndex;
-
- // Per-creator raffle count; reset each epoch to enforce QRAFFLE_MAX_ASSET_RAFFLES_PER_CREATOR.
- HashMap assetRafflesPerCreator;
-
- // Settled raffle history ring buffer.
- Array endedAssetRaffles;
- uint32 numberOfEndedAssetRaffles;
-
- // Accumulated proposal fees destined for DAO registers (50% of each 500K fee);
- // distributed in one O(R) pass at END_EPOCH alongside the register share bucket.
- uint64 epochAssetRaffleDaoBucket;
-
- // Aggregate analytics (monotonically increasing).
- uint64 totalAssetRaffleProposalFees;
- uint64 totalAssetRaffleCreatorPaid;
- uint64 totalAssetRaffleRefunded;
- uint32 totalAssetRafflesCreated;
- uint32 totalAssetRafflesSucceeded;
- uint32 totalAssetRafflesFailed;
- };
-
- struct registerInSystem_input
- {
- bit useQXMR; // 0 = use qubic, 1 = use QXMR tokens
- };
-
- struct registerInSystem_output
- {
- sint32 returnCode;
- };
-
- struct logoutInSystem_input
- {
- };
-
- struct logoutInSystem_output
- {
- sint32 returnCode;
- };
-
- struct submitEntryAmount_input
- {
- uint64 amount;
- };
-
- struct submitEntryAmount_output
- {
- sint32 returnCode;
- };
-
- struct submitProposal_input
- {
- id tokenIssuer;
- uint64 tokenName;
- uint64 entryAmount;
- };
-
- struct submitProposal_output
- {
- sint32 returnCode;
- };
-
- struct voteInProposal_input
- {
- uint32 indexOfProposal;
- bit yes;
- };
-
- struct voteInProposal_output
- {
- sint32 returnCode;
- };
-
- struct depositInQuRaffle_input
- {
-
- };
-
- struct depositInQuRaffle_output
- {
- sint32 returnCode;
- };
-
- struct depositInTokenRaffle_input
- {
- uint32 indexOfTokenRaffle;
- };
-
- struct depositInTokenRaffle_output
- {
- sint32 returnCode;
- };
-
- struct TransferShareManagementRights_input
- {
- id tokenIssuer;
- uint64 tokenName;
- sint64 numberOfShares;
- uint32 newManagingContractIndex;
- };
-
- struct TransferShareManagementRights_output
- {
- sint64 transferredNumberOfShares;
- };
-
- struct getRegisters_input
- {
- uint32 offset;
- uint32 limit;
- };
-
- struct getRegisters_output
- {
- id register1, register2, register3, register4, register5, register6, register7, register8, register9, register10, register11, register12, register13, register14, register15, register16, register17, register18, register19, register20;
- sint32 returnCode;
- };
-
- struct getAnalytics_input
- {
- };
-
- struct getAnalytics_output
- {
- uint64 currentQuRaffleAmount;
- uint64 totalBurnAmount;
- uint64 totalCharityAmount;
- uint64 totalShareholderAmount;
- uint64 totalRegisterAmount;
- uint64 totalFeeAmount;
- uint64 totalWinnerAmount;
- uint64 largestWinnerAmount;
- uint32 numberOfRegisters;
- uint32 numberOfProposals;
- uint32 numberOfQuRaffleMembers;
- uint32 numberOfActiveTokenRaffle;
- uint32 numberOfEndedTokenRaffle;
- uint32 numberOfEntryAmountSubmitted;
- sint32 returnCode;
- };
-
- struct getActiveProposal_input
- {
- uint32 indexOfProposal;
- };
-
- struct getActiveProposal_output
- {
- id tokenIssuer;
- id proposer;
- uint64 tokenName;
- uint64 entryAmount;
- uint32 nYes;
- uint32 nNo;
- sint32 returnCode;
- };
-
- struct getEndedTokenRaffle_input
- {
- uint32 indexOfRaffle;
- };
-
- struct getEndedTokenRaffle_output
- {
- id epochWinner;
- id tokenIssuer;
- uint64 tokenName;
- uint64 entryAmount;
- uint32 numberOfMembers;
- uint32 winnerIndex;
- uint32 epoch;
- sint32 returnCode;
- };
-
- struct getEpochRaffleIndexes_input
- {
- uint32 epoch;
- };
-
- struct getEpochRaffleIndexes_output
- {
- uint32 StartIndex;
- uint32 EndIndex;
- sint32 returnCode;
- };
-
- struct getEndedQuRaffle_input
- {
- uint32 epoch;
- };
-
- struct getEndedQuRaffle_output
- {
- id epochWinner;
- uint64 receivedAmount;
- uint64 entryAmount;
- uint32 numberOfMembers;
- uint32 winnerIndex;
- uint32 numberOfDaoMembers;
- sint32 returnCode;
- };
-
- struct getActiveTokenRaffle_input
- {
- uint32 indexOfTokenRaffle;
- };
-
- struct getActiveTokenRaffle_output
- {
- id tokenIssuer;
- uint64 tokenName;
- uint64 entryAmount;
- uint32 numberOfMembers;
- sint32 returnCode;
- };
-
- struct getQuRaffleEntryAmountPerUser_input
- {
- id user;
- };
-
- struct getQuRaffleEntryAmountPerUser_output
- {
- uint64 entryAmount;
- sint32 returnCode;
- };
-
- struct getQuRaffleEntryAverageAmount_input
- {
- };
-
- struct getQuRaffleEntryAverageAmount_output
- {
- uint64 entryAverageAmount;
- sint32 returnCode;
- };
-
- // ── Asset Raffle I/O structs ───────────────────────────────────────────────
-
- struct createAssetRaffle_input
- {
- // Bundle: fixed-capacity QPI Array; only [0..bundleSize) are used.
- Array bundleItems;
- uint32 bundleSize;
- uint64 reservePriceQu; // min Qu creator wants AFTER 20% service fee
- uint64 entryTicketQu; // Qu per ticket
- };
-
- struct createAssetRaffle_output
- {
- uint32 raffleIndex;
- sint32 returnCode;
- };
-
- struct buyAssetRaffleTicket_input
- {
- uint32 indexOfAssetRaffle;
- uint32 numberOfTickets;
- };
-
- struct buyAssetRaffleTicket_output
- {
- uint32 ticketsBought;
- sint32 returnCode;
- };
-
- struct cancelAssetRaffle_input
- {
- uint32 indexOfAssetRaffle;
- };
-
- struct cancelAssetRaffle_output
- {
- sint32 returnCode;
- };
-
- struct getActiveAssetRaffle_input
- {
- uint32 indexOfAssetRaffle;
- };
-
- struct getActiveAssetRaffle_output
- {
- id creator;
- uint64 reservePriceQu;
- uint64 entryTicketQu;
- uint64 totalTicketsPaidQu;
- uint32 numberOfBuyers;
- uint32 totalTickets;
- uint32 bundleSize;
- uint32 epoch;
- sint32 returnCode;
- };
-
- struct getActiveAssetRaffleBundleItem_input
- {
- uint32 indexOfAssetRaffle;
- uint32 itemIndex;
- };
-
- struct getActiveAssetRaffleBundleItem_output
- {
- id assetIssuer;
- uint64 assetName;
- sint64 numberOfShares;
- sint32 returnCode;
- };
-
- struct getActiveAssetRaffleBuyer_input
- {
- uint32 indexOfAssetRaffle;
- uint32 buyerIndex;
- };
-
- struct getActiveAssetRaffleBuyer_output
- {
- id buyer;
- uint32 ticketCount;
- sint32 returnCode;
- };
-
- struct getEndedAssetRaffle_input
- {
- uint32 indexOfRaffle;
- };
-
- struct getEndedAssetRaffle_output
- {
- id creator;
- id epochWinner;
- uint64 reservePriceQu;
- uint64 entryTicketQu;
- uint64 grossPoolQu;
- uint64 creatorPaidQu;
- uint32 totalTickets;
- uint32 numberOfBuyers;
- uint32 bundleSize;
- uint32 epoch;
- uint8 reserveMet;
- sint32 returnCode;
- };
-
- struct getAssetRaffleAnalytics_input
- {
- };
-
- struct getAssetRaffleAnalytics_output
- {
- uint64 totalAssetRaffleProposalFees;
- uint64 totalAssetRaffleCreatorPaid;
- uint64 totalAssetRaffleRefunded;
- uint32 numberOfActiveAssetRaffles;
- uint32 numberOfEndedAssetRaffles;
- uint32 totalAssetRafflesCreated;
- uint32 totalAssetRafflesSucceeded;
- uint32 totalAssetRafflesFailed;
- sint32 returnCode;
- };
-
-protected:
-
-
- struct registerInSystem_locals
- {
- Logger log;
- };
-
- PUBLIC_PROCEDURE_WITH_LOCALS(registerInSystem)
- {
- if (state.get().registers.contains(qpi.invocator()))
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- output.returnCode = QRAFFLE_ALREADY_REGISTERED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_alreadyRegistered, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- if (state.get().numberOfRegisters >= QRAFFLE_MAX_MEMBER)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- output.returnCode = QRAFFLE_MAX_MEMBER_REACHED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_maxMemberReached, 0 };
- LOG_INFO(locals.log);
- return ;
- }
-
- if (input.useQXMR)
- {
- // refund the invocation reward if the user uses QXMR for registration
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- // Use QXMR tokens for registration
- if (qpi.numberOfPossessedShares(QRAFFLE_QXMR_ASSET_NAME, state.get().QXMRIssuer, qpi.invocator(), qpi.invocator(), SELF_INDEX, SELF_INDEX) < QRAFFLE_QXMR_REGISTER_AMOUNT)
- {
- output.returnCode = QRAFFLE_INSUFFICIENT_QXMR;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_insufficientQXMR, 0 };
- LOG_INFO(locals.log);
- return ;
- }
-
- // Transfer QXMR tokens to the contract
- if (qpi.transferShareOwnershipAndPossession(QRAFFLE_QXMR_ASSET_NAME, state.get().QXMRIssuer, qpi.invocator(), qpi.invocator(), QRAFFLE_QXMR_REGISTER_AMOUNT, SELF) < 0)
- {
- output.returnCode = QRAFFLE_INSUFFICIENT_QXMR;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_insufficientQXMR, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- state.mut().registers.set(qpi.invocator(), 2);
- }
- else
- {
- // Use qubic for registration
- if (qpi.invocationReward() < QRAFFLE_REGISTER_AMOUNT)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- output.returnCode = QRAFFLE_INSUFFICIENT_FUND;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_insufficientQubic, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - QRAFFLE_REGISTER_AMOUNT);
- state.mut().registers.set(qpi.invocator(), 1);
- }
-
- state.mut().numberOfRegisters++;
- output.returnCode = QRAFFLE_SUCCESS;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_success, 0 };
- LOG_INFO(locals.log);
- }
-
- struct logoutInSystem_locals
- {
- sint64 refundAmount;
- uint8 tokenType;
- Logger log;
- };
-
- PUBLIC_PROCEDURE_WITH_LOCALS(logoutInSystem)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- if (qpi.invocator() == state.get().initialRegister1 || qpi.invocator() == state.get().initialRegister2 || qpi.invocator() == state.get().initialRegister3 || qpi.invocator() == state.get().initialRegister4 || qpi.invocator() == state.get().initialRegister5)
- {
- output.returnCode = QRAFFLE_INITIAL_REGISTER_CANNOT_LOGOUT;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_initialRegisterCannotLogout, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- if (state.get().registers.contains(qpi.invocator()) == 0)
- {
- output.returnCode = QRAFFLE_UNREGISTERED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_unregistered, 0 };
- LOG_INFO(locals.log);
- return ;
- }
-
- state.get().registers.get(qpi.invocator(), locals.tokenType);
-
- if (locals.tokenType == 1)
- {
- // Use qubic for logout
- locals.refundAmount = QRAFFLE_REGISTER_AMOUNT - QRAFFLE_LOGOUT_FEE;
- qpi.transfer(qpi.invocator(), locals.refundAmount);
- state.mut().epochRevenue += QRAFFLE_LOGOUT_FEE;
- }
- else if (locals.tokenType == 2)
- {
- // Use QXMR tokens for logout
- locals.refundAmount = QRAFFLE_QXMR_REGISTER_AMOUNT - QRAFFLE_QXMR_LOGOUT_FEE;
-
- // Check if contract has enough QXMR tokens
- if (qpi.numberOfPossessedShares(QRAFFLE_QXMR_ASSET_NAME, state.get().QXMRIssuer, SELF, SELF, SELF_INDEX, SELF_INDEX) < locals.refundAmount)
- {
- output.returnCode = QRAFFLE_INSUFFICIENT_QXMR;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_insufficientQXMR, 0 };
- LOG_INFO(locals.log);
- return ;
- }
-
- // Transfer QXMR tokens back to user
- if (qpi.transferShareOwnershipAndPossession(QRAFFLE_QXMR_ASSET_NAME, state.get().QXMRIssuer, SELF, SELF, locals.refundAmount, qpi.invocator()) < 0)
- {
- output.returnCode = QRAFFLE_INSUFFICIENT_QXMR;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_insufficientQXMR, 0 };
- LOG_INFO(locals.log);
- return ;
- }
-
- state.mut().epochQXMRRevenue += QRAFFLE_QXMR_LOGOUT_FEE;
- }
-
- state.mut().registers.removeByKey(qpi.invocator());
- state.mut().numberOfRegisters--;
- output.returnCode = QRAFFLE_SUCCESS;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_success, 0 };
- LOG_INFO(locals.log);
- }
-
- struct submitEntryAmount_locals
- {
- Logger log;
- };
-
- PUBLIC_PROCEDURE_WITH_LOCALS(submitEntryAmount)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- if (input.amount < QRAFFLE_MIN_QRAFFLE_AMOUNT || input.amount > QRAFFLE_MAX_QRAFFLE_AMOUNT)
- {
- output.returnCode = QRAFFLE_INVALID_ENTRY_AMOUNT;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_invalidEntryAmount, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- if (state.get().registers.contains(qpi.invocator()) == 0)
- {
- output.returnCode = QRAFFLE_UNREGISTERED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_unregistered, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- if (state.get().quRaffleEntryAmount.contains(qpi.invocator()) == 0)
- {
- state.mut().numberOfEntryAmountSubmitted++;
- }
- state.mut().quRaffleEntryAmount.set(qpi.invocator(), input.amount);
- output.returnCode = QRAFFLE_SUCCESS;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_success, 0 };
- LOG_INFO(locals.log);
- }
-
- struct submitProposal_locals
- {
- ProposalInfo proposal;
- uint8 countThisEpoch;
- Logger log;
- };
-
- PUBLIC_PROCEDURE_WITH_LOCALS(submitProposal)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- if (state.get().registers.contains(qpi.invocator()) == 0)
- {
- output.returnCode = QRAFFLE_UNREGISTERED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_unregistered, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- if (state.get().numberOfProposals >= QRAFFLE_MAX_PROPOSAL_EPOCH)
- {
- output.returnCode = QRAFFLE_MAX_PROPOSAL_EPOCH_REACHED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_maxProposalEpochReached, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- locals.countThisEpoch = 0;
- if (state.get().proposalsPerProposer.contains(qpi.invocator()))
- {
- state.get().proposalsPerProposer.get(qpi.invocator(), locals.countThisEpoch);
- }
- if (locals.countThisEpoch >= QRAFFLE_MAX_PROPOSALS_PER_PROPOSER)
- {
- output.returnCode = QRAFFLE_MAX_PROPOSAL_PER_USER_REACHED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_maxProposalPerUserReached, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- if (input.entryAmount <= 0)
- {
- output.returnCode = QRAFFLE_INVALID_ENTRY_AMOUNT;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_invalidEntryAmount, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- if (!qpi.isAssetIssued(input.tokenIssuer, input.tokenName))
- {
- output.returnCode = QRAFFLE_INVALID_TOKEN_TYPE;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_invalidTokenType, 0 };
- LOG_INFO(locals.log);
- return ;
- }
-
- locals.proposal.token.issuer = input.tokenIssuer;
- locals.proposal.token.assetName = input.tokenName;
- locals.proposal.entryAmount = input.entryAmount;
- locals.proposal.proposer = qpi.invocator();
- state.mut().proposals.set(state.get().numberOfProposals, locals.proposal);
- state.mut().numberOfProposals++;
- state.mut().proposalsPerProposer.set(qpi.invocator(), locals.countThisEpoch + 1);
- output.returnCode = QRAFFLE_SUCCESS;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_proposalSubmitted, 0 };
- LOG_INFO(locals.log);
- }
-
- struct voteInProposal_locals
- {
- ProposalInfo proposal;
- BitArray participation;
- BitArray values;
- uint32 votedCount;
- Logger log;
- };
-
- PUBLIC_PROCEDURE_WITH_LOCALS(voteInProposal)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- if (state.get().registers.contains(qpi.invocator()) == 0)
- {
- output.returnCode = QRAFFLE_UNREGISTERED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_unregistered, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- if (input.indexOfProposal >= state.get().numberOfProposals)
- {
- output.returnCode = QRAFFLE_INVALID_PROPOSAL;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_proposalNotFound, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- locals.proposal = state.get().proposals.get(input.indexOfProposal);
-
- // O(1) vote lookup via per-user bitfield (id hash, no K12 overhead).
- state.get().voteParticipation.get(qpi.invocator(), locals.participation);
- if (locals.participation.get(input.indexOfProposal))
- {
- // Already voted — check if same direction.
- state.get().voteValues.get(qpi.invocator(), locals.values);
- if (locals.values.get(input.indexOfProposal) == input.yes)
- {
- output.returnCode = QRAFFLE_ALREADY_VOTED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_alreadyVoted, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- // Flip the vote: update counters with underflow guard.
- if (input.yes)
- {
- locals.proposal.nYes++;
- if (locals.proposal.nNo > 0) { locals.proposal.nNo--; }
- }
- else
- {
- locals.proposal.nNo++;
- if (locals.proposal.nYes > 0) { locals.proposal.nYes--; }
- }
- state.mut().proposals.set(input.indexOfProposal, locals.proposal);
- locals.values.set(input.indexOfProposal, input.yes);
- state.mut().voteValues.replace(qpi.invocator(), locals.values);
- output.returnCode = QRAFFLE_SUCCESS;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_proposalVoted, 0 };
- LOG_INFO(locals.log);
- return ;
- }
-
- // New vote: check capacity before inserting.
- locals.votedCount = state.get().numberOfVotedInProposal.get(input.indexOfProposal);
- if (locals.votedCount >= QRAFFLE_MAX_MEMBER)
- {
- output.returnCode = QRAFFLE_MAX_MEMBER_REACHED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_maxMemberReached, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- if (input.yes)
- {
- locals.proposal.nYes++;
- }
- else
- {
- locals.proposal.nNo++;
- }
- state.mut().proposals.set(input.indexOfProposal, locals.proposal);
-
- // Mark participation and record vote direction.
- locals.participation.set(input.indexOfProposal, 1);
- state.mut().voteParticipation.set(qpi.invocator(), locals.participation);
- state.get().voteValues.get(qpi.invocator(), locals.values);
- locals.values.set(input.indexOfProposal, input.yes);
- state.mut().voteValues.set(qpi.invocator(), locals.values);
-
- state.mut().numberOfVotedInProposal.set(input.indexOfProposal, locals.votedCount + 1);
- output.returnCode = QRAFFLE_SUCCESS;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_proposalVoted, 0 };
- LOG_INFO(locals.log);
- }
-
- struct depositInQuRaffle_locals
- {
- Logger log;
- };
-
- PUBLIC_PROCEDURE_WITH_LOCALS(depositInQuRaffle)
- {
- if (state.get().numberOfQuRaffleMembers >= QRAFFLE_MAX_MEMBER)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- output.returnCode = QRAFFLE_MAX_MEMBER_REACHED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_maxMemberReachedForQuRaffle, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- if (qpi.invocationReward() < (sint64)state.get().qREAmount)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- output.returnCode = QRAFFLE_INSUFFICIENT_FUND;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_insufficientQubic, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- // O(1) duplicate check via HashSet (replaces former O(N) linear scan over quRaffleMembers).
- if (state.get().quRaffleMemberSet.contains(qpi.invocator()))
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- output.returnCode = QRAFFLE_ALREADY_REGISTERED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_alreadyRegistered, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - state.get().qREAmount);
- state.mut().quRaffleMembers.set(state.get().numberOfQuRaffleMembers, qpi.invocator());
- state.mut().quRaffleMemberSet.add(qpi.invocator());
- state.mut().numberOfQuRaffleMembers++;
- output.returnCode = QRAFFLE_SUCCESS;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_quRaffleDeposited, 0 };
- LOG_INFO(locals.log);
- }
-
- struct depositInTokenRaffle_locals
- {
- ActiveTokenRaffleInfo raffleInfo;
- BitArray participation;
- uint32 currentMembers;
- Logger log;
- };
-
- PUBLIC_PROCEDURE_WITH_LOCALS(depositInTokenRaffle)
- {
- if (qpi.invocationReward() < QRAFFLE_TRANSFER_SHARE_FEE)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- output.returnCode = QRAFFLE_INSUFFICIENT_FUND;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_insufficientQubic, 0 };
- LOG_INFO(locals.log);
- return ;
- }
-
- if (input.indexOfTokenRaffle >= state.get().numberOfActiveTokenRaffle)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- output.returnCode = QRAFFLE_INVALID_TOKEN_RAFFLE;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_invalidTokenRaffle, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- locals.currentMembers = state.get().numberOfTokenRaffleMembers.get(input.indexOfTokenRaffle);
- if (locals.currentMembers >= QRAFFLE_TOKEN_RAFFLE_SLOT_SIZE)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- output.returnCode = QRAFFLE_MAX_MEMBER_REACHED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_maxMemberReached, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- // O(1) duplicate check via per-user bitfield.
- state.get().tokenRaffleParticipation.get(qpi.invocator(), locals.participation);
- if (locals.participation.get(input.indexOfTokenRaffle))
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- output.returnCode = QRAFFLE_ALREADY_REGISTERED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_alreadyRegistered, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- locals.raffleInfo = state.get().activeTokenRaffle.get(input.indexOfTokenRaffle);
- if (qpi.transferShareOwnershipAndPossession(locals.raffleInfo.token.assetName, locals.raffleInfo.token.issuer, qpi.invocator(), qpi.invocator(), locals.raffleInfo.entryAmount, SELF) < 0)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- output.returnCode = QRAFFLE_FAILED_TO_DEPOSIT;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_transferFailed, 0 };
- LOG_INFO(locals.log);
- return ;
- }
- // Keep QRAFFLE_TRANSFER_SHARE_FEE as service revenue; refund any excess.
- if (qpi.invocationReward() > QRAFFLE_TRANSFER_SHARE_FEE)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - QRAFFLE_TRANSFER_SHARE_FEE);
- }
- state.mut().epochRevenue += QRAFFLE_TRANSFER_SHARE_FEE;
-
- // Store member in flat slot array and mark participation.
- state.mut().tokenRaffleMemberSlots.set(input.indexOfTokenRaffle * QRAFFLE_TOKEN_RAFFLE_SLOT_SIZE + locals.currentMembers, qpi.invocator());
- state.mut().numberOfTokenRaffleMembers.set(input.indexOfTokenRaffle, locals.currentMembers + 1);
- locals.participation.set(input.indexOfTokenRaffle, 1);
- state.mut().tokenRaffleParticipation.set(qpi.invocator(), locals.participation);
- output.returnCode = QRAFFLE_SUCCESS;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_tokenRaffleDeposited, 0 };
- LOG_INFO(locals.log);
- }
-
- struct TransferShareManagementRights_locals
- {
- Asset asset;
- sint64 offeredFee;
- sint64 paidFee;
- Logger log;
- };
-
- PUBLIC_PROCEDURE_WITH_LOCALS(TransferShareManagementRights)
- {
- // Requires QRAFFLE_TRANSFER_SHARE_FEE minimum. The rest is offered to the destination
- // contract as transfer fee; the unused portion is refunded after releaseShares.
- if (qpi.invocationReward() < QRAFFLE_TRANSFER_SHARE_FEE)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_insufficientQubic, 0 };
- LOG_INFO(locals.log);
- return ;
- }
-
- if (qpi.numberOfPossessedShares(input.tokenName, input.tokenIssuer,qpi.invocator(), qpi.invocator(), SELF_INDEX, SELF_INDEX) < input.numberOfShares)
- {
- // Not enough shares — refund in full.
- output.transferredNumberOfShares = 0;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_notEnoughShares, 0 };
- LOG_INFO(locals.log);
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- }
- else
- {
- locals.asset.assetName = input.tokenName;
- locals.asset.issuer = input.tokenIssuer;
- locals.offeredFee = qpi.invocationReward() - QRAFFLE_TRANSFER_SHARE_FEE;
- locals.paidFee = qpi.releaseShares(locals.asset, qpi.invocator(), qpi.invocator(), input.numberOfShares,
- input.newManagingContractIndex, input.newManagingContractIndex, locals.offeredFee);
- if (locals.paidFee < 0)
- {
- // Transfer rejected by the destination — refund everything.
- output.transferredNumberOfShares = 0;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_transferFailed, 0 };
- LOG_INFO(locals.log);
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- }
- else
- {
- // Success — keep service fee as revenue, refund unused transfer fee.
- output.transferredNumberOfShares = input.numberOfShares;
- state.mut().epochRevenue += QRAFFLE_TRANSFER_SHARE_FEE;
- if (locals.offeredFee > locals.paidFee)
- {
- qpi.transfer(qpi.invocator(), locals.offeredFee - locals.paidFee);
- }
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_shareManagementRightsTransferred, 0 };
- LOG_INFO(locals.log);
- }
- }
- }
-
- // ── createAssetRaffle ──────────────────────────────────────────────────────
- struct createAssetRaffle_locals
- {
- AssetRaffleItem item;
- AssetRaffleItem dupItem;
- AssetRaffleItem rollbackItem;
- AssetRaffleInfo info;
- AssetRaffleCreatedLogger clog;
- Logger log;
- uint64 proposalFeeHalf;
- uint8 creatorCount;
- uint32 slot;
- uint32 i;
- uint32 j;
- sint64 escrowResult;
- bit dupFound;
- };
-
- PUBLIC_PROCEDURE_WITH_LOCALS(createAssetRaffle)
- {
- if (qpi.invocationReward() < (sint64)QRAFFLE_ASSET_RAFFLE_PROPOSAL_FEE)
- {
- if (qpi.invocationReward() > 0) { qpi.transfer(qpi.invocator(), qpi.invocationReward()); }
- output.returnCode = QRAFFLE_INSUFFICIENT_FUND;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_insufficientQubic, 0 };
- LOG_INFO(locals.log);
- return;
- }
- if (!state.get().registers.contains(qpi.invocator()))
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- output.returnCode = QRAFFLE_UNREGISTERED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_unregistered, 0 };
- LOG_INFO(locals.log);
- return;
- }
- locals.creatorCount = 0;
- if (state.get().assetRafflesPerCreator.contains(qpi.invocator()))
- {
- state.get().assetRafflesPerCreator.get(qpi.invocator(), locals.creatorCount);
- }
- if (locals.creatorCount >= QRAFFLE_MAX_ASSET_RAFFLES_PER_CREATOR)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- output.returnCode = QRAFFLE_MAX_ASSET_RAFFLES_REACHED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_maxAssetRafflesReached, 0 };
- LOG_INFO(locals.log);
- return;
- }
- if (state.get().numberOfActiveAssetRaffles >= QRAFFLE_MAX_ASSET_RAFFLES_PER_EPOCH)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- output.returnCode = QRAFFLE_MAX_ASSET_RAFFLES_REACHED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_maxAssetRafflesReached, 0 };
- LOG_INFO(locals.log);
- return;
- }
- if (input.bundleSize == 0 || input.bundleSize > QRAFFLE_MAX_ASSETS_PER_BUNDLE)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- output.returnCode = QRAFFLE_INVALID_BUNDLE;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_invalidBundle, 0 };
- LOG_INFO(locals.log);
- return;
- }
- if (input.entryTicketQu < QRAFFLE_MIN_ASSET_TICKET_AMOUNT || input.entryTicketQu > QRAFFLE_MAX_ASSET_TICKET_AMOUNT)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- output.returnCode = QRAFFLE_INVALID_ENTRY_AMOUNT;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_invalidEntryAmount, 0 };
- LOG_INFO(locals.log);
- return;
- }
- if (input.reservePriceQu == 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- output.returnCode = QRAFFLE_INVALID_RESERVE_PRICE;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_invalidReservePrice, 0 };
- LOG_INFO(locals.log);
- return;
- }
- // Guard against uint64 overflow in the END_EPOCH reserve check (reservePriceQu * 100).
- if (input.reservePriceQu > div(0xFFFFFFFFFFFFFFFFull, 100ull))
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- output.returnCode = QRAFFLE_INVALID_RESERVE_PRICE;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_invalidReservePrice, 0 };
- LOG_INFO(locals.log);
- return;
- }
- for (locals.i = 0; locals.i < input.bundleSize; locals.i++)
- {
- locals.item = input.bundleItems.get(locals.i);
- if (!qpi.isAssetIssued(locals.item.asset.issuer, locals.item.asset.assetName))
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- output.returnCode = QRAFFLE_INVALID_BUNDLE;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_invalidBundle, 0 };
- LOG_INFO(locals.log);
- return;
- }
- if (locals.item.numberOfShares <= 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- output.returnCode = QRAFFLE_INVALID_BUNDLE;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_invalidBundle, 0 };
- LOG_INFO(locals.log);
- return;
- }
- // QRAFFLE and QXMR are reserved for dividends/registration; disallow in bundles.
- if ((locals.item.asset.assetName == QRAFFLE_ASSET_NAME && locals.item.asset.issuer == NULL_ID)
- || (locals.item.asset.assetName == QRAFFLE_QXMR_ASSET_NAME && locals.item.asset.issuer == state.get().QXMRIssuer))
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- output.returnCode = QRAFFLE_INVALID_BUNDLE;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_invalidBundle, 0 };
- LOG_INFO(locals.log);
- return;
- }
- // Duplicate-asset check within the bundle; O(N²) acceptable for N ≤ 4.
- locals.dupFound = 0;
- for (locals.j = 0; locals.j < locals.i; locals.j++)
- {
- locals.dupItem = input.bundleItems.get(locals.j);
- if (locals.dupItem.asset.assetName == locals.item.asset.assetName
- && locals.dupItem.asset.issuer == locals.item.asset.issuer)
- {
- locals.dupFound = 1;
- break;
- }
- }
- if (locals.dupFound)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- output.returnCode = QRAFFLE_INVALID_BUNDLE;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_invalidBundle, 0 };
- LOG_INFO(locals.log);
- return;
- }
- }
-
- // Atomic escrow: if any item fails, roll back all previously transferred items.
- locals.slot = state.get().numberOfActiveAssetRaffles;
- for (locals.i = 0; locals.i < input.bundleSize; locals.i++)
- {
- locals.item = input.bundleItems.get(locals.i);
- locals.escrowResult = qpi.transferShareOwnershipAndPossession(
- locals.item.asset.assetName, locals.item.asset.issuer,
- qpi.invocator(), qpi.invocator(),
- locals.item.numberOfShares, SELF);
- if (locals.escrowResult < 0)
- {
- // Rollback: return all previously escrowed items to the invocator.
- // These transfers move shares we just received from the same invocator back to
- // them, so they should not fail in normal circumstances. If a rollback transfer
- // does fail (e.g. spectrum entry evicted), residual shares stay under contract
- // management for governance recovery.
- for (locals.j = 0; locals.j < locals.i; locals.j++)
- {
- locals.rollbackItem = input.bundleItems.get(locals.j);
- qpi.transferShareOwnershipAndPossession(
- locals.rollbackItem.asset.assetName, locals.rollbackItem.asset.issuer,
- SELF, SELF,
- locals.rollbackItem.numberOfShares, qpi.invocator());
- }
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- output.returnCode = QRAFFLE_BUNDLE_ESCROW_FAILED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_assetRaffleBundleEscrowFailed, 0 };
- LOG_INFO(locals.log);
- return;
- }
- state.mut().activeAssetRaffleItems.set(locals.slot * QRAFFLE_MAX_ASSETS_PER_BUNDLE + locals.i, locals.item);
- }
-
- locals.info.creator = qpi.invocator();
- locals.info.reservePriceQu = input.reservePriceQu;
- locals.info.entryTicketQu = input.entryTicketQu;
- locals.info.totalTicketsPaidQu = 0;
- locals.info.numberOfBuyers = 0;
- locals.info.totalTickets = 0;
- locals.info.bundleSize = input.bundleSize;
- locals.info.epoch = qpi.epoch();
- state.mut().activeAssetRaffles.set(locals.slot, locals.info);
- state.mut().numberOfActiveAssetRaffles++;
- state.mut().assetRafflesPerCreator.set(qpi.invocator(), locals.creatorCount + 1);
-
- // 50% of proposal fee → shareholders via epochRevenue; 50% → DAO bucket distributed in END_EPOCH.
- locals.proposalFeeHalf = div(QRAFFLE_ASSET_RAFFLE_PROPOSAL_FEE, 2);
- state.mut().epochRevenue += locals.proposalFeeHalf;
- state.mut().epochAssetRaffleDaoBucket += (QRAFFLE_ASSET_RAFFLE_PROPOSAL_FEE - locals.proposalFeeHalf);
- state.mut().totalAssetRaffleProposalFees += QRAFFLE_ASSET_RAFFLE_PROPOSAL_FEE;
- state.mut().totalAssetRafflesCreated++;
-
- if (qpi.invocationReward() > (sint64)QRAFFLE_ASSET_RAFFLE_PROPOSAL_FEE)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - (sint64)QRAFFLE_ASSET_RAFFLE_PROPOSAL_FEE);
- }
-
- output.raffleIndex = locals.slot;
- output.returnCode = QRAFFLE_SUCCESS;
- locals.clog = AssetRaffleCreatedLogger{
- QRAFFLE_CONTRACT_INDEX, QRAFFLE_assetRaffleCreated,
- locals.slot, qpi.invocator(),
- input.reservePriceQu, input.entryTicketQu,
- input.bundleSize, 0
- };
- LOG_INFO(locals.clog);
- }
-
- // ── buyAssetRaffleTicket ───────────────────────────────────────────────────
- struct buyAssetRaffleTicket_locals
- {
- AssetRaffleInfo info;
- AssetRaffleTicketLogger tlog;
- Logger log;
- BitArray participation;
- Array slotIndexArr;
- uint64 cost;
- uint32 baseSlot;
- uint32 existingTickets;
- uint32 buyerSlot;
- bit isNewBuyer;
- };
-
- PUBLIC_PROCEDURE_WITH_LOCALS(buyAssetRaffleTicket)
- {
- if (input.indexOfAssetRaffle >= state.get().numberOfActiveAssetRaffles)
- {
- if (qpi.invocationReward() > 0) { qpi.transfer(qpi.invocator(), qpi.invocationReward()); }
- output.returnCode = QRAFFLE_INVALID_ASSET_RAFFLE;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_invalidTokenRaffle, 0 };
- LOG_INFO(locals.log);
- return;
- }
- if (input.numberOfTickets == 0 || input.numberOfTickets > QRAFFLE_MAX_TICKETS_PER_BUYER)
- {
- // Reject zero or absurd ticket counts up-front so the cost multiplication below cannot overflow.
- if (qpi.invocationReward() > 0) { qpi.transfer(qpi.invocator(), qpi.invocationReward()); }
- output.returnCode = QRAFFLE_INVALID_ENTRY_AMOUNT;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_invalidEntryAmount, 0 };
- LOG_INFO(locals.log);
- return;
- }
- locals.info = state.get().activeAssetRaffles.get(input.indexOfAssetRaffle);
- // Overflow-safe cost: entryTicketQu ≤ 1e12 (QRAFFLE_MAX_ASSET_TICKET_AMOUNT) and tickets ≤ 100,
- // so cost ≤ 1e14, safely under uint64 max (~1.8e19). totalTicketsPaidQu accumulates across
- // up to 1024 buyers, max ~1e17, also safe.
- locals.cost = locals.info.entryTicketQu * (uint64)input.numberOfTickets;
- if (qpi.invocationReward() < (sint64)locals.cost)
- {
- if (qpi.invocationReward() > 0) { qpi.transfer(qpi.invocator(), qpi.invocationReward()); }
- output.returnCode = QRAFFLE_INSUFFICIENT_FUND;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_insufficientQubic, 0 };
- LOG_INFO(locals.log);
- return;
- }
-
- locals.baseSlot = input.indexOfAssetRaffle * QRAFFLE_MAX_ASSET_TICKET_BUYERS;
- locals.existingTickets = 0;
- locals.isNewBuyer = 1;
- locals.buyerSlot = locals.baseSlot + locals.info.numberOfBuyers;
-
- state.get().assetRaffleParticipation.get(qpi.invocator(), locals.participation);
- if (locals.participation.get(input.indexOfAssetRaffle))
- {
- // Returning buyer: resolve slot via index map (O(1)).
- locals.isNewBuyer = 0;
- state.get().assetRaffleBuyerSlotIndex.get(qpi.invocator(), locals.slotIndexArr);
- locals.buyerSlot = locals.baseSlot + (uint32)locals.slotIndexArr.get(input.indexOfAssetRaffle);
- locals.existingTickets = state.get().activeAssetRaffleBuyerTickets.get(locals.buyerSlot);
- }
-
- if (locals.existingTickets + input.numberOfTickets > QRAFFLE_MAX_TICKETS_PER_BUYER)
- {
- if (qpi.invocationReward() > 0) { qpi.transfer(qpi.invocator(), qpi.invocationReward()); }
- output.returnCode = QRAFFLE_TICKET_LIMIT_REACHED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_ticketLimitReached, 0 };
- LOG_INFO(locals.log);
- return;
- }
-
- if (locals.isNewBuyer)
- {
- if (locals.info.numberOfBuyers >= QRAFFLE_MAX_ASSET_TICKET_BUYERS)
- {
- if (qpi.invocationReward() > 0) { qpi.transfer(qpi.invocator(), qpi.invocationReward()); }
- output.returnCode = QRAFFLE_ASSET_RAFFLE_FULL;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_assetRaffleFull, 0 };
- LOG_INFO(locals.log);
- return;
- }
- state.mut().activeAssetRaffleBuyers.set(locals.buyerSlot, qpi.invocator());
- // Record slot position so future purchases skip the buyer-list scan.
- state.get().assetRaffleBuyerSlotIndex.get(qpi.invocator(), locals.slotIndexArr);
- locals.slotIndexArr.set(input.indexOfAssetRaffle, (uint16)locals.info.numberOfBuyers);
- state.mut().assetRaffleBuyerSlotIndex.set(qpi.invocator(), locals.slotIndexArr);
- locals.participation.set(input.indexOfAssetRaffle, 1);
- state.mut().assetRaffleParticipation.set(qpi.invocator(), locals.participation);
- locals.info.numberOfBuyers++;
- }
-
- state.mut().activeAssetRaffleBuyerTickets.set(locals.buyerSlot, locals.existingTickets + input.numberOfTickets);
- locals.info.totalTickets += input.numberOfTickets;
- locals.info.totalTicketsPaidQu += locals.cost;
- state.mut().activeAssetRaffles.set(input.indexOfAssetRaffle, locals.info);
-
- if (qpi.invocationReward() > (sint64)locals.cost)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - (sint64)locals.cost);
- }
-
- output.ticketsBought = input.numberOfTickets;
- output.returnCode = QRAFFLE_SUCCESS;
- locals.tlog = AssetRaffleTicketLogger{
- QRAFFLE_CONTRACT_INDEX, QRAFFLE_assetRaffleTicketBought,
- input.indexOfAssetRaffle, qpi.invocator(),
- input.numberOfTickets, locals.cost, 0
- };
- LOG_INFO(locals.tlog);
- }
-
- // ── cancelAssetRaffle ──────────────────────────────────────────────────────
- struct cancelAssetRaffle_locals
- {
- AssetRaffleInfo info;
- AssetRaffleItem item;
- AssetRaffleInfo lastInfo;
- AssetRaffleItem lastItem;
- Array slotIndexArr;
- BitArray participation;
- Logger log;
- id movedBuyer;
- uint8 creatorCount;
- uint32 lastSlot;
- uint32 i;
- };
-
- PUBLIC_PROCEDURE_WITH_LOCALS(cancelAssetRaffle)
- {
- if (qpi.invocationReward() > 0) { qpi.transfer(qpi.invocator(), qpi.invocationReward()); }
-
- if (input.indexOfAssetRaffle >= state.get().numberOfActiveAssetRaffles)
- {
- output.returnCode = QRAFFLE_INVALID_ASSET_RAFFLE;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_invalidTokenRaffle, 0 };
- LOG_INFO(locals.log);
- return;
- }
- locals.info = state.get().activeAssetRaffles.get(input.indexOfAssetRaffle);
- if (locals.info.creator != qpi.invocator())
- {
- output.returnCode = QRAFFLE_CANCEL_NOT_ALLOWED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_cancelNotAllowed, 0 };
- LOG_INFO(locals.log);
- return;
- }
- if (locals.info.numberOfBuyers > 0)
- {
- output.returnCode = QRAFFLE_CANCEL_NOT_ALLOWED;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_cancelNotAllowed, 0 };
- LOG_INFO(locals.log);
- return;
- }
-
- for (locals.i = 0; locals.i < locals.info.bundleSize; locals.i++)
- {
- locals.item = state.get().activeAssetRaffleItems.get(input.indexOfAssetRaffle * QRAFFLE_MAX_ASSETS_PER_BUNDLE + locals.i);
- qpi.transferShareOwnershipAndPossession(
- locals.item.asset.assetName, locals.item.asset.issuer,
- SELF, SELF,
- locals.item.numberOfShares, qpi.invocator());
- }
-
- // Swap-and-pop: fill the vacated slot with the last active raffle.
- // Three parallel arrays must be kept in sync: raffle info, bundle items, and buyer lists.
- locals.lastSlot = state.get().numberOfActiveAssetRaffles - 1;
- if (input.indexOfAssetRaffle < locals.lastSlot)
- {
- locals.lastInfo = state.get().activeAssetRaffles.get(locals.lastSlot);
- state.mut().activeAssetRaffles.set(input.indexOfAssetRaffle, locals.lastInfo);
-
- for (locals.i = 0; locals.i < locals.lastInfo.bundleSize; locals.i++)
- {
- locals.lastItem = state.get().activeAssetRaffleItems.get(locals.lastSlot * QRAFFLE_MAX_ASSETS_PER_BUNDLE + locals.i);
- state.mut().activeAssetRaffleItems.set(input.indexOfAssetRaffle * QRAFFLE_MAX_ASSETS_PER_BUNDLE + locals.i, locals.lastItem);
- }
-
- // Cancelled raffle already has numberOfBuyers==0, so the destination region is safe to overwrite.
- for (locals.i = 0; locals.i < locals.lastInfo.numberOfBuyers; locals.i++)
- {
- locals.movedBuyer = state.get().activeAssetRaffleBuyers.get(locals.lastSlot * QRAFFLE_MAX_ASSET_TICKET_BUYERS + locals.i);
- state.mut().activeAssetRaffleBuyers.set(
- input.indexOfAssetRaffle * QRAFFLE_MAX_ASSET_TICKET_BUYERS + locals.i,
- locals.movedBuyer);
- state.mut().activeAssetRaffleBuyerTickets.set(
- input.indexOfAssetRaffle * QRAFFLE_MAX_ASSET_TICKET_BUYERS + locals.i,
- state.get().activeAssetRaffleBuyerTickets.get(locals.lastSlot * QRAFFLE_MAX_ASSET_TICKET_BUYERS + locals.i));
- // Update slot-index map: raffle index changed from lastSlot to indexOfAssetRaffle;
- // relative position within the buyer region is preserved.
- state.get().assetRaffleBuyerSlotIndex.get(locals.movedBuyer, locals.slotIndexArr);
- locals.slotIndexArr.set(input.indexOfAssetRaffle, locals.slotIndexArr.get(locals.lastSlot));
- locals.slotIndexArr.set(locals.lastSlot, 0xFFFF);
- state.mut().assetRaffleBuyerSlotIndex.replace(locals.movedBuyer, locals.slotIndexArr);
-
- // Keep participation bitfield aligned with moved raffle index.
- state.get().assetRaffleParticipation.get(locals.movedBuyer, locals.participation);
- locals.participation.set(input.indexOfAssetRaffle, 1);
- locals.participation.set(locals.lastSlot, 0);
- state.mut().assetRaffleParticipation.replace(locals.movedBuyer, locals.participation);
- }
- }
- state.mut().numberOfActiveAssetRaffles--;
-
- // Decrement per-creator counter so the creator can replace the cancelled raffle
- // within the same epoch. The 500K proposal fee is *not* refunded (anti-spam).
- locals.creatorCount = 0;
- if (state.get().assetRafflesPerCreator.contains(qpi.invocator()))
- {
- state.get().assetRafflesPerCreator.get(qpi.invocator(), locals.creatorCount);
- if (locals.creatorCount > 0)
- {
- state.mut().assetRafflesPerCreator.set(qpi.invocator(), (uint8)(locals.creatorCount - 1));
- }
- }
-
- output.returnCode = QRAFFLE_SUCCESS;
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_assetRaffleCancelled, 0 };
- LOG_INFO(locals.log);
- }
-
- struct getRegisters_locals
- {
- id user;
- sint64 idx;
- uint32 i;
- };
-
- PUBLIC_FUNCTION_WITH_LOCALS(getRegisters)
- {
- if (input.limit > 20)
- {
- output.returnCode = QRAFFLE_INVALID_OFFSET_OR_LIMIT;
- return ;
- }
- if (input.offset >= state.get().numberOfRegisters)
- {
- output.returnCode = QRAFFLE_SUCCESS;
- return ;
- }
- locals.idx = state.get().registers.nextElementIndex(NULL_INDEX);
- while (locals.idx != NULL_INDEX)
- {
- locals.user = state.get().registers.key(locals.idx);
- if (locals.i >= input.offset && locals.i < input.offset + input.limit)
- {
- if (locals.i - input.offset == 0)
- {
- output.register1 = locals.user;
- }
- else if (locals.i - input.offset == 1)
- {
- output.register2 = locals.user;
- }
- else if (locals.i - input.offset == 2)
- {
- output.register3 = locals.user;
- }
- else if (locals.i - input.offset == 3)
- {
- output.register4 = locals.user;
- }
- else if (locals.i - input.offset == 4)
- {
- output.register5 = locals.user;
- }
- else if (locals.i - input.offset == 5)
- {
- output.register6 = locals.user;
- }
- else if (locals.i - input.offset == 6)
- {
- output.register7 = locals.user;
- }
- else if (locals.i - input.offset == 7)
- {
- output.register8 = locals.user;
- }
- else if (locals.i - input.offset == 8)
- {
- output.register9 = locals.user;
- }
- else if (locals.i - input.offset == 9)
- {
- output.register10 = locals.user;
- }
- else if (locals.i - input.offset == 10)
- {
- output.register11 = locals.user;
- }
- else if (locals.i - input.offset == 11)
- {
- output.register12 = locals.user;
- }
- else if (locals.i - input.offset == 12)
- {
- output.register13 = locals.user;
- }
- else if (locals.i - input.offset == 13)
- {
- output.register14 = locals.user;
- }
- else if (locals.i - input.offset == 14)
- {
- output.register15 = locals.user;
- }
- else if (locals.i - input.offset == 15)
- {
- output.register16 = locals.user;
- }
- else if (locals.i - input.offset == 16)
- {
- output.register17 = locals.user;
- }
- else if (locals.i - input.offset == 17)
- {
- output.register18 = locals.user;
- }
- else if (locals.i - input.offset == 18)
- {
- output.register19 = locals.user;
- }
- else if (locals.i - input.offset == 19)
- {
- output.register20 = locals.user;
- }
- }
- if (locals.i >= input.offset + input.limit)
- {
- break;
- }
- locals.i++;
- locals.idx = state.get().registers.nextElementIndex(locals.idx);
- }
- output.returnCode = QRAFFLE_SUCCESS;
- }
-
- PUBLIC_FUNCTION(getAnalytics)
- {
- output.currentQuRaffleAmount = state.get().qREAmount;
- output.totalBurnAmount = state.get().totalBurnAmount;
- output.totalCharityAmount = state.get().totalCharityAmount;
- output.totalShareholderAmount = state.get().totalShareholderAmount;
- output.totalRegisterAmount = state.get().totalRegisterAmount;
- output.totalFeeAmount = state.get().totalFeeAmount;
- output.totalWinnerAmount = state.get().totalWinnerAmount;
- output.largestWinnerAmount = state.get().largestWinnerAmount;
- output.numberOfRegisters = state.get().numberOfRegisters;
- output.numberOfProposals = state.get().numberOfProposals;
- output.numberOfQuRaffleMembers = state.get().numberOfQuRaffleMembers;
- output.numberOfActiveTokenRaffle = state.get().numberOfActiveTokenRaffle;
- output.numberOfEndedTokenRaffle = state.get().numberOfEndedTokenRaffle;
- output.numberOfEntryAmountSubmitted = state.get().numberOfEntryAmountSubmitted;
- output.returnCode = QRAFFLE_SUCCESS;
- }
-
- PUBLIC_FUNCTION(getActiveProposal)
- {
- if (input.indexOfProposal >= state.get().numberOfProposals)
- {
- output.returnCode = QRAFFLE_INVALID_PROPOSAL;
- return ;
- }
- output.tokenName = state.get().proposals.get(input.indexOfProposal).token.assetName;
- output.tokenIssuer = state.get().proposals.get(input.indexOfProposal).token.issuer;
- output.proposer = state.get().proposals.get(input.indexOfProposal).proposer;
- output.entryAmount = state.get().proposals.get(input.indexOfProposal).entryAmount;
- output.nYes = state.get().proposals.get(input.indexOfProposal).nYes;
- output.nNo = state.get().proposals.get(input.indexOfProposal).nNo;
- output.returnCode = QRAFFLE_SUCCESS;
- }
-
- PUBLIC_FUNCTION(getEndedTokenRaffle)
- {
- if (input.indexOfRaffle >= state.get().numberOfEndedTokenRaffle)
- {
- output.returnCode = QRAFFLE_INVALID_TOKEN_RAFFLE;
- return ;
- }
- // Reject indices that have been overwritten by the ring buffer.
- if (state.get().numberOfEndedTokenRaffle > QRAFFLE_MAX_TOKEN_RAFFLES
- && input.indexOfRaffle < state.get().numberOfEndedTokenRaffle - QRAFFLE_MAX_TOKEN_RAFFLES)
- {
- output.returnCode = QRAFFLE_INVALID_TOKEN_RAFFLE;
- return ;
- }
- output.epochWinner = state.get().tokenRaffle.get(input.indexOfRaffle).epochWinner;
- output.tokenName = state.get().tokenRaffle.get(input.indexOfRaffle).token.assetName;
- output.tokenIssuer = state.get().tokenRaffle.get(input.indexOfRaffle).token.issuer;
- output.entryAmount = state.get().tokenRaffle.get(input.indexOfRaffle).entryAmount;
- output.numberOfMembers = state.get().tokenRaffle.get(input.indexOfRaffle).numberOfMembers;
- output.winnerIndex = state.get().tokenRaffle.get(input.indexOfRaffle).winnerIndex;
- output.epoch = state.get().tokenRaffle.get(input.indexOfRaffle).epoch;
- output.returnCode = QRAFFLE_SUCCESS;
- }
-
- struct getEpochRaffleIndexes_locals
- {
- uint32 ringStart;
- uint32 ringEnd;
- uint32 i;
- };
-
- PUBLIC_FUNCTION_WITH_LOCALS(getEpochRaffleIndexes)
- {
- output.StartIndex = 0;
- output.EndIndex = 0;
- if (input.epoch > qpi.epoch())
- {
- output.returnCode = QRAFFLE_INVALID_EPOCH;
- return ;
- }
- if (input.epoch == qpi.epoch())
- {
- output.StartIndex = 0;
- output.EndIndex = state.get().numberOfActiveTokenRaffle;
- output.returnCode = QRAFFLE_SUCCESS;
- return ;
- }
- // Only scan the valid ring window to avoid re-reading overwritten slots.
- locals.ringEnd = state.get().numberOfEndedTokenRaffle;
- locals.ringStart = (locals.ringEnd > QRAFFLE_MAX_TOKEN_RAFFLES) ? (locals.ringEnd - QRAFFLE_MAX_TOKEN_RAFFLES) : 0;
- for (locals.i = locals.ringStart; locals.i < locals.ringEnd; locals.i++)
- {
- if (state.get().tokenRaffle.get(locals.i).epoch == input.epoch)
- {
- output.StartIndex = locals.i;
- break;
- }
- }
- locals.i = locals.ringEnd;
- while (locals.i > locals.ringStart)
- {
- locals.i--;
- if (state.get().tokenRaffle.get(locals.i).epoch == input.epoch)
- {
- output.EndIndex = locals.i;
- break;
- }
- }
- output.returnCode = QRAFFLE_SUCCESS;
- }
-
- PUBLIC_FUNCTION(getEndedQuRaffle)
- {
- // Note: indices are masked by the underlying Array (capacity is power-of-two), so
- // any uint32 epoch value is safely bounded inside the QuRaffles ring. Slots that
- // were never written return a zero-initialised QuRaffleInfo, which the caller can
- // detect via numberOfMembers == 0 / epochWinner == NULL_ID.
- output.epochWinner = state.get().QuRaffles.get(input.epoch).epochWinner;
- output.receivedAmount = state.get().QuRaffles.get(input.epoch).receivedAmount;
- output.entryAmount = state.get().QuRaffles.get(input.epoch).entryAmount;
- output.numberOfMembers = state.get().QuRaffles.get(input.epoch).numberOfMembers;
- output.winnerIndex = state.get().QuRaffles.get(input.epoch).winnerIndex;
- output.numberOfDaoMembers = state.get().daoMemberCount.get(input.epoch);
- output.returnCode = QRAFFLE_SUCCESS;
- }
-
- PUBLIC_FUNCTION(getActiveTokenRaffle)
- {
- if (input.indexOfTokenRaffle >= state.get().numberOfActiveTokenRaffle)
- {
- output.returnCode = QRAFFLE_INVALID_TOKEN_RAFFLE;
- return ;
- }
- output.tokenName = state.get().activeTokenRaffle.get(input.indexOfTokenRaffle).token.assetName;
- output.tokenIssuer = state.get().activeTokenRaffle.get(input.indexOfTokenRaffle).token.issuer;
- output.entryAmount = state.get().activeTokenRaffle.get(input.indexOfTokenRaffle).entryAmount;
- output.numberOfMembers = state.get().numberOfTokenRaffleMembers.get(input.indexOfTokenRaffle);
- output.returnCode = QRAFFLE_SUCCESS;
- }
-
- PUBLIC_FUNCTION(getQuRaffleEntryAmountPerUser)
- {
- if (state.get().quRaffleEntryAmount.contains(input.user) == 0)
- {
- output.entryAmount = 0;
- output.returnCode = QRAFFLE_USER_NOT_FOUND;
- }
- else
- {
- state.get().quRaffleEntryAmount.get(input.user, output.entryAmount);
- output.returnCode = QRAFFLE_SUCCESS;
- }
- }
-
- struct getQuRaffleEntryAverageAmount_locals
- {
- uint64 entryAmount;
- uint64 totalEntryAmount;
- sint64 idx;
- };
-
- PUBLIC_FUNCTION_WITH_LOCALS(getQuRaffleEntryAverageAmount)
- {
- locals.entryAmount = 0;
- locals.totalEntryAmount = 0;
- locals.idx = state.get().quRaffleEntryAmount.nextElementIndex(NULL_INDEX);
- while (locals.idx != NULL_INDEX)
- {
- locals.entryAmount = state.get().quRaffleEntryAmount.value(locals.idx);
- locals.totalEntryAmount += locals.entryAmount;
- locals.idx = state.get().quRaffleEntryAmount.nextElementIndex(locals.idx);
- }
- if (state.get().numberOfEntryAmountSubmitted > 0)
- {
- output.entryAverageAmount = div(locals.totalEntryAmount, state.get().numberOfEntryAmountSubmitted);
- }
- else
- {
- output.entryAverageAmount = 0;
- }
- output.returnCode = QRAFFLE_SUCCESS;
- }
-
- // ── Asset Raffle view functions ────────────────────────────────────────────
-
- struct getActiveAssetRaffle_locals
- {
- AssetRaffleInfo info;
- };
-
- PUBLIC_FUNCTION_WITH_LOCALS(getActiveAssetRaffle)
- {
- if (input.indexOfAssetRaffle >= state.get().numberOfActiveAssetRaffles)
- {
- output.returnCode = QRAFFLE_INVALID_ASSET_RAFFLE;
- return;
- }
- locals.info = state.get().activeAssetRaffles.get(input.indexOfAssetRaffle);
- output.creator = locals.info.creator;
- output.reservePriceQu = locals.info.reservePriceQu;
- output.entryTicketQu = locals.info.entryTicketQu;
- output.totalTicketsPaidQu = locals.info.totalTicketsPaidQu;
- output.numberOfBuyers = locals.info.numberOfBuyers;
- output.totalTickets = locals.info.totalTickets;
- output.bundleSize = locals.info.bundleSize;
- output.epoch = locals.info.epoch;
- output.returnCode = QRAFFLE_SUCCESS;
- }
-
- struct getActiveAssetRaffleBundleItem_locals
- {
- AssetRaffleInfo info;
- AssetRaffleItem item;
- };
-
- PUBLIC_FUNCTION_WITH_LOCALS(getActiveAssetRaffleBundleItem)
- {
- if (input.indexOfAssetRaffle >= state.get().numberOfActiveAssetRaffles)
- {
- output.returnCode = QRAFFLE_INVALID_ASSET_RAFFLE;
- return;
- }
- locals.info = state.get().activeAssetRaffles.get(input.indexOfAssetRaffle);
- if (input.itemIndex >= locals.info.bundleSize)
- {
- output.returnCode = QRAFFLE_INVALID_BUNDLE;
- return;
- }
- locals.item = state.get().activeAssetRaffleItems.get(
- input.indexOfAssetRaffle * QRAFFLE_MAX_ASSETS_PER_BUNDLE + input.itemIndex);
- output.assetIssuer = locals.item.asset.issuer;
- output.assetName = locals.item.asset.assetName;
- output.numberOfShares = locals.item.numberOfShares;
- output.returnCode = QRAFFLE_SUCCESS;
- }
-
- struct getActiveAssetRaffleBuyer_locals
- {
- AssetRaffleInfo info;
- uint32 slot;
- };
-
- PUBLIC_FUNCTION_WITH_LOCALS(getActiveAssetRaffleBuyer)
- {
- if (input.indexOfAssetRaffle >= state.get().numberOfActiveAssetRaffles)
- {
- output.returnCode = QRAFFLE_INVALID_ASSET_RAFFLE;
- return;
- }
- locals.info = state.get().activeAssetRaffles.get(input.indexOfAssetRaffle);
- if (input.buyerIndex >= locals.info.numberOfBuyers)
- {
- output.returnCode = QRAFFLE_INVALID_OFFSET_OR_LIMIT;
- return;
- }
- locals.slot = input.indexOfAssetRaffle * QRAFFLE_MAX_ASSET_TICKET_BUYERS + input.buyerIndex;
- output.buyer = state.get().activeAssetRaffleBuyers.get(locals.slot);
- output.ticketCount = state.get().activeAssetRaffleBuyerTickets.get(locals.slot);
- output.returnCode = QRAFFLE_SUCCESS;
- }
-
- struct getEndedAssetRaffle_locals
- {
- EndedAssetRaffleInfo r;
- uint32 slot;
- };
-
- PUBLIC_FUNCTION_WITH_LOCALS(getEndedAssetRaffle)
- {
- if (input.indexOfRaffle >= state.get().numberOfEndedAssetRaffles)
- {
- output.returnCode = QRAFFLE_INVALID_ASSET_RAFFLE;
- return;
- }
- // Reject indices that have been overwritten by the ring buffer.
- if (state.get().numberOfEndedAssetRaffles > QRAFFLE_MAX_ENDED_ASSET_RAFFLES
- && input.indexOfRaffle < state.get().numberOfEndedAssetRaffles - QRAFFLE_MAX_ENDED_ASSET_RAFFLES)
- {
- output.returnCode = QRAFFLE_INVALID_ASSET_RAFFLE;
- return;
- }
- locals.slot = mod(input.indexOfRaffle, QRAFFLE_MAX_ENDED_ASSET_RAFFLES);
- locals.r = state.get().endedAssetRaffles.get(locals.slot);
- output.creator = locals.r.creator;
- output.epochWinner = locals.r.epochWinner;
- output.reservePriceQu = locals.r.reservePriceQu;
- output.entryTicketQu = locals.r.entryTicketQu;
- output.grossPoolQu = locals.r.grossPoolQu;
- output.creatorPaidQu = locals.r.creatorPaidQu;
- output.totalTickets = locals.r.totalTickets;
- output.numberOfBuyers = locals.r.numberOfBuyers;
- output.bundleSize = locals.r.bundleSize;
- output.epoch = locals.r.epoch;
- output.reserveMet = locals.r.reserveMet;
- output.returnCode = QRAFFLE_SUCCESS;
- }
-
- PUBLIC_FUNCTION(getAssetRaffleAnalytics)
- {
- output.totalAssetRaffleProposalFees = state.get().totalAssetRaffleProposalFees;
- output.totalAssetRaffleCreatorPaid = state.get().totalAssetRaffleCreatorPaid;
- output.totalAssetRaffleRefunded = state.get().totalAssetRaffleRefunded;
- output.numberOfActiveAssetRaffles = state.get().numberOfActiveAssetRaffles;
- output.numberOfEndedAssetRaffles = state.get().numberOfEndedAssetRaffles;
- output.totalAssetRafflesCreated = state.get().totalAssetRafflesCreated;
- output.totalAssetRafflesSucceeded = state.get().totalAssetRafflesSucceeded;
- output.totalAssetRafflesFailed = state.get().totalAssetRafflesFailed;
- output.returnCode = QRAFFLE_SUCCESS;
- }
-
- REGISTER_USER_FUNCTIONS_AND_PROCEDURES()
- {
- REGISTER_USER_FUNCTION(getRegisters, 1);
- REGISTER_USER_FUNCTION(getAnalytics, 2);
- REGISTER_USER_FUNCTION(getActiveProposal, 3);
- REGISTER_USER_FUNCTION(getEndedTokenRaffle, 4);
- REGISTER_USER_FUNCTION(getEndedQuRaffle, 5);
- REGISTER_USER_FUNCTION(getActiveTokenRaffle, 6);
- REGISTER_USER_FUNCTION(getEpochRaffleIndexes, 7);
- REGISTER_USER_FUNCTION(getQuRaffleEntryAmountPerUser, 8);
- REGISTER_USER_FUNCTION(getQuRaffleEntryAverageAmount, 9);
- // Asset Raffle view functions
- REGISTER_USER_FUNCTION(getActiveAssetRaffle, 10);
- REGISTER_USER_FUNCTION(getActiveAssetRaffleBundleItem, 11);
- REGISTER_USER_FUNCTION(getActiveAssetRaffleBuyer, 12);
- REGISTER_USER_FUNCTION(getEndedAssetRaffle, 13);
- REGISTER_USER_FUNCTION(getAssetRaffleAnalytics, 14);
-
- REGISTER_USER_PROCEDURE(registerInSystem, 1);
- REGISTER_USER_PROCEDURE(logoutInSystem, 2);
- REGISTER_USER_PROCEDURE(submitEntryAmount, 3);
- REGISTER_USER_PROCEDURE(submitProposal, 4);
- REGISTER_USER_PROCEDURE(voteInProposal, 5);
- REGISTER_USER_PROCEDURE(depositInQuRaffle, 6);
- REGISTER_USER_PROCEDURE(depositInTokenRaffle, 7);
- REGISTER_USER_PROCEDURE(TransferShareManagementRights, 8);
- // Asset Raffle procedures
- REGISTER_USER_PROCEDURE(createAssetRaffle, 9);
- REGISTER_USER_PROCEDURE(buyAssetRaffleTicket, 10);
- REGISTER_USER_PROCEDURE(cancelAssetRaffle, 11);
- }
-
- INITIALIZE()
- {
- state.mut().qREAmount = QRAFFLE_DEFAULT_QRAFFLE_AMOUNT;
- state.mut().charityAddress = ID(_D, _P, _Q, _R, _L, _S, _Z, _S, _S, _C, _X, _I, _Y, _F, _I, _Q, _G, _B, _F, _B, _X, _X, _I, _S, _D, _D, _E, _B, _E, _G, _Q, _N, _W, _N, _T, _Q, _U, _E, _I, _F, _S, _C, _U, _W, _G, _H, _V, _X, _J, _P, _L, _F, _G, _M, _Y, _D);
- state.mut().initialRegister1 = ID(_I, _L, _N, _J, _X, _V, _H, _A, _U, _X, _D, _G, _G, _B, _T, _T, _U, _O, _I, _T, _O, _Q, _G, _P, _A, _Y, _U, _C, _F, _T, _N, _C, _P, _X, _D, _K, _O, _C, _P, _U, _O, _C, _D, _O, _T, _P, _U, _W, _X, _B, _I, _G, _R, _V, _Q, _D);
- state.mut().initialRegister2 = ID(_L, _S, _D, _A, _A, _C, _L, _X, _X, _G, _I, _P, _G, _G, _L, _S, _O, _C, _L, _M, _V, _A, _Y, _L, _N, _T, _G, _D, _V, _B, _N, _O, _S, _S, _Y, _E, _Q, _D, _R, _K, _X, _D, _Y, _W, _B, _C, _G, _J, _I, _K, _C, _M, _Z, _K, _M, _F);
- state.mut().initialRegister3 = ID(_G, _H, _G, _R, _L, _W, _S, _X, _Z, _X, _W, _D, _A, _A, _O, _M, _T, _X, _Q, _Y, _U, _P, _R, _L, _P, _N, _K, _C, _W, _G, _H, _A, _E, _F, _I, _R, _J, _I, _Z, _A, _K, _C, _A, _U, _D, _G, _N, _M, _C, _D, _E, _Q, _R, _O, _Q, _B);
- state.mut().initialRegister4 = ID(_E, _U, _O, _N, _A, _Z, _J, _U, _A, _G, _V, _D, _C, _E, _I, _B, _A, _H, _J, _E, _T, _G, _U, _U, _H, _M, _N, _D, _J, _C, _S, _E, _T, _T, _Q, _V, _G, _Y, _F, _H, _M, _D, _P, _X, _T, _A, _L, _D, _Y, _U, _V, _E, _P, _F, _C, _A);
- state.mut().initialRegister5 = ID(_S, _L, _C, _J, _C, _C, _U, _X, _G, _K, _N, _V, _A, _D, _F, _B, _E, _A, _Y, _V, _L, _S, _O, _B, _Z, _P, _A, _B, _H, _K, _S, _G, _M, _H, _W, _H, _S, _H, _G, _G, _B, _A, _P, _J, _W, _F, _V, _O, _K, _Z, _J, _P, _F, _L, _X, _D);
- state.mut().QXMRIssuer = ID(_Q, _X, _M, _R, _T, _K, _A, _I, _I, _G, _L, _U, _R, _E, _P, _I, _Q, _P, _C, _M, _H, _C, _K, _W, _S, _I, _P, _D, _T, _U, _Y, _F, _C, _F, _N, _Y, _X, _Q, _L, _T, _E, _C, _S, _U, _J, _V, _Y, _E, _M, _M, _D, _E, _L, _B, _M, _D);
- state.mut().feeAddress = ID(_H, _H, _R, _L, _C, _Z, _Q, _V, _G, _O, _M, _G, _X, _G, _F, _P, _H, _T, _R, _H, _H, _D, _W, _A, _E, _U, _X, _C, _N, _D, _L, _Z, _S, _Z, _J, _R, _M, _O, _R, _J, _K, _A, _I, _W, _S, _U, _Y, _R, _N, _X, _I, _H, _H, _O, _W, _D);
-
- state.mut().registers.set(state.get().initialRegister1, 0);
- state.mut().registers.set(state.get().initialRegister2, 0);
- state.mut().registers.set(state.get().initialRegister3, 0);
- state.mut().registers.set(state.get().initialRegister4, 0);
- state.mut().registers.set(state.get().initialRegister5, 0);
- state.mut().numberOfRegisters = 5;
- }
-
- struct END_EPOCH_locals
- {
- ProposalInfo proposal;
- QuRaffleInfo qraffle;
- TokenRaffleInfo tRaffle;
- ActiveTokenRaffleInfo acTokenRaffle;
- AssetPossessionIterator iter;
- Asset QraffleAsset;
- id digest, computerDigest, winner, shareholder, baseSeed, raffleSeed;
- sint64 idx;
- sint64 sharesHeld;
- sint64 perShare;
- sint64 transferResult;
- uint64 sumOfEntryAmountSubmitted, r, winnerRevenue, burnAmount, charityRevenue, shareholderRevenue, registerRevenue, fee, oneShareholderRev;
- uint64 tokenPool;
- uint64 shareholderPerShareUnit;
- uint64 registerPerShareUnit;
- uint64 actualShareholderTotal;
- uint64 actualRegisterTotal;
- uint64 qxmrPerShare;
- uint64 qxmrDistributedTotal;
- uint64 qxmrContractBalance;
- uint32 i, j, winnerIndex;
- Logger log;
- EmptyTokenRaffleLogger emptyTokenRafflelog;
- EndEpochLogger endEpochLog;
- RevenueLogger revenueLog;
- TokenRaffleLogger tokenRaffleLog;
- ProposalLogger proposalLog;
- // Asset raffle settlement locals
- AssetRaffleInfo arInfo;
- AssetRaffleItem arItem;
- EndedAssetRaffleInfo arEnded;
- AssetRaffleEndedLogger arLog;
- uint64 arGross;
- uint64 arCreatorPay;
- uint64 arBurn;
- uint64 arCharity;
- uint64 arShareholderRev;
- uint64 arRegisterRev;
- uint64 arFee;
- uint64 arShareholderPerShare;
- uint64 arRegisterPerShare;
- uint64 arRegisterPerShareActual;
- uint64 arRegisterBucket; // accumulated register share across all successful asset raffles
- uint64 arRegisterBucketPerReg; // per-register amount distributed after the settlement loop
- uint64 arDaoBucketPerRegister;
- uint64 arTicketAcc;
- uint64 arRefund; // per-buyer refund amount (used in reserve-missed path)
- uint32 arI;
- uint32 arJ;
- uint32 arBuyerSlot;
- uint32 arWinnerIndex;
- uint32 arEndedIdx; // ring-buffer slot (masked) the settled raffle is written to
- uint32 arEndedGlobalIdx; // monotonic global index callers pass to getEndedAssetRaffle
- bit arReserveMet;
- };
-
- END_EPOCH_WITH_LOCALS()
- {
- // Distribute logout-fee revenue to shareholders.
- locals.oneShareholderRev = div(state.get().epochRevenue, NUMBER_OF_COMPUTORS);
- if (locals.oneShareholderRev > 0)
- {
- qpi.distributeDividends(locals.oneShareholderRev);
- state.mut().epochRevenue -= locals.oneShareholderRev * NUMBER_OF_COMPUTORS;
- }
-
- // RNG seed: XOR of prevSpectrumDigest and prevComputerDigest, hashed with K12.
- // Tick-level inputs are excluded so a computor cannot grind the seed.
- locals.digest = qpi.getPrevSpectrumDigest();
- locals.computerDigest = qpi.getPrevComputerDigest();
- locals.baseSeed = qpi.K12(m256i(
- locals.digest.u64._0 ^ locals.computerDigest.u64._0,
- locals.digest.u64._1 ^ locals.computerDigest.u64._1,
- locals.digest.u64._2 ^ locals.computerDigest.u64._2,
- locals.digest.u64._3 ^ locals.computerDigest.u64._3));
-
- // Asset descriptor reused by the QXMR distribution and per-token-raffle shareholder
- // payout loops below; both iterate QRAFFLE_ASSET possessors directly via locals.iter.
- locals.QraffleAsset.assetName = QRAFFLE_ASSET_NAME;
- locals.QraffleAsset.issuer = NULL_ID;
-
- if (state.get().numberOfQuRaffleMembers > 0)
- {
- // Pick winner.
- locals.raffleSeed = qpi.K12(m256i(locals.baseSeed.u64._0, locals.baseSeed.u64._1, locals.baseSeed.u64._2, locals.baseSeed.u64._3));
- locals.r = locals.raffleSeed.u64._0;
- locals.winnerIndex = (uint32)mod(locals.r, state.get().numberOfQuRaffleMembers * 1ull);
- locals.winner = state.get().quRaffleMembers.get(locals.winnerIndex);
-
- // Calculate fee distributions.
- locals.tokenPool = state.get().qREAmount * state.get().numberOfQuRaffleMembers;
- locals.burnAmount = div(locals.tokenPool * QRAFFLE_BURN_FEE, 100);
- locals.charityRevenue = div(locals.tokenPool * QRAFFLE_CHARITY_FEE, 100);
- locals.shareholderRevenue = div(locals.tokenPool * QRAFFLE_SHAREHOLDER_FEE, 100);
- locals.registerRevenue = div(locals.tokenPool * QRAFFLE_REGISTER_FEE, 100);
- locals.fee = div(locals.tokenPool * QRAFFLE_FEE, 100);
- // Round down per-share amounts; winner gets the remainder.
- locals.shareholderPerShareUnit = div(locals.shareholderRevenue, NUMBER_OF_COMPUTORS);
- locals.actualShareholderTotal = locals.shareholderPerShareUnit * NUMBER_OF_COMPUTORS;
- locals.registerPerShareUnit = div(locals.registerRevenue, state.get().numberOfRegisters);
- locals.actualRegisterTotal = locals.registerPerShareUnit * state.get().numberOfRegisters;
- locals.winnerRevenue = locals.tokenPool - locals.burnAmount - locals.charityRevenue - locals.actualShareholderTotal - locals.actualRegisterTotal - locals.fee;
-
- locals.revenueLog = RevenueLogger{
- QRAFFLE_CONTRACT_INDEX,
- QRAFFLE_revenueDistributed,
- locals.burnAmount,
- locals.charityRevenue,
- locals.actualShareholderTotal,
- locals.actualRegisterTotal,
- locals.fee,
- locals.winnerRevenue,
- 0
- };
- LOG_INFO(locals.revenueLog);
-
- qpi.transfer(locals.winner, locals.winnerRevenue);
- qpi.burn(locals.burnAmount);
- qpi.transfer(state.get().charityAddress, locals.charityRevenue);
- if (locals.shareholderPerShareUnit > 0)
- {
- qpi.distributeDividends(locals.shareholderPerShareUnit);
- }
- qpi.transfer(state.get().feeAddress, locals.fee);
-
- state.mut().totalBurnAmount += locals.burnAmount;
- state.mut().totalCharityAmount += locals.charityRevenue;
- state.mut().totalShareholderAmount += locals.actualShareholderTotal;
- state.mut().totalRegisterAmount += locals.actualRegisterTotal;
- state.mut().totalFeeAmount += locals.fee;
- state.mut().totalWinnerAmount += locals.winnerRevenue;
- if (locals.winnerRevenue > state.get().largestWinnerAmount)
- {
- state.mut().largestWinnerAmount = locals.winnerRevenue;
- }
-
- if (locals.registerPerShareUnit > 0)
- {
- locals.idx = state.get().registers.nextElementIndex(NULL_INDEX);
- while (locals.idx != NULL_INDEX)
- {
- qpi.transfer(state.get().registers.key(locals.idx), locals.registerPerShareUnit);
- locals.idx = state.get().registers.nextElementIndex(locals.idx);
- }
- }
-
- locals.qraffle.epochWinner = locals.winner;
- locals.qraffle.receivedAmount = locals.winnerRevenue;
- locals.qraffle.entryAmount = state.get().qREAmount;
- locals.qraffle.numberOfMembers = state.get().numberOfQuRaffleMembers;
- locals.qraffle.winnerIndex = locals.winnerIndex;
- state.mut().QuRaffles.set(qpi.epoch(), locals.qraffle);
-
- locals.endEpochLog = EndEpochLogger{
- QRAFFLE_CONTRACT_INDEX,
- QRAFFLE_revenueDistributed,
- qpi.epoch(),
- state.get().numberOfQuRaffleMembers,
- locals.tokenPool,
- locals.winnerRevenue,
- locals.winnerIndex,
- 0
- };
- LOG_INFO(locals.endEpochLog);
- }
- else
- {
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_emptyQuRaffle, 0 };
- LOG_INFO(locals.log);
- }
-
- locals.qxmrPerShare = div(state.get().epochQXMRRevenue, NUMBER_OF_COMPUTORS);
- locals.qxmrDistributedTotal = 0;
- if (locals.qxmrPerShare > 0)
- {
- locals.qxmrContractBalance = (uint64)qpi.numberOfPossessedShares(QRAFFLE_QXMR_ASSET_NAME, state.get().QXMRIssuer, SELF, SELF, SELF_INDEX, SELF_INDEX);
- locals.iter.begin(locals.QraffleAsset);
- while (!locals.iter.reachedEnd())
- {
- locals.sharesHeld = locals.iter.numberOfPossessedShares();
- if (locals.sharesHeld > 0)
- {
- locals.shareholder = locals.iter.possessor();
- locals.perShare = (sint64)(locals.qxmrPerShare * (uint64)locals.sharesHeld);
- if ((uint64)locals.perShare <= locals.qxmrContractBalance - locals.qxmrDistributedTotal)
- {
- locals.transferResult = qpi.transferShareOwnershipAndPossession(QRAFFLE_QXMR_ASSET_NAME, state.get().QXMRIssuer, SELF, SELF, locals.perShare, locals.shareholder);
- if (locals.transferResult >= 0)
- {
- locals.qxmrDistributedTotal += (uint64)locals.perShare;
- }
- }
- }
- locals.iter.next();
- }
- }
- state.mut().epochQXMRRevenue -= locals.qxmrDistributedTotal;
-
- // Process each active token raffle.
- for (locals.i = 0 ; locals.i < state.get().numberOfActiveTokenRaffle; locals.i++)
- {
- if (state.get().numberOfTokenRaffleMembers.get(locals.i) > 0)
- {
- locals.raffleSeed = qpi.K12(m256i(locals.baseSeed.u64._0, locals.baseSeed.u64._1, locals.baseSeed.u64._2, locals.baseSeed.u64._3 ^ ((uint64)locals.i + 1ULL)));
- locals.r = locals.raffleSeed.u64._0;
- locals.winnerIndex = (uint32)mod(locals.r, state.get().numberOfTokenRaffleMembers.get(locals.i) * 1ull);
- locals.winner = state.get().tokenRaffleMemberSlots.get(locals.i * QRAFFLE_TOKEN_RAFFLE_SLOT_SIZE + locals.winnerIndex);
-
- locals.acTokenRaffle = state.get().activeTokenRaffle.get(locals.i);
-
- locals.tokenPool = locals.acTokenRaffle.entryAmount * state.get().numberOfTokenRaffleMembers.get(locals.i);
- locals.burnAmount = div(locals.tokenPool * QRAFFLE_BURN_FEE, 100);
- locals.charityRevenue = div(locals.tokenPool * QRAFFLE_CHARITY_FEE, 100);
- locals.shareholderRevenue = div(locals.tokenPool * QRAFFLE_SHAREHOLDER_FEE, 100);
- locals.registerRevenue = div(locals.tokenPool * QRAFFLE_REGISTER_FEE, 100);
- locals.fee = div(locals.tokenPool * QRAFFLE_FEE, 100);
- // Round down per-share amounts; winner gets the remainder.
- locals.shareholderPerShareUnit = div(locals.shareholderRevenue, NUMBER_OF_COMPUTORS);
- locals.actualShareholderTotal = locals.shareholderPerShareUnit * NUMBER_OF_COMPUTORS;
- locals.registerPerShareUnit = div(locals.registerRevenue, state.get().numberOfRegisters);
- locals.actualRegisterTotal = locals.registerPerShareUnit * state.get().numberOfRegisters;
- locals.winnerRevenue = locals.tokenPool - locals.burnAmount - locals.charityRevenue - locals.actualShareholderTotal - locals.actualRegisterTotal - locals.fee;
-
- // Send winner share. Skip the whole raffle if this fails to prevent partial distribution.
- locals.transferResult = qpi.transferShareOwnershipAndPossession(locals.acTokenRaffle.token.assetName, locals.acTokenRaffle.token.issuer, SELF, SELF, locals.winnerRevenue, locals.winner);
- if (locals.transferResult < 0)
- {
- // Winner transfer failed — skip raffle, leave funds for next epoch.
- locals.emptyTokenRafflelog = EmptyTokenRaffleLogger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_transferFailed, locals.i, 0 };
- LOG_INFO(locals.emptyTokenRafflelog);
- state.mut().numberOfTokenRaffleMembers.set(locals.i, 0);
- continue;
- }
-
- // Burn shares (NULL_ID); fall back to charity if burn is rejected.
- if (locals.burnAmount > 0)
- {
- locals.transferResult = qpi.transferShareOwnershipAndPossession(locals.acTokenRaffle.token.assetName, locals.acTokenRaffle.token.issuer, SELF, SELF, locals.burnAmount, NULL_ID);
- if (locals.transferResult < 0)
- {
- qpi.transferShareOwnershipAndPossession(locals.acTokenRaffle.token.assetName, locals.acTokenRaffle.token.issuer, SELF, SELF, locals.burnAmount, state.get().charityAddress);
- }
- }
- if (locals.charityRevenue > 0)
- {
- qpi.transferShareOwnershipAndPossession(locals.acTokenRaffle.token.assetName, locals.acTokenRaffle.token.issuer, SELF, SELF, locals.charityRevenue, state.get().charityAddress);
- }
- if (locals.fee > 0)
- {
- qpi.transferShareOwnershipAndPossession(locals.acTokenRaffle.token.assetName, locals.acTokenRaffle.token.issuer, SELF, SELF, locals.fee, state.get().feeAddress);
- }
-
- // Pay shareholders proportional to possessed shares.
- if (locals.shareholderPerShareUnit > 0)
- {
- locals.iter.begin(locals.QraffleAsset);
- while (!locals.iter.reachedEnd())
- {
- locals.sharesHeld = locals.iter.numberOfPossessedShares();
- if (locals.sharesHeld > 0)
- {
- qpi.transferShareOwnershipAndPossession(locals.acTokenRaffle.token.assetName, locals.acTokenRaffle.token.issuer, SELF, SELF, (sint64)(locals.shareholderPerShareUnit * (uint64)locals.sharesHeld), locals.iter.possessor());
- }
- locals.iter.next();
- }
- }
-
- if (locals.registerPerShareUnit > 0)
- {
- locals.idx = state.get().registers.nextElementIndex(NULL_INDEX);
- while (locals.idx != NULL_INDEX)
- {
- qpi.transferShareOwnershipAndPossession(locals.acTokenRaffle.token.assetName, locals.acTokenRaffle.token.issuer, SELF, SELF, (sint64)locals.registerPerShareUnit, state.get().registers.key(locals.idx));
- locals.idx = state.get().registers.nextElementIndex(locals.idx);
- }
- }
-
- locals.tRaffle.epochWinner = locals.winner;
- locals.tRaffle.token.assetName = locals.acTokenRaffle.token.assetName;
- locals.tRaffle.token.issuer = locals.acTokenRaffle.token.issuer;
- locals.tRaffle.entryAmount = locals.acTokenRaffle.entryAmount;
- locals.tRaffle.numberOfMembers = state.get().numberOfTokenRaffleMembers.get(locals.i);
- locals.tRaffle.winnerIndex = locals.winnerIndex;
- locals.tRaffle.epoch = qpi.epoch();
- state.mut().tokenRaffle.set(state.get().numberOfEndedTokenRaffle, locals.tRaffle);
-
- locals.tokenRaffleLog = TokenRaffleLogger{
- QRAFFLE_CONTRACT_INDEX,
- QRAFFLE_tokenRaffleEnded,
- state.mut().numberOfEndedTokenRaffle++,
- locals.acTokenRaffle.token.assetName,
- state.get().numberOfTokenRaffleMembers.get(locals.i),
- locals.acTokenRaffle.entryAmount,
- locals.winnerIndex,
- locals.winnerRevenue,
- 0
- };
- LOG_INFO(locals.tokenRaffleLog);
-
- state.mut().numberOfTokenRaffleMembers.set(locals.i, 0);
- }
- else
- {
- locals.emptyTokenRafflelog = EmptyTokenRaffleLogger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_emptyTokenRaffle, locals.i, 0 };
- LOG_INFO(locals.emptyTokenRafflelog);
- }
- }
-
- // ── Asset Raffle settlement ────────────────────────────────────────────
- locals.arRegisterBucket = 0;
- for (locals.arI = 0; locals.arI < state.get().numberOfActiveAssetRaffles; locals.arI++)
- {
- locals.arInfo = state.get().activeAssetRaffles.get(locals.arI);
- locals.arGross = locals.arInfo.totalTicketsPaidQu;
-
- // Reserve test: gross * 80 >= reservePriceQu * 100
- locals.arReserveMet = (locals.arInfo.totalTickets > 0)
- && (locals.arGross * 80ull >= locals.arInfo.reservePriceQu * 100ull);
-
- if (locals.arReserveMet)
- {
- // Weighted winner selection by ticket count.
- locals.raffleSeed = qpi.K12(m256i(
- locals.baseSeed.u64._0, locals.baseSeed.u64._1,
- locals.baseSeed.u64._2,
- locals.baseSeed.u64._3 ^ (0xA55E7000ULL + (uint64)locals.arI)));
- locals.r = locals.raffleSeed.u64._0;
- locals.r = mod(locals.r, (uint64)locals.arInfo.totalTickets);
- locals.arTicketAcc = 0;
- locals.arWinnerIndex = 0;
- locals.winner = NULL_ID;
- for (locals.arJ = 0; locals.arJ < locals.arInfo.numberOfBuyers; locals.arJ++)
- {
- locals.arBuyerSlot = locals.arI * QRAFFLE_MAX_ASSET_TICKET_BUYERS + locals.arJ;
- locals.arTicketAcc += (uint64)state.get().activeAssetRaffleBuyerTickets.get(locals.arBuyerSlot);
- if (locals.r < locals.arTicketAcc)
- {
- locals.arWinnerIndex = locals.arJ;
- locals.winner = state.get().activeAssetRaffleBuyers.get(locals.arBuyerSlot);
- break;
- }
- }
-
- // Transfer each bundle item to the winner. If an item fails, log and continue;
- // we cannot pull assets back from a user's wallet, so the winner keeps whatever
- // was delivered and the remaining escrowed items stay in the contract.
- for (locals.arJ = 0; locals.arJ < locals.arInfo.bundleSize; locals.arJ++)
- {
- locals.arItem = state.get().activeAssetRaffleItems.get(
- locals.arI * QRAFFLE_MAX_ASSETS_PER_BUNDLE + locals.arJ);
- locals.transferResult = qpi.transferShareOwnershipAndPossession(
- locals.arItem.asset.assetName, locals.arItem.asset.issuer,
- SELF, SELF,
- locals.arItem.numberOfShares, locals.winner);
- if (locals.transferResult < 0)
- {
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_assetRaffleBundleDeliveryFailed, 0 };
- LOG_INFO(locals.log);
- }
- }
-
- // Qu pool distribution: 80% to creator, 20% to fee buckets.
- // Always executed when reserve is met, regardless of per-item delivery outcome.
- // (Assets already delivered to winner; we cannot recall them from a user's wallet.)
- locals.arBurn = div(locals.arGross * (uint64)QRAFFLE_BURN_FEE, 100ull);
- locals.arCharity = div(locals.arGross * (uint64)QRAFFLE_CHARITY_FEE, 100ull);
- locals.arShareholderRev = div(locals.arGross * (uint64)QRAFFLE_SHAREHOLDER_FEE, 100ull);
- locals.arRegisterRev = div(locals.arGross * (uint64)QRAFFLE_REGISTER_FEE, 100ull);
- locals.arFee = div(locals.arGross * (uint64)QRAFFLE_FEE, 100ull);
- // Round down per-share amounts; all rounding dust goes to creator.
- locals.arShareholderPerShare = div(locals.arShareholderRev, (uint64)NUMBER_OF_COMPUTORS);
- locals.arRegisterPerShare = (state.get().numberOfRegisters > 0)
- ? div(locals.arRegisterRev, (uint64)state.get().numberOfRegisters)
- : 0;
- locals.arRegisterPerShareActual = locals.arRegisterPerShare * (uint64)state.get().numberOfRegisters;
- // Creator gets gross minus all deductions; rounding dust stays with creator.
- locals.arCreatorPay = locals.arGross
- - locals.arBurn
- - locals.arCharity
- - (locals.arShareholderPerShare * (uint64)NUMBER_OF_COMPUTORS)
- - locals.arRegisterPerShareActual
- - locals.arFee;
-
- qpi.transfer(locals.arInfo.creator, locals.arCreatorPay);
- qpi.burn(locals.arBurn);
- qpi.transfer(state.get().charityAddress, locals.arCharity);
- if (locals.arShareholderPerShare > 0)
- {
- qpi.distributeDividends(locals.arShareholderPerShare);
- }
- qpi.transfer(state.get().feeAddress, locals.arFee);
- // Accumulate register share; distributed in a single pass after the loop.
- locals.arRegisterBucket += locals.arRegisterPerShareActual;
-
- state.mut().totalAssetRaffleCreatorPaid += locals.arCreatorPay;
- state.mut().totalAssetRafflesSucceeded++;
- }
-
- if (!locals.arReserveMet)
- {
- // Reserve not met: refund all Qu to buyers and return bundle to creator.
- for (locals.arJ = 0; locals.arJ < locals.arInfo.numberOfBuyers; locals.arJ++)
- {
- locals.arBuyerSlot = locals.arI * QRAFFLE_MAX_ASSET_TICKET_BUYERS + locals.arJ;
- locals.arRefund = (uint64)state.get().activeAssetRaffleBuyerTickets.get(locals.arBuyerSlot) * locals.arInfo.entryTicketQu;
- qpi.transfer(state.get().activeAssetRaffleBuyers.get(locals.arBuyerSlot), locals.arRefund);
- state.mut().totalAssetRaffleRefunded += locals.arRefund;
- }
- for (locals.arJ = 0; locals.arJ < locals.arInfo.bundleSize; locals.arJ++)
- {
- locals.arItem = state.get().activeAssetRaffleItems.get(
- locals.arI * QRAFFLE_MAX_ASSETS_PER_BUNDLE + locals.arJ);
- qpi.transferShareOwnershipAndPossession(
- locals.arItem.asset.assetName, locals.arItem.asset.issuer,
- SELF, SELF,
- locals.arItem.numberOfShares, locals.arInfo.creator);
- }
- locals.arCreatorPay = 0;
- locals.winner = NULL_ID;
- locals.arWinnerIndex = 0;
- state.mut().totalAssetRafflesFailed++;
- }
-
- // Write to ended ring buffer.
- // arEndedGlobalIdx is the monotonic logical index (pre-increment); this is the
- // value callers pass to getEndedAssetRaffle. arEndedIdx is its ring-masked slot.
- locals.arEndedGlobalIdx = state.get().numberOfEndedAssetRaffles;
- locals.arEndedIdx = mod(locals.arEndedGlobalIdx, QRAFFLE_MAX_ENDED_ASSET_RAFFLES);
- locals.arEnded.creator = locals.arInfo.creator;
- locals.arEnded.epochWinner = locals.winner;
- locals.arEnded.reservePriceQu = locals.arInfo.reservePriceQu;
- locals.arEnded.entryTicketQu = locals.arInfo.entryTicketQu;
- locals.arEnded.grossPoolQu = locals.arGross;
- locals.arEnded.creatorPaidQu = locals.arCreatorPay;
- locals.arEnded.totalTickets = locals.arInfo.totalTickets;
- locals.arEnded.numberOfBuyers = locals.arInfo.numberOfBuyers;
- locals.arEnded.bundleSize = locals.arInfo.bundleSize;
- locals.arEnded.epoch = locals.arInfo.epoch;
- locals.arEnded.reserveMet = locals.arReserveMet ? 1u : 0u;
- state.mut().endedAssetRaffles.set(locals.arEndedIdx, locals.arEnded);
- state.mut().numberOfEndedAssetRaffles++;
-
- locals.arLog = AssetRaffleEndedLogger{
- QRAFFLE_CONTRACT_INDEX,
- locals.arReserveMet ? (uint32)QRAFFLE_assetRaffleSucceeded : (uint32)QRAFFLE_assetRaffleRefunded,
- locals.arEndedGlobalIdx,
- locals.arInfo.creator,
- locals.winner,
- locals.arGross,
- locals.arCreatorPay,
- locals.arReserveMet ? (uint8)1 : (uint8)0,
- 0
- };
- LOG_INFO(locals.arLog);
- }
-
- // Distribute accumulated register share from all successful asset raffles in one O(R) pass.
- // Any integer-division remainder (up to numberOfRegisters-1 Qu) is folded into the DAO
- // bucket below so the dust either pays out this same epoch via the DAO distribution that
- // follows, or carries forward — never silently leaks into untracked contract balance.
- if (locals.arRegisterBucket > 0 && state.get().numberOfRegisters > 0)
- {
- locals.arRegisterBucketPerReg = div(locals.arRegisterBucket, (uint64)state.get().numberOfRegisters);
- if (locals.arRegisterBucketPerReg > 0)
- {
- locals.idx = state.get().registers.nextElementIndex(NULL_INDEX);
- while (locals.idx != NULL_INDEX)
- {
- qpi.transfer(state.get().registers.key(locals.idx), locals.arRegisterBucketPerReg);
- locals.idx = state.get().registers.nextElementIndex(locals.idx);
- }
- }
- state.mut().epochAssetRaffleDaoBucket += locals.arRegisterBucket - locals.arRegisterBucketPerReg * (uint64)state.get().numberOfRegisters;
- }
-
- // Distribute DAO proposal-fee bucket evenly to registers.
- // Subtract only what was actually paid out so the integer-division remainder carries
- // forward to the next epoch instead of being silently dropped into contract balance.
- if (state.get().epochAssetRaffleDaoBucket > 0 && state.get().numberOfRegisters > 0)
- {
- locals.arDaoBucketPerRegister = div(state.get().epochAssetRaffleDaoBucket, (uint64)state.get().numberOfRegisters);
- if (locals.arDaoBucketPerRegister > 0)
- {
- locals.idx = state.get().registers.nextElementIndex(NULL_INDEX);
- while (locals.idx != NULL_INDEX)
- {
- qpi.transfer(state.get().registers.key(locals.idx), locals.arDaoBucketPerRegister);
- locals.idx = state.get().registers.nextElementIndex(locals.idx);
- }
- }
- state.mut().epochAssetRaffleDaoBucket -= locals.arDaoBucketPerRegister * (uint64)state.get().numberOfRegisters;
- }
-
- // Reset asset raffle per-epoch state.
- state.mut().numberOfActiveAssetRaffles = 0;
- state.mut().assetRaffleParticipation.reset();
- state.mut().assetRaffleBuyerSlotIndex.reset();
- state.mut().assetRafflesPerCreator.reset();
-
- // Calculate new qREAmount and log
- locals.log = Logger{ QRAFFLE_CONTRACT_INDEX, QRAFFLE_revenueDistributed, 0 };
- LOG_INFO(locals.log);
-
- locals.sumOfEntryAmountSubmitted = 0;
- locals.idx = state.get().quRaffleEntryAmount.nextElementIndex(NULL_INDEX);
- while (locals.idx != NULL_INDEX)
- {
- locals.sumOfEntryAmountSubmitted += state.get().quRaffleEntryAmount.value(locals.idx);
- locals.idx = state.get().quRaffleEntryAmount.nextElementIndex(locals.idx);
- }
- if (state.get().numberOfEntryAmountSubmitted > 0)
- {
- state.mut().qREAmount = div(locals.sumOfEntryAmountSubmitted, state.get().numberOfEntryAmountSubmitted);
- }
- else
- {
- state.mut().qREAmount = QRAFFLE_DEFAULT_QRAFFLE_AMOUNT;
- }
-
- state.mut().numberOfActiveTokenRaffle = 0;
-
- // Process approved proposals and create new token raffles
- for (locals.i = 0 ; locals.i < state.get().numberOfProposals; locals.i++)
- {
- locals.proposal = state.get().proposals.get(locals.i);
-
- // Log proposal processing with detailed information
- locals.proposalLog = ProposalLogger{
- QRAFFLE_CONTRACT_INDEX,
- QRAFFLE_proposalSubmitted,
- locals.i,
- locals.proposal.proposer,
- locals.proposal.nYes,
- locals.proposal.nNo,
- locals.proposal.token.assetName,
- locals.proposal.entryAmount,
- 0
- };
- LOG_INFO(locals.proposalLog);
-
- if (locals.proposal.nYes > locals.proposal.nNo)
- {
- locals.acTokenRaffle.token.assetName = locals.proposal.token.assetName;
- locals.acTokenRaffle.token.issuer = locals.proposal.token.issuer;
- locals.acTokenRaffle.entryAmount = locals.proposal.entryAmount;
-
- state.mut().activeTokenRaffle.set(state.mut().numberOfActiveTokenRaffle++, locals.acTokenRaffle);
- }
- }
-
- // Record DAO member count for this epoch before resetting per-epoch state.
- state.mut().daoMemberCount.set(qpi.epoch(), state.get().numberOfRegisters);
-
- state.mut().numberOfVotedInProposal.setAll(0);
- state.mut().tokenRaffleParticipation.reset();
- state.mut().proposalsPerProposer.reset();
- state.mut().quRaffleEntryAmount.reset();
- state.mut().voteParticipation.reset();
- state.mut().voteValues.reset();
- state.mut().numberOfEntryAmountSubmitted = 0;
- state.mut().numberOfProposals = 0;
- state.mut().numberOfQuRaffleMembers = 0;
- state.mut().quRaffleMemberSet.reset();
- if (state.get().registers.needsCleanup()) { state.mut().registers.cleanup(); }
- }
-
- MIGRATE()
- {
- copyMemory(state.mut().registers, oldState.registers);
- copyMemory(state.mut().voteParticipation, oldState.voteParticipation);
- copyMemory(state.mut().voteValues, oldState.voteValues);
- copyMemory(state.mut().quRaffleMemberSet, oldState.quRaffleMemberSet);
- copyMemory(state.mut().tokenRaffleParticipation, oldState.tokenRaffleParticipation);
- copyMemory(state.mut().quRaffleEntryAmount, oldState.quRaffleEntryAmount);
- copyMemory(state.mut().proposalsPerProposer, oldState.proposalsPerProposer);
-
- state.mut().proposals = oldState.proposals;
- state.mut().numberOfVotedInProposal = oldState.numberOfVotedInProposal;
- state.mut().quRaffleMembers = oldState.quRaffleMembers;
- state.mut().activeTokenRaffle = oldState.activeTokenRaffle;
- state.mut().tokenRaffleMemberSlots = oldState.tokenRaffleMemberSlots;
- state.mut().numberOfTokenRaffleMembers = oldState.numberOfTokenRaffleMembers;
- state.mut().QuRaffles = oldState.QuRaffles;
- state.mut().tokenRaffle = oldState.tokenRaffle;
- state.mut().daoMemberCount = oldState.daoMemberCount;
-
- state.mut().initialRegister1 = oldState.initialRegister1;
- state.mut().initialRegister2 = oldState.initialRegister2;
- state.mut().initialRegister3 = oldState.initialRegister3;
- state.mut().initialRegister4 = oldState.initialRegister4;
- state.mut().initialRegister5 = oldState.initialRegister5;
- state.mut().charityAddress = oldState.charityAddress;
- state.mut().feeAddress = oldState.feeAddress;
- state.mut().QXMRIssuer = oldState.QXMRIssuer;
- state.mut().epochRevenue = oldState.epochRevenue;
- state.mut().epochQXMRRevenue = oldState.epochQXMRRevenue;
- state.mut().qREAmount = oldState.qREAmount;
- state.mut().totalBurnAmount = oldState.totalBurnAmount;
- state.mut().totalCharityAmount = oldState.totalCharityAmount;
- state.mut().totalShareholderAmount = oldState.totalShareholderAmount;
- state.mut().totalRegisterAmount = oldState.totalRegisterAmount;
- state.mut().totalFeeAmount = oldState.totalFeeAmount;
- state.mut().totalWinnerAmount = oldState.totalWinnerAmount;
- state.mut().largestWinnerAmount = oldState.largestWinnerAmount;
- state.mut().numberOfRegisters = oldState.numberOfRegisters;
- state.mut().numberOfQuRaffleMembers = oldState.numberOfQuRaffleMembers;
- state.mut().numberOfEntryAmountSubmitted = oldState.numberOfEntryAmountSubmitted;
- state.mut().numberOfProposals = oldState.numberOfProposals;
- state.mut().numberOfActiveTokenRaffle = oldState.numberOfActiveTokenRaffle;
- state.mut().numberOfEndedTokenRaffle = oldState.numberOfEndedTokenRaffle;
- }
-
- PRE_ACQUIRE_SHARES()
- {
- // Accept all incoming share management transfers for free.
- // Service fees are collected in user procedures (depositInTokenRaffle, TransferShareManagementRights).
- output.requestedFee = 0;
- output.allowTransfer = true;
- }
-
- POST_ACQUIRE_SHARES()
- {
- // Credit any received fee to epochRevenue.
- if (input.receivedFee > 0)
- {
- state.mut().epochRevenue += (uint64)input.receivedFee;
- }
- }
-};
diff --git a/src/contracts/Qswap_old.h b/src/contracts/Qswap_old.h
deleted file mode 100644
index ecf63457e..000000000
--- a/src/contracts/Qswap_old.h
+++ /dev/null
@@ -1,2436 +0,0 @@
-using namespace QPI;
-
-// Log types enum for QSWAP contract
-enum QSWAPLogInfo {
- QSWAPAddLiquidity = 4,
- QSWAPRemoveLiquidity = 5,
- QSWAPSwapExactQuForAsset = 6,
- QSWAPSwapQuForExactAsset = 7,
- QSWAPSwapExactAssetForQu = 8,
- QSWAPSwapAssetForExactQu = 9,
- QSWAPFailedDistribution = 10,
-};
-
-// FIXED CONSTANTS
-constexpr uint64 QSWAP_INITIAL_MAX_POOL = 16384;
-constexpr uint64 QSWAP_MAX_POOL = QSWAP_INITIAL_MAX_POOL * X_MULTIPLIER;
-constexpr uint64 QSWAP_MAX_USER_PER_POOL = 256;
-constexpr sint64 QSWAP_MIN_LIQUIDITY = 1000;
-constexpr uint32 QSWAP_SWAP_FEE_BASE = 10000;
-constexpr uint32 QSWAP_FEE_BASE_100 = 100;
-
-struct QSWAP2
-{
-};
-
-struct QSWAP : public ContractBase
-{
-public:
- // Logging message structures
- struct AddLiquidityMessage
- {
- uint32 _contractIndex;
- uint32 _type;
- id assetIssuer;
- uint64 assetName;
- sint64 userIncreaseLiquidity;
- sint64 quAmount;
- sint64 assetAmount;
- sint8 _terminator;
- };
-
- struct RemoveLiquidityMessage
- {
- uint32 _contractIndex;
- uint32 _type;
- sint64 quAmount;
- sint64 assetAmount;
- sint8 _terminator;
- };
-
- struct SwapMessage
- {
- uint32 _contractIndex;
- uint32 _type;
- id assetIssuer;
- uint64 assetName;
- sint64 assetAmountIn;
- sint64 assetAmountOut;
- sint8 _terminator;
- };
-
- struct FailedDistributionMessage
- {
- uint32 _contractIndex;
- uint32 _type;
- id dst;
- uint64 amount;
- sint8 _terminator;
- };
-
- // Types used by state fields
- struct PoolBasicState
- {
- id poolID;
- sint64 reservedQuAmount;
- sint64 reservedAssetAmount;
- sint64 totalLiquidity;
- };
-
- struct LiquidityInfo
- {
- id entity;
- sint64 liquidity;
- };
-
- struct StateData
- {
- uint32 swapFeeRate; // e.g. 30: 0.3% (base: 10_000)
- uint32 investRewardsFeeRate;// 3: 3% of swap fees to Invest & Rewards (base: 100)
- uint32 shareholderFeeRate; // 27: 27% of swap fees to SC shareholders (base: 100)
- uint32 poolCreationFeeRate; // e.g. 10: 10% (base: 100)
-
- id investRewardsId;
- uint64 investRewardsEarnedFee;
- uint64 investRewardsDistributedAmount;
-
- uint64 shareholderEarnedFee;
- uint64 shareholderDistributedAmount;
-
- Array mPoolBasicStates;
- Collection mLiquidities;
-
- uint32 qxFeeRate; // 5: 5% of swap fees to QX (base: 100)
- uint32 burnFeeRate; // 1: 1% of swap fees burned (base: 100)
-
- uint64 qxEarnedFee;
- uint64 qxDistributedAmount;
-
- uint64 burnEarnedFee; // Total burn fees collected (to be burned in END_TICK)
- uint64 burnedAmount; // Total amount actually burned
-
- uint32 cachedIssuanceFee;
- uint32 cachedTransferFee;
- };
-
- struct Fees_input
- {
- };
- struct Fees_output
- {
- uint32 assetIssuanceFee; // Amount of qus
- uint32 poolCreationFee; // Amount of qus
- uint32 transferFee; // Amount of qus
-
- uint32 swapFee; // 30 -> 0.3%
- uint32 shareholderFee; // 27 -> 27% of swap fee, for SC shareholders
- uint32 investRewardsFee; // 3 -> 3% of swap fee, for Invest & Rewards
- uint32 qxFee; // 5 -> 5% of swap fee, for QX
- uint32 burnFee; // 1 -> 1% of swap fee, burned
- };
-
- struct InvestRewardsInfo_input
- {
- };
- struct InvestRewardsInfo_output
- {
- uint32 investRewardsFee; // 3 -> 3% of swap fee
- id investRewardsId;
- };
-
- struct SetInvestRewardsInfo_input
- {
- id newInvestRewardsId;
- };
- struct SetInvestRewardsInfo_output
- {
- bit success;
- };
-
- struct GetPoolBasicState_input
- {
- id assetIssuer;
- uint64 assetName;
- };
- struct GetPoolBasicState_output
- {
- sint64 poolExists;
- sint64 reservedQuAmount;
- sint64 reservedAssetAmount;
- sint64 totalLiquidity;
- };
-
- struct GetLiquidityOf_input
- {
- id assetIssuer;
- uint64 assetName;
- id account;
- };
- struct GetLiquidityOf_output
- {
- sint64 liquidity;
- };
-
- struct QuoteExactQuInput_input
- {
- id assetIssuer;
- uint64 assetName;
- sint64 quAmountIn;
- };
- struct QuoteExactQuInput_output
- {
- sint64 assetAmountOut;
- };
-
- struct QuoteExactQuOutput_input{
- id assetIssuer;
- uint64 assetName;
- sint64 quAmountOut;
- };
- struct QuoteExactQuOutput_output
- {
- sint64 assetAmountIn;
- };
-
- struct QuoteExactAssetInput_input
- {
- id assetIssuer;
- uint64 assetName;
- sint64 assetAmountIn;
- };
- struct QuoteExactAssetInput_output
- {
- sint64 quAmountOut;
- };
-
- struct QuoteExactAssetOutput_input
- {
- id assetIssuer;
- uint64 assetName;
- sint64 assetAmountOut;
- };
- struct QuoteExactAssetOutput_output
- {
- sint64 quAmountIn;
- };
-
- struct IssueAsset_input
- {
- uint64 assetName;
- sint64 numberOfShares;
- uint64 unitOfMeasurement;
- sint8 numberOfDecimalPlaces;
- };
- struct IssueAsset_output
- {
- sint64 issuedNumberOfShares;
- };
-
- struct CreatePool_input
- {
- id assetIssuer;
- uint64 assetName;
- };
- struct CreatePool_output
- {
- bit success;
- };
-
- struct TransferShareOwnershipAndPossession_input
- {
- id assetIssuer;
- uint64 assetName;
- id newOwnerAndPossessor;
- sint64 amount;
- };
- struct TransferShareOwnershipAndPossession_output
- {
- sint64 transferredAmount;
- };
-
- /**
- * @param quAmountADesired The amount of tokenA to add as liquidity if the B/A price is <= amountBDesired/amountADesired (A depreciates).
- * @param assetAmountBDesired The amount of tokenB to add as liquidity if the A/B price is <= amountADesired/amountBDesired (B depreciates).
- * @param quAmountMin Bounds the extent to which the B/A price can go up before the transaction reverts. Must be <= amountADesired.
- * @param assetAmountMin Bounds the extent to which the A/B price can go up before the transaction reverts. Must be <= amountBDesired.
- */
- struct AddLiquidity_input
- {
- id assetIssuer;
- uint64 assetName;
- sint64 assetAmountDesired;
- sint64 quAmountMin;
- sint64 assetAmountMin;
- };
- struct AddLiquidity_output
- {
- sint64 userIncreaseLiquidity;
- sint64 quAmount;
- sint64 assetAmount;
- };
-
- struct RemoveLiquidity_input
- {
- id assetIssuer;
- uint64 assetName;
- sint64 burnLiquidity;
- sint64 quAmountMin;
- sint64 assetAmountMin;
- };
-
- struct RemoveLiquidity_output
- {
- sint64 quAmount;
- sint64 assetAmount;
- };
-
- struct SwapExactQuForAsset_input
- {
- id assetIssuer;
- uint64 assetName;
- sint64 assetAmountOutMin;
- };
- struct SwapExactQuForAsset_output
- {
- sint64 assetAmountOut;
- };
-
- struct SwapQuForExactAsset_input
- {
- id assetIssuer;
- uint64 assetName;
- sint64 assetAmountOut;
- };
- struct SwapQuForExactAsset_output
- {
- sint64 quAmountIn;
- };
-
- struct SwapExactAssetForQu_input
- {
- id assetIssuer;
- uint64 assetName;
- sint64 assetAmountIn;
- sint64 quAmountOutMin;
- };
- struct SwapExactAssetForQu_output
- {
- sint64 quAmountOut;
- };
-
- struct SwapAssetForExactQu_input
- {
- id assetIssuer;
- uint64 assetName;
- sint64 assetAmountInMax;
- sint64 quAmountOut;
- };
- struct SwapAssetForExactQu_output
- {
- sint64 assetAmountIn;
- };
-
- struct TransferShareManagementRights_input
- {
- Asset asset;
- sint64 numberOfShares;
- uint32 newManagingContractIndex;
- };
- struct TransferShareManagementRights_output
- {
- sint64 transferredNumberOfShares;
- };
-
-protected:
-
-
- inline static sint64 min(sint64 a, sint64 b)
- {
- return (a < b) ? a : b;
- }
-
- // find the sqrt of a*b
- inline static sint64 sqrt(sint64& a, sint64& b, uint128& prod, uint128& y, uint128& z)
- {
- if (a == b)
- {
- return a;
- }
-
- prod = uint128(a) * uint128(b);
-
- y = uint128(0);
-
- z = uint128(1) << uint128(0, 126);
- while (z > prod)
- {
- z >>= uint128(0, 2);
- }
-
- while (z)
- {
- if (prod >= y + z)
- {
- prod -= y + z;
- y = (y >> uint128(0, 1)) + z;
- }
- else
- {
- y >>= uint128(0, 1);
- }
- z >>= uint128(0, 2);
- }
-
- return sint64(y.low);
- }
-
- inline static sint64 quoteEquivalentAmountB(sint64& amountADesired, sint64& reserveA, sint64& reserveB, uint128& tmpRes)
- {
- // amountDesired * reserveB / reserveA
- tmpRes = div(uint128(amountADesired) * uint128(reserveB), uint128(reserveA));
-
- if ((tmpRes.high != 0)|| (tmpRes.low > 0x7FFFFFFFFFFFFFFF))
- {
- return -1;
- }
- else
- {
- return sint64(tmpRes.low);
- }
- }
-
- // reserveIn * reserveOut = (reserveIn + amountIn * (1-fee)) * (reserveOut - x)
- // x = reserveOut * amountIn * (1-fee) / (reserveIn + amountIn * (1-fee))
- inline static sint64 getAmountOutTakeFeeFromInToken(
- sint64& amountIn,
- sint64& reserveIn,
- sint64& reserveOut,
- uint32 fee,
- uint128& amountInWithFee,
- uint128& numerator,
- uint128& denominator,
- uint128& tmpRes
- )
- {
- if (amountIn >= MAX_AMOUNT) return -1;
-
- amountInWithFee = uint128(amountIn) * uint128(QSWAP_SWAP_FEE_BASE - fee);
- numerator = uint128(reserveOut) * amountInWithFee;
- denominator = uint128(reserveIn) * uint128(QSWAP_SWAP_FEE_BASE) + amountInWithFee;
-
- // numerator / denominator
- tmpRes = div(numerator, denominator);
- if ((tmpRes.high != 0) || (tmpRes.low > 0x7FFFFFFFFFFFFFFF))
- {
- return -1;
- }
- else
- {
- return sint64(tmpRes.low);
- }
- }
-
- // reserveIn * reserveOut = (reserveIn + x * (1-fee)) * (reserveOut - amountOut)
- // x = (reserveIn * amountOut * 10000) / ((reserveOut - amountOut) * (10000 - fee))
- inline static sint64 getAmountInTakeFeeFromInToken(sint64& amountOut, sint64& reserveIn, sint64& reserveOut, uint32 fee, uint128& numerator, uint128& denominator, uint128& tmpRes)
- {
- if (amountOut >= MAX_AMOUNT) return -1;
-
- // Calculate full numerator first to avoid premature truncation
- numerator = uint128(reserveIn) * uint128(amountOut) * uint128(QSWAP_SWAP_FEE_BASE);
- denominator = uint128(reserveOut - amountOut) * uint128(QSWAP_SWAP_FEE_BASE - fee);
-
- // Perform single division at the end
- // Use floor + 1 to ensure user pays at least enough (protects LPs)
- tmpRes = div(numerator, denominator) + uint128(1);
-
- if ((tmpRes.high != 0) || (tmpRes.low > 0x7FFFFFFFFFFFFFFF))
- {
- return -1;
- }
- else
- {
- return sint64(tmpRes.low);
- }
- }
-
- // (reserveIn + amountIn) * (reserveOut - x) = reserveIn * reserveOut
- // x = reserveOut * amountIn / (reserveIn + amountIn)
- // NOTE: Despite the name, this returns the GROSS output (before fee deduction).
- // The fee parameter is unused here because fee is applied separately by the caller.
- // This is intentional: the caller needs the gross value for fee distribution calculation.
- inline static sint64 getAmountOutTakeFeeFromOutToken(sint64& amountIn, sint64& reserveIn, sint64& reserveOut, uint32 fee, uint128& numerator, uint128& denominator, uint128& tmpRes)
- {
- if (amountIn >= MAX_AMOUNT) return -1;
-
- numerator = uint128(reserveOut) * uint128(amountIn);
- denominator = uint128(reserveIn + amountIn);
-
- tmpRes = div(numerator, denominator);
- if ((tmpRes.high != 0)|| (tmpRes.low > 0x7FFFFFFFFFFFFFFF))
- {
- return -1;
- }
- else
- {
- return sint64(tmpRes.low);
- }
- }
-
- // (reserveIn + x) * (reserveOut - amountOut/(1 - fee)) = reserveIn * reserveOut
- // x = (reserveIn * amountOut * 10000) / (reserveOut * (10000-fee) - amountOut * 10000)
- inline static sint64 getAmountInTakeFeeFromOutToken(sint64& amountOut, sint64& reserveIn, sint64& reserveOut, uint32 fee, uint128& numerator, uint128& denominator, uint128& tmpRes)
- {
- if (amountOut >= MAX_AMOUNT) return -1;
-
- // Calculate full numerator to avoid premature truncation
- numerator = uint128(reserveIn) * uint128(amountOut) * uint128(QSWAP_SWAP_FEE_BASE);
-
- // Check: reserveOut * (1-fee) must be greater than amountOut
- // Scale reserveOut by (10000-fee) and amountOut by 10000 for comparison
- // Use tmpRes and denominator temporarily for the comparison
- tmpRes = uint128(reserveOut) * uint128(QSWAP_SWAP_FEE_BASE - fee);
- denominator = uint128(amountOut) * uint128(QSWAP_SWAP_FEE_BASE);
-
- if (tmpRes <= denominator)
- {
- return -1;
- }
-
- denominator = tmpRes - denominator;
-
- // Use floor + 1 to ensure user pays at least enough (protects LPs)
- tmpRes = div(numerator, denominator) + uint128(1);
-
- if ((tmpRes.high != 0) || (tmpRes.low > 0x7FFFFFFFFFFFFFFF))
- {
- return -1;
- }
- else
- {
- return sint64(tmpRes.low);
- }
- }
-
- PUBLIC_FUNCTION(Fees)
- {
- output.assetIssuanceFee = state.get().cachedIssuanceFee;
- output.poolCreationFee = uint32(div(uint64(state.get().cachedIssuanceFee) * uint64(state.get().poolCreationFeeRate), uint64(QSWAP_FEE_BASE_100)));
- output.transferFee = state.get().cachedTransferFee;
- output.swapFee = state.get().swapFeeRate;
- output.shareholderFee = state.get().shareholderFeeRate;
- output.investRewardsFee = state.get().investRewardsFeeRate;
- output.qxFee = state.get().qxFeeRate;
- output.burnFee = state.get().burnFeeRate;
- }
-
- struct GetPoolBasicState_locals
- {
- id poolID;
- sint64 poolSlot;
- PoolBasicState poolBasicState;
- uint32 i0;
- };
-
- PUBLIC_FUNCTION_WITH_LOCALS(GetPoolBasicState)
- {
- output.poolExists = 0;
- output.totalLiquidity = -1;
- output.reservedAssetAmount = -1;
- output.reservedQuAmount = -1;
-
- // asset not issued
- if (!qpi.isAssetIssued(input.assetIssuer, input.assetName))
- {
- return;
- }
-
- locals.poolID = input.assetIssuer;
- locals.poolID.u64._3 = input.assetName;
-
- locals.poolSlot = NULL_INDEX;
- for (locals.i0 = 0; locals.i0 < QSWAP_MAX_POOL; locals.i0++)
- {
- if (state.get().mPoolBasicStates.get(locals.i0).poolID == locals.poolID)
- {
- locals.poolSlot = locals.i0;
- break;
- }
- }
-
- if (locals.poolSlot == NULL_INDEX)
- {
- return;
- }
-
- output.poolExists = 1;
-
- locals.poolBasicState = state.get().mPoolBasicStates.get(locals.poolSlot);
-
- output.reservedQuAmount = locals.poolBasicState.reservedQuAmount;
- output.reservedAssetAmount = locals.poolBasicState.reservedAssetAmount;
- output.totalLiquidity = locals.poolBasicState.totalLiquidity;
- }
-
- struct GetLiquidityOf_locals
- {
- id poolID;
- sint64 liqElementIndex;
- };
-
- PUBLIC_FUNCTION_WITH_LOCALS(GetLiquidityOf)
- {
- output.liquidity = 0;
-
- locals.poolID = input.assetIssuer;
- locals.poolID.u64._3 = input.assetName;
-
- locals.liqElementIndex = state.get().mLiquidities.headIndex(locals.poolID, 0);
-
- while (locals.liqElementIndex != NULL_INDEX)
- {
- if (state.get().mLiquidities.element(locals.liqElementIndex).entity == input.account)
- {
- output.liquidity = state.get().mLiquidities.element(locals.liqElementIndex).liquidity;
- return;
- }
- locals.liqElementIndex = state.get().mLiquidities.nextElementIndex(locals.liqElementIndex);
- }
- }
-
- struct QuoteExactQuInput_locals
- {
- id poolID;
- sint64 poolSlot;
- PoolBasicState poolBasicState;
-
- uint32 i0;
- uint128 i1, i2, i3, i4;
- };
-
- PUBLIC_FUNCTION_WITH_LOCALS(QuoteExactQuInput)
- {
- output.assetAmountOut = -1;
-
- if (input.quAmountIn <= 0)
- {
- return;
- }
-
- locals.poolID = input.assetIssuer;
- locals.poolID.u64._3 = input.assetName;
-
- locals.poolSlot = -1;
- for (locals.i0 = 0; locals.i0 < QSWAP_MAX_POOL; locals.i0 ++)
- {
- if (state.get().mPoolBasicStates.get(locals.i0).poolID == locals.poolID)
- {
- locals.poolSlot = locals.i0;
- break;
- }
- }
-
- // no available slot for new pool
- if (locals.poolSlot == -1)
- {
- return;
- }
-
- locals.poolBasicState = state.get().mPoolBasicStates.get(locals.poolSlot);
-
- // no liquidity in the pool
- if (locals.poolBasicState.totalLiquidity == 0)
- {
- return;
- }
-
- output.assetAmountOut = getAmountOutTakeFeeFromInToken(
- input.quAmountIn,
- locals.poolBasicState.reservedQuAmount,
- locals.poolBasicState.reservedAssetAmount,
- state.get().swapFeeRate,
- locals.i1,
- locals.i2,
- locals.i3,
- locals.i4
- );
- }
-
- struct QuoteExactQuOutput_locals
- {
- id poolID;
- sint64 poolSlot;
- PoolBasicState poolBasicState;
-
- uint32 i0;
- uint128 i1, i2, i3;
- };
-
- PUBLIC_FUNCTION_WITH_LOCALS(QuoteExactQuOutput)
- {
- output.assetAmountIn = -1;
-
- if (input.quAmountOut <= 0)
- {
- return;
- }
-
- locals.poolID = input.assetIssuer;
- locals.poolID.u64._3 = input.assetName;
-
- locals.poolSlot = -1;
- for (locals.i0 = 0; locals.i0 < QSWAP_MAX_POOL; locals.i0 ++)
- {
- if (state.get().mPoolBasicStates.get(locals.i0).poolID == locals.poolID)
- {
- locals.poolSlot = locals.i0;
- break;
- }
- }
-
- // no available slot for new pool
- if (locals.poolSlot == -1)
- {
- return;
- }
-
- locals.poolBasicState = state.get().mPoolBasicStates.get(locals.poolSlot);
-
- // no liquidity in the pool
- if (locals.poolBasicState.totalLiquidity == 0)
- {
- return;
- }
-
- if (input.quAmountOut >= locals.poolBasicState.reservedQuAmount)
- {
- return;
- }
-
- output.assetAmountIn = getAmountInTakeFeeFromOutToken(
- input.quAmountOut,
- locals.poolBasicState.reservedAssetAmount,
- locals.poolBasicState.reservedQuAmount,
- state.get().swapFeeRate,
- locals.i1,
- locals.i2,
- locals.i3
- );
- }
-
- struct QuoteExactAssetInput_locals
- {
- id poolID;
- sint64 poolSlot;
- PoolBasicState poolBasicState;
- sint64 quAmountOutWithFee;
-
- uint32 i0;
- uint128 i1, i2, i3;
- };
-
- PUBLIC_FUNCTION_WITH_LOCALS(QuoteExactAssetInput)
- {
- output.quAmountOut = -1;
-
- if (input.assetAmountIn <= 0)
- {
- return;
- }
-
- locals.poolID = input.assetIssuer;
- locals.poolID.u64._3 = input.assetName;
-
- locals.poolSlot = -1;
- for (locals.i0 = 0; locals.i0 < QSWAP_MAX_POOL; locals.i0 ++)
- {
- if (state.get().mPoolBasicStates.get(locals.i0).poolID == locals.poolID)
- {
- locals.poolSlot = locals.i0;
- break;
- }
- }
-
- // no available slot for new pool
- if (locals.poolSlot == -1)
- {
- return;
- }
-
- locals.poolBasicState = state.get().mPoolBasicStates.get(locals.poolSlot);
-
- // no liquidity in the pool
- if (locals.poolBasicState.totalLiquidity == 0)
- {
- return;
- }
-
- locals.quAmountOutWithFee = getAmountOutTakeFeeFromOutToken(
- input.assetAmountIn,
- locals.poolBasicState.reservedAssetAmount,
- locals.poolBasicState.reservedQuAmount,
- state.get().swapFeeRate,
- locals.i1,
- locals.i2,
- locals.i3
- );
-
- // above call overflow
- if (locals.quAmountOutWithFee == -1)
- {
- return;
- }
-
- // amount * (1-fee), no overflow risk
- output.quAmountOut = sint64(div(
- uint128(locals.quAmountOutWithFee) * uint128(QSWAP_SWAP_FEE_BASE - state.get().swapFeeRate),
- uint128(QSWAP_SWAP_FEE_BASE)
- ).low);
- }
-
- struct QuoteExactAssetOutput_locals
- {
- id poolID;
- sint64 poolSlot;
- PoolBasicState poolBasicState;
-
- uint32 i0;
- uint128 i1, i2, i3;
- };
-
- PUBLIC_FUNCTION_WITH_LOCALS(QuoteExactAssetOutput)
- {
- output.quAmountIn = -1;
-
- if (input.assetAmountOut <= 0)
- {
- return;
- }
-
- locals.poolID = input.assetIssuer;
- locals.poolID.u64._3 = input.assetName;
-
- locals.poolSlot = -1;
- for (locals.i0 = 0; locals.i0 < QSWAP_MAX_POOL; locals.i0 ++)
- {
- if (state.get().mPoolBasicStates.get(locals.i0).poolID == locals.poolID)
- {
- locals.poolSlot = locals.i0;
- break;
- }
- }
-
- // no available slot for new pool
- if (locals.poolSlot == -1)
- {
- return;
- }
-
- locals.poolBasicState = state.get().mPoolBasicStates.get(locals.poolSlot);
-
- // no liquidity in the pool
- if (locals.poolBasicState.totalLiquidity == 0)
- {
- return;
- }
-
- if (input.assetAmountOut >= locals.poolBasicState.reservedAssetAmount)
- {
- return;
- }
-
- output.quAmountIn = getAmountInTakeFeeFromInToken(
- input.assetAmountOut,
- locals.poolBasicState.reservedQuAmount,
- locals.poolBasicState.reservedAssetAmount,
- state.get().swapFeeRate,
- locals.i1,
- locals.i2,
- locals.i3
- );
- }
-
- PUBLIC_FUNCTION(InvestRewardsInfo)
- {
- output.investRewardsFee = state.get().investRewardsFeeRate;
- output.investRewardsId = state.get().investRewardsId;
- }
-
-//
-// procedure
-//
- PUBLIC_PROCEDURE(IssueAsset)
- {
- output.issuedNumberOfShares = 0;
- if ((qpi.invocationReward() < state.get().cachedIssuanceFee))
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return;
- }
-
- // check the validity of input
- if ((input.numberOfShares <= 0) || (input.numberOfDecimalPlaces < 0))
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return;
- }
-
- // asset already issued
- if (qpi.isAssetIssued(qpi.invocator(), input.assetName))
- {
- if (qpi.invocationReward() > 0 )
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return;
- }
-
- output.issuedNumberOfShares = qpi.issueAsset(
- input.assetName,
- qpi.invocator(),
- input.numberOfDecimalPlaces,
- input.numberOfShares,
- input.unitOfMeasurement
- );
-
- if (output.issuedNumberOfShares == 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
- else
- {
- if (qpi.invocationReward() > state.get().cachedIssuanceFee)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - state.get().cachedIssuanceFee);
- }
- state.mut().shareholderEarnedFee += state.get().cachedIssuanceFee;
- }
- }
-
- struct CreatePool_locals
- {
- id poolID;
- sint64 poolSlot;
- PoolBasicState poolBasicState;
- uint32 poolCreationFee;
-
- uint32 i0, i1;
- };
-
- // create uniswap like pool
- // TODO: reject if there is no shares avaliabe shares in current contract, e.g. asset is issue in contract qx
- PUBLIC_PROCEDURE_WITH_LOCALS(CreatePool)
- {
- output.success = false;
-
- locals.poolCreationFee = uint32(div(uint64(state.get().cachedIssuanceFee) * uint64(state.get().poolCreationFeeRate), uint64(QSWAP_FEE_BASE_100)));
-
- // fee check
- if (qpi.invocationReward() < locals.poolCreationFee)
- {
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return;
- }
-
- // asset no exist
- if (!qpi.isAssetIssued(input.assetIssuer, input.assetName))
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- locals.poolID = input.assetIssuer;
- locals.poolID.u64._3 = input.assetName;
-
- // check if pool already exist
- for (locals.i0 = 0; locals.i0 < QSWAP_MAX_POOL ; locals.i0 ++ )
- {
- if (state.get().mPoolBasicStates.get(locals.i0).poolID == locals.poolID)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
- }
-
- // find an vacant pool slot
- locals.poolSlot = -1;
- for (locals.i1 = 0; locals.i1 < QSWAP_MAX_POOL; locals.i1 ++)
- {
- if (state.get().mPoolBasicStates.get(locals.i1).poolID == id(0,0,0,0))
- {
- locals.poolSlot = locals.i1;
- break;
- }
- }
-
- // no available slot for new pool
- if (locals.poolSlot == -1)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- locals.poolBasicState.poolID = locals.poolID;
- locals.poolBasicState.reservedAssetAmount = 0;
- locals.poolBasicState.reservedQuAmount = 0;
- locals.poolBasicState.totalLiquidity = 0;
-
- state.mut().mPoolBasicStates.set(locals.poolSlot, locals.poolBasicState);
-
- if(qpi.invocationReward() > locals.poolCreationFee)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - locals.poolCreationFee );
- }
- state.mut().shareholderEarnedFee += locals.poolCreationFee;
-
- output.success = true;
- }
-
-
- struct AddLiquidity_locals
- {
- AddLiquidityMessage addLiquidityMessage;
- id poolID;
- sint64 poolSlot;
- PoolBasicState poolBasicState;
- LiquidityInfo tmpLiquidity;
-
- sint64 userLiquidityElementIndex;
- sint64 quAmountDesired;
-
- sint64 quTransferAmount;
- sint64 assetTransferAmount;
- sint64 quOptimalAmount;
- sint64 assetOptimalAmount;
- sint64 increaseLiquidity;
- sint64 reservedAssetAmountBefore;
- sint64 reservedAssetAmountAfter;
-
- uint128 tmpIncLiq0;
- uint128 tmpIncLiq1;
-
- uint32 i0;
- uint128 i1, i2, i3;
- };
-
- PUBLIC_PROCEDURE_WITH_LOCALS(AddLiquidity)
- {
- output.userIncreaseLiquidity = 0;
- output.assetAmount = 0;
- output.quAmount = 0;
-
- // add liquidity must stake both qu and asset
- if (qpi.invocationReward() <= 0)
- {
- return;
- }
-
- locals.quAmountDesired = qpi.invocationReward();
-
- // check the vadility of input params
- if ((input.assetAmountDesired <= 0) ||
- (input.quAmountMin < 0) ||
- (input.assetAmountMin < 0))
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- locals.poolID = input.assetIssuer;
- locals.poolID.u64._3 = input.assetName;
-
- // check the pool existance
- locals.poolSlot = -1;
- for (locals.i0 = 0; locals.i0 < QSWAP_MAX_POOL; locals.i0 ++)
- {
- if (state.get().mPoolBasicStates.get(locals.i0).poolID == locals.poolID)
- {
- locals.poolSlot = locals.i0;
- break;
- }
- }
-
- if (locals.poolSlot == -1)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- locals.poolBasicState = state.get().mPoolBasicStates.get(locals.poolSlot);
-
- // check if pool state meet the input condition before desposit
- // and confirm the final qu and asset amount to stake
- if (locals.poolBasicState.totalLiquidity == 0)
- {
- locals.quTransferAmount = locals.quAmountDesired;
- locals.assetTransferAmount = input.assetAmountDesired;
- }
- else
- {
- locals.assetOptimalAmount = quoteEquivalentAmountB(
- locals.quAmountDesired,
- locals.poolBasicState.reservedQuAmount,
- locals.poolBasicState.reservedAssetAmount,
- locals.i1
- );
- // overflow
- if (locals.assetOptimalAmount == -1)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return ;
- }
-
- if (locals.assetOptimalAmount <= input.assetAmountDesired )
- {
- if (locals.assetOptimalAmount < input.assetAmountMin)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return ;
- }
- locals.quTransferAmount = locals.quAmountDesired;
- locals.assetTransferAmount = locals.assetOptimalAmount;
- }
- else
- {
- locals.quOptimalAmount = quoteEquivalentAmountB(
- input.assetAmountDesired,
- locals.poolBasicState.reservedAssetAmount,
- locals.poolBasicState.reservedQuAmount,
- locals.i1
- );
- // overflow
- if (locals.quOptimalAmount == -1)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return ;
- }
- if (locals.quOptimalAmount > locals.quAmountDesired)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return ;
- }
- if (locals.quOptimalAmount < input.quAmountMin)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return ;
- }
- locals.quTransferAmount = locals.quOptimalAmount;
- locals.assetTransferAmount = input.assetAmountDesired;
- }
- }
-
- // check if the qu is enough
- if (qpi.invocationReward() < locals.quTransferAmount)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- // check if the asset is enough
- if (qpi.numberOfPossessedShares(
- input.assetName,
- input.assetIssuer,
- qpi.invocator(),
- qpi.invocator(),
- SELF_INDEX,
- SELF_INDEX
- ) < locals.assetTransferAmount)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- // for pool's initial mint
- if (locals.poolBasicState.totalLiquidity == 0)
- {
- locals.increaseLiquidity = sqrt(locals.quTransferAmount, locals.assetTransferAmount, locals.i1, locals.i2, locals.i3);
-
- if (locals.increaseLiquidity < QSWAP_MIN_LIQUIDITY )
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- locals.reservedAssetAmountBefore = qpi.numberOfPossessedShares(
- input.assetName,
- input.assetIssuer,
- SELF,
- SELF,
- SELF_INDEX,
- SELF_INDEX
- );
- qpi.transferShareOwnershipAndPossession(
- input.assetName,
- input.assetIssuer,
- qpi.invocator(),
- qpi.invocator(),
- locals.assetTransferAmount,
- SELF
- );
- locals.reservedAssetAmountAfter = qpi.numberOfPossessedShares(
- input.assetName,
- input.assetIssuer,
- SELF,
- SELF,
- SELF_INDEX,
- SELF_INDEX
- );
-
- if (locals.reservedAssetAmountAfter - locals.reservedAssetAmountBefore < locals.assetTransferAmount)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- // permanently lock the first MINIMUM_LIQUIDITY tokens
- locals.tmpLiquidity.entity = SELF;
- locals.tmpLiquidity.liquidity = QSWAP_MIN_LIQUIDITY;
- state.mut().mLiquidities.add(locals.poolID, locals.tmpLiquidity, 0);
-
- locals.tmpLiquidity.entity = qpi.invocator();
- locals.tmpLiquidity.liquidity = locals.increaseLiquidity - QSWAP_MIN_LIQUIDITY;
- state.mut().mLiquidities.add(locals.poolID, locals.tmpLiquidity, 0);
-
- output.quAmount = locals.quTransferAmount;
- output.assetAmount = locals.assetTransferAmount;
- output.userIncreaseLiquidity = locals.increaseLiquidity - QSWAP_MIN_LIQUIDITY;
- }
- else
- {
- locals.tmpIncLiq0 = div(
- uint128(locals.quTransferAmount) * uint128(locals.poolBasicState.totalLiquidity),
- uint128(locals.poolBasicState.reservedQuAmount)
- );
- if (locals.tmpIncLiq0.high != 0 || locals.tmpIncLiq0.low > 0x7FFFFFFFFFFFFFFF)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
- locals.tmpIncLiq1 = div(
- uint128(locals.assetTransferAmount) * uint128(locals.poolBasicState.totalLiquidity),
- uint128(locals.poolBasicState.reservedAssetAmount)
- );
- if (locals.tmpIncLiq1.high != 0 || locals.tmpIncLiq1.low > 0x7FFFFFFFFFFFFFFF)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- // increaseLiquity = min(
- // quTransferAmount * totalLiquity / reserveQuAmount,
- // assetTransferAmount * totalLiquity / reserveAssetAmount
- // );
- locals.increaseLiquidity = min(sint64(locals.tmpIncLiq0.low), sint64(locals.tmpIncLiq1.low));
-
- // maybe too little input
- if (locals.increaseLiquidity == 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- // find user liquidity index
- locals.userLiquidityElementIndex = state.get().mLiquidities.headIndex(locals.poolID, 0);
- while (locals.userLiquidityElementIndex != NULL_INDEX)
- {
- if(state.get().mLiquidities.element(locals.userLiquidityElementIndex).entity == qpi.invocator())
- {
- break;
- }
-
- locals.userLiquidityElementIndex = state.get().mLiquidities.nextElementIndex(locals.userLiquidityElementIndex);
- }
-
- // no more space for new liquidity item
- if ((locals.userLiquidityElementIndex == NULL_INDEX) && ( state.get().mLiquidities.population() == state.get().mLiquidities.capacity()))
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- // transfer the asset from invocator to contract
- locals.reservedAssetAmountBefore = qpi.numberOfPossessedShares(
- input.assetName,
- input.assetIssuer,
- SELF,
- SELF,
- SELF_INDEX,
- SELF_INDEX
- );
- qpi.transferShareOwnershipAndPossession(
- input.assetName,
- input.assetIssuer,
- qpi.invocator(),
- qpi.invocator(),
- locals.assetTransferAmount,
- SELF
- );
- locals.reservedAssetAmountAfter = qpi.numberOfPossessedShares(
- input.assetName,
- input.assetIssuer,
- SELF,
- SELF,
- SELF_INDEX,
- SELF_INDEX
- );
-
- // only trust the amount in the contract
- if (locals.reservedAssetAmountAfter - locals.reservedAssetAmountBefore < locals.assetTransferAmount)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- if (locals.userLiquidityElementIndex == NULL_INDEX)
- {
- locals.tmpLiquidity.entity = qpi.invocator();
- locals.tmpLiquidity.liquidity = locals.increaseLiquidity;
- state.mut().mLiquidities.add(locals.poolID, locals.tmpLiquidity, 0);
- }
- else
- {
- locals.tmpLiquidity = state.get().mLiquidities.element(locals.userLiquidityElementIndex);
- locals.tmpLiquidity.liquidity += locals.increaseLiquidity;
- state.mut().mLiquidities.replace(locals.userLiquidityElementIndex, locals.tmpLiquidity);
- }
-
- output.quAmount = locals.quTransferAmount;
- output.assetAmount = locals.assetTransferAmount;
- output.userIncreaseLiquidity = locals.increaseLiquidity;
- }
-
- locals.poolBasicState.reservedQuAmount += locals.quTransferAmount;
- locals.poolBasicState.reservedAssetAmount += locals.assetTransferAmount;
- locals.poolBasicState.totalLiquidity += locals.increaseLiquidity;
-
- state.mut().mPoolBasicStates.set(locals.poolSlot, locals.poolBasicState);
-
- // Log AddLiquidity procedure
- locals.addLiquidityMessage._contractIndex = SELF_INDEX;
- locals.addLiquidityMessage._type = QSWAPAddLiquidity;
- locals.addLiquidityMessage.assetIssuer = input.assetIssuer;
- locals.addLiquidityMessage.assetName = input.assetName;
- locals.addLiquidityMessage.userIncreaseLiquidity = output.userIncreaseLiquidity;
- locals.addLiquidityMessage.quAmount = output.quAmount;
- locals.addLiquidityMessage.assetAmount = output.assetAmount;
- LOG_INFO(locals.addLiquidityMessage);
-
- if (qpi.invocationReward() > locals.quTransferAmount)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - locals.quTransferAmount);
- }
- }
-
- struct RemoveLiquidity_locals
- {
- RemoveLiquidityMessage removeLiquidityMessage;
- id poolID;
- PoolBasicState poolBasicState;
- sint64 userLiquidityElementIndex;
- sint64 poolSlot;
- LiquidityInfo userLiquidity;
- sint64 burnQuAmount;
- sint64 burnAssetAmount;
-
- uint32 i0;
- };
-
- PUBLIC_PROCEDURE_WITH_LOCALS(RemoveLiquidity)
- {
- output.quAmount = 0;
- output.assetAmount = 0;
-
- if (qpi.invocationReward() > 0 )
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
-
- // check the vadility of input params
- if (input.quAmountMin < 0 || input.assetAmountMin < 0 || input.burnLiquidity <= 0)
- {
- return;
- }
-
- locals.poolID = input.assetIssuer;
- locals.poolID.u64._3 = input.assetName;
-
- // get the pool's basic state
- locals.poolSlot = -1;
-
- for (locals.i0 = 0; locals.i0 < QSWAP_MAX_POOL; locals.i0 ++)
- {
- if (state.get().mPoolBasicStates.get(locals.i0).poolID == locals.poolID)
- {
- locals.poolSlot = locals.i0;
- break;
- }
- }
-
- // the pool does not exsit
- if (locals.poolSlot == -1)
- {
- return;
- }
-
- locals.poolBasicState = state.get().mPoolBasicStates.get(locals.poolSlot);
-
- locals.userLiquidityElementIndex = state.get().mLiquidities.headIndex(locals.poolID, 0);
- while (locals.userLiquidityElementIndex != NULL_INDEX)
- {
- if(state.get().mLiquidities.element(locals.userLiquidityElementIndex).entity == qpi.invocator())
- {
- break;
- }
-
- locals.userLiquidityElementIndex = state.get().mLiquidities.nextElementIndex(locals.userLiquidityElementIndex);
- }
-
- if (locals.userLiquidityElementIndex == NULL_INDEX)
- {
- return;
- }
-
- locals.userLiquidity = state.get().mLiquidities.element(locals.userLiquidityElementIndex);
-
- // not enough liquidity for burning
- if (locals.userLiquidity.liquidity < input.burnLiquidity )
- {
- return;
- }
-
- if (locals.poolBasicState.totalLiquidity < input.burnLiquidity )
- {
- return;
- }
-
- // since burnLiquidity < totalLiquidity, so there will be no overflow risk
- locals.burnQuAmount = sint64(div(
- uint128(input.burnLiquidity) * uint128(locals.poolBasicState.reservedQuAmount),
- uint128(locals.poolBasicState.totalLiquidity)
- ).low);
-
- // since burnLiquidity < totalLiquidity, so there will be no overflow risk
- locals.burnAssetAmount = sint64(div(
- uint128(input.burnLiquidity) * uint128(locals.poolBasicState.reservedAssetAmount),
- uint128(locals.poolBasicState.totalLiquidity)
- ).low);
-
-
- if ((locals.burnQuAmount < input.quAmountMin) || (locals.burnAssetAmount < input.assetAmountMin))
- {
- return;
- }
-
- // return qu and asset to invocator
- qpi.transfer(qpi.invocator(), locals.burnQuAmount);
- qpi.transferShareOwnershipAndPossession(
- input.assetName,
- input.assetIssuer,
- SELF,
- SELF,
- locals.burnAssetAmount,
- qpi.invocator()
- );
-
- output.quAmount = locals.burnQuAmount;
- output.assetAmount = locals.burnAssetAmount;
-
- // modify invocator's liquidity info
- locals.userLiquidity.liquidity -= input.burnLiquidity;
- if (locals.userLiquidity.liquidity == 0)
- {
- state.mut().mLiquidities.remove(locals.userLiquidityElementIndex);
- }
- else
- {
- state.mut().mLiquidities.replace(locals.userLiquidityElementIndex, locals.userLiquidity);
- }
-
- // modify the pool's liquidity info
- locals.poolBasicState.totalLiquidity -= input.burnLiquidity;
- locals.poolBasicState.reservedQuAmount -= locals.burnQuAmount;
- locals.poolBasicState.reservedAssetAmount -= locals.burnAssetAmount;
-
- state.mut().mPoolBasicStates.set(locals.poolSlot, locals.poolBasicState);
-
- // Log RemoveLiquidity procedure
- locals.removeLiquidityMessage._contractIndex = SELF_INDEX;
- locals.removeLiquidityMessage._type = QSWAPRemoveLiquidity;
- locals.removeLiquidityMessage.quAmount = output.quAmount;
- locals.removeLiquidityMessage.assetAmount = output.assetAmount;
- LOG_INFO(locals.removeLiquidityMessage);
- }
-
- struct SwapExactQuForAsset_locals
- {
- SwapMessage swapMessage;
- id poolID;
- sint64 poolSlot;
- sint64 quAmountIn;
- PoolBasicState poolBasicState;
- sint64 assetAmountOut;
-
- uint32 i0;
- uint128 i1, i2, i3, i4;
- uint128 swapFee;
- uint128 feeToInvestRewards;
- uint128 feeToShareholders;
-
- uint128 feeToQx;
- uint128 feeToBurn;
-
- sint64 totalFee;
- };
-
- // given an input qu amountIn, only execute swap in case (amountOut >= amountOutMin)
- // https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-02#swapexacttokensfortokens
- PUBLIC_PROCEDURE_WITH_LOCALS(SwapExactQuForAsset)
- {
- output.assetAmountOut = 0;
-
- // require input qu > 0
- if (qpi.invocationReward() <= 0)
- {
- return;
- }
-
- if (input.assetAmountOutMin < 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- locals.quAmountIn = qpi.invocationReward();
-
- locals.poolID = input.assetIssuer;
- locals.poolID.u64._3 = input.assetName;
-
- locals.poolSlot = -1;
- for (locals.i0 = 0; locals.i0 < QSWAP_MAX_POOL; locals.i0 ++)
- {
- if (state.get().mPoolBasicStates.get(locals.i0).poolID == locals.poolID)
- {
- locals.poolSlot = locals.i0;
- break;
- }
- }
-
- if (locals.poolSlot == -1)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- locals.poolBasicState = state.get().mPoolBasicStates.get(locals.poolSlot);
-
- // check the liquidity validity
- if (locals.poolBasicState.totalLiquidity == 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- locals.assetAmountOut = getAmountOutTakeFeeFromInToken(
- locals.quAmountIn,
- locals.poolBasicState.reservedQuAmount,
- locals.poolBasicState.reservedAssetAmount,
- state.get().swapFeeRate,
- locals.i1,
- locals.i2,
- locals.i3,
- locals.i4
- );
-
- // overflow
- if (locals.assetAmountOut == -1)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- // not meet user's amountOut requirement
- if (locals.assetAmountOut < input.assetAmountOutMin)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- // swapFee = quAmountIn * 0.3% (swapFeeRate/10000)
- // swapFee distribution: 27% shareholders, 5% QX, 3% invest&rewards, 1% burn, 64% LP
- locals.swapFee = div(uint128(locals.quAmountIn) * uint128(state.get().swapFeeRate), uint128(QSWAP_SWAP_FEE_BASE));
- if (locals.swapFee == uint128_t(0))
- {
- locals.swapFee = QSWAP_FEE_BASE_100;
- }
- locals.feeToShareholders = div(locals.swapFee * uint128(state.get().shareholderFeeRate), uint128(QSWAP_FEE_BASE_100));
- locals.feeToQx = div(locals.swapFee * uint128(state.get().qxFeeRate), uint128(QSWAP_FEE_BASE_100));
- locals.feeToInvestRewards = div(locals.swapFee * uint128(state.get().investRewardsFeeRate), uint128(QSWAP_FEE_BASE_100));
- locals.feeToBurn = div(locals.swapFee * uint128(state.get().burnFeeRate), uint128(QSWAP_FEE_BASE_100));
-
- locals.totalFee = sint64(locals.feeToShareholders.low) + sint64(locals.feeToQx.low) + sint64(locals.feeToInvestRewards.low) + sint64(locals.feeToBurn.low);
-
- // Overflow protection: ensure all fees fit in uint64
- if (locals.feeToShareholders.high != 0 || locals.feeToQx.high != 0
- || locals.feeToInvestRewards.high != 0 || locals.feeToBurn.high != 0
- || locals.quAmountIn < locals.totalFee)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- // transfer the asset from pool to qpi.invocator()
- output.assetAmountOut = qpi.transferShareOwnershipAndPossession(
- input.assetName,
- input.assetIssuer,
- SELF,
- SELF,
- locals.assetAmountOut,
- qpi.invocator()
- ) < 0 ? 0: locals.assetAmountOut;
-
- // in case asset transfer failed
- if (output.assetAmountOut == 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- // update fee state after successful transfer
- state.mut().shareholderEarnedFee += locals.feeToShareholders.low;
- state.mut().qxEarnedFee += locals.feeToQx.low;
- state.mut().investRewardsEarnedFee += locals.feeToInvestRewards.low;
- state.mut().burnEarnedFee += locals.feeToBurn.low;
-
- locals.poolBasicState.reservedQuAmount += locals.quAmountIn - locals.totalFee;
- locals.poolBasicState.reservedAssetAmount -= locals.assetAmountOut;
- state.mut().mPoolBasicStates.set(locals.poolSlot, locals.poolBasicState);
-
- // Log SwapExactQuForAsset procedure
- locals.swapMessage._contractIndex = SELF_INDEX;
- locals.swapMessage._type = QSWAPSwapExactQuForAsset;
- locals.swapMessage.assetIssuer = input.assetIssuer;
- locals.swapMessage.assetName = input.assetName;
- locals.swapMessage.assetAmountIn = locals.quAmountIn;
- locals.swapMessage.assetAmountOut = output.assetAmountOut;
- LOG_INFO(locals.swapMessage);
- }
-
- struct SwapQuForExactAsset_locals
- {
- SwapMessage swapMessage;
- id poolID;
- sint64 poolSlot;
- PoolBasicState poolBasicState;
- sint64 quAmountIn;
- sint64 transferredAssetAmount;
-
- uint32 i0;
- uint128 i1, i2, i3;
- uint128 swapFee;
- uint128 feeToInvestRewards;
- uint128 feeToShareholders;
- uint128 feeToQx;
- uint128 feeToBurn;
-
- sint64 totalFee;
- };
-
- // https://docs.uniswap.org/contracts/v2/reference/smart-contracts/router-02#swaptokensforexacttokens
- PUBLIC_PROCEDURE_WITH_LOCALS(SwapQuForExactAsset)
- {
- output.quAmountIn = 0;
-
- // require input qu amount > 0
- if (qpi.invocationReward() <= 0)
- {
- return;
- }
-
- // check input param validity
- if (input.assetAmountOut <= 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- locals.poolID = input.assetIssuer;
- locals.poolID.u64._3 = input.assetName;
-
- locals.poolSlot = -1;
- for (locals.i0 = 0; locals.i0 < QSWAP_MAX_POOL; locals.i0 ++)
- {
- if (state.get().mPoolBasicStates.get(locals.i0).poolID == locals.poolID)
- {
- locals.poolSlot = locals.i0;
- break;
- }
- }
-
- if (locals.poolSlot == -1)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- locals.poolBasicState = state.get().mPoolBasicStates.get(locals.poolSlot);
-
- // check if there is liquidity in the poool
- if (locals.poolBasicState.totalLiquidity == 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- // check if reserved asset is enough
- if (input.assetAmountOut >= locals.poolBasicState.reservedAssetAmount)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- locals.quAmountIn = getAmountInTakeFeeFromInToken(
- input.assetAmountOut,
- locals.poolBasicState.reservedQuAmount,
- locals.poolBasicState.reservedAssetAmount,
- state.get().swapFeeRate,
- locals.i1,
- locals.i2,
- locals.i3
- );
-
- // above call overflow
- if (locals.quAmountIn == -1 || locals.quAmountIn > qpi.invocationReward())
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- // swapFee = quAmountIn * 0.3% (swapFeeRate/10000)
- // swapFee distribution: 27% shareholders, 5% QX, 3% invest&rewards, 1% burn, 64% LP
- locals.swapFee = div(uint128(locals.quAmountIn) * uint128(state.get().swapFeeRate), uint128(QSWAP_SWAP_FEE_BASE));
- if (locals.swapFee == uint128_t(0))
- {
- locals.swapFee = QSWAP_FEE_BASE_100;
- }
- locals.feeToShareholders = div(locals.swapFee * uint128(state.get().shareholderFeeRate), uint128(QSWAP_FEE_BASE_100));
- locals.feeToQx = div(locals.swapFee * uint128(state.get().qxFeeRate), uint128(QSWAP_FEE_BASE_100));
- locals.feeToInvestRewards = div(locals.swapFee * uint128(state.get().investRewardsFeeRate), uint128(QSWAP_FEE_BASE_100));
- locals.feeToBurn = div(locals.swapFee * uint128(state.get().burnFeeRate), uint128(QSWAP_FEE_BASE_100));
-
- locals.totalFee = sint64(locals.feeToShareholders.low) + sint64(locals.feeToQx.low) + sint64(locals.feeToInvestRewards.low) + sint64(locals.feeToBurn.low);
- if (locals.quAmountIn < locals.totalFee)
- {
- qpi.transfer(qpi.invocator(), locals.quAmountIn);
- return;
- }
-
- // Overflow protection: ensure all fees fit in uint64
- if (locals.feeToShareholders.high != 0 || locals.feeToQx.high != 0 ||
- locals.feeToInvestRewards.high != 0 || locals.feeToBurn.high != 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- // transfer the asset from pool to qpi.invocator()
- locals.transferredAssetAmount = qpi.transferShareOwnershipAndPossession(
- input.assetName,
- input.assetIssuer,
- SELF,
- SELF,
- input.assetAmountOut,
- qpi.invocator()
- ) < 0 ? 0: input.assetAmountOut;
-
- // asset transfer failed
- if (locals.transferredAssetAmount == 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- output.quAmountIn = locals.quAmountIn;
- if (qpi.invocationReward() > locals.quAmountIn)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - locals.quAmountIn);
- }
-
- // update fee state after successful transfer
- state.mut().shareholderEarnedFee += locals.feeToShareholders.low;
- state.mut().qxEarnedFee += locals.feeToQx.low;
- state.mut().investRewardsEarnedFee += locals.feeToInvestRewards.low;
- state.mut().burnEarnedFee += locals.feeToBurn.low;
-
- locals.poolBasicState.reservedQuAmount += locals.quAmountIn - locals.totalFee;
- locals.poolBasicState.reservedAssetAmount -= input.assetAmountOut;
- state.mut().mPoolBasicStates.set(locals.poolSlot, locals.poolBasicState);
-
- // Log SwapQuForExactAsset procedure
- locals.swapMessage._contractIndex = SELF_INDEX;
- locals.swapMessage._type = QSWAPSwapQuForExactAsset;
- locals.swapMessage.assetIssuer = input.assetIssuer;
- locals.swapMessage.assetName = input.assetName;
- locals.swapMessage.assetAmountIn = output.quAmountIn;
- locals.swapMessage.assetAmountOut = input.assetAmountOut;
- LOG_INFO(locals.swapMessage);
- }
-
- struct SwapExactAssetForQu_locals
- {
- SwapMessage swapMessage;
- id poolID;
- sint64 poolSlot;
- PoolBasicState poolBasicState;
- sint64 quAmountOut;
- sint64 quAmountOutWithFee;
- sint64 transferredAssetAmountBefore;
- sint64 transferredAssetAmountAfter;
-
- uint32 i0;
- uint128 i1, i2, i3;
- uint128 swapFee;
- uint128 feeToInvestRewards;
- uint128 feeToShareholders;
- uint128 feeToQx;
- uint128 feeToBurn;
-
- sint64 totalFee;
- };
-
- // given an amount of asset swap in, only execute swaping if quAmountOut >= input.amountOutMin
- PUBLIC_PROCEDURE_WITH_LOCALS(SwapExactAssetForQu)
- {
- output.quAmountOut = 0;
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
-
- // check input param validity
- if ((input.assetAmountIn <= 0 )||(input.quAmountOutMin < 0))
- {
- return;
- }
-
- locals.poolID = input.assetIssuer;
- locals.poolID.u64._3 = input.assetName;
-
- locals.poolSlot = -1;
- for (locals.i0 = 0; locals.i0 < QSWAP_MAX_POOL; locals.i0++)
- {
- if (state.get().mPoolBasicStates.get(locals.i0).poolID == locals.poolID)
- {
- locals.poolSlot = locals.i0;
- break;
- }
- }
-
- if (locals.poolSlot == -1)
- {
- return;
- }
-
- locals.poolBasicState = state.get().mPoolBasicStates.get(locals.poolSlot);
-
- // check the liquidity validity
- if (locals.poolBasicState.totalLiquidity == 0)
- {
- return;
- }
-
- // invocator's asset not enough
- if (qpi.numberOfPossessedShares(
- input.assetName,
- input.assetIssuer,
- qpi.invocator(),
- qpi.invocator(),
- SELF_INDEX,
- SELF_INDEX
- ) < input.assetAmountIn )
- {
- return;
- }
-
- locals.quAmountOutWithFee = getAmountOutTakeFeeFromOutToken(
- input.assetAmountIn,
- locals.poolBasicState.reservedAssetAmount,
- locals.poolBasicState.reservedQuAmount,
- state.get().swapFeeRate,
- locals.i1,
- locals.i2,
- locals.i3
- );
-
- // above call overflow
- if (locals.quAmountOutWithFee == -1)
- {
- return;
- }
-
- // no overflow risk
- // locals.quAmountOutWithFee * (QSWAP_SWAP_FEE_BASE - state.swapFeeRate) / QSWAP_SWAP_FEE_BASE
- locals.quAmountOut = sint64(div(
- uint128(locals.quAmountOutWithFee) * uint128(QSWAP_SWAP_FEE_BASE - state.get().swapFeeRate),
- uint128(QSWAP_SWAP_FEE_BASE)
- ).low);
-
- // not meet user min amountOut requirement
- if (locals.quAmountOut < input.quAmountOutMin)
- {
- return;
- }
-
- // swapFee = quAmountOutWithFee * 0.3% (swapFeeRate/10000)
- // swapFee distribution: 27% shareholders, 5% QX, 3% invest&rewards, 1% burn, 64% LP
- locals.swapFee = div(uint128(locals.quAmountOutWithFee) * uint128(state.get().swapFeeRate), uint128(QSWAP_SWAP_FEE_BASE));
- if (locals.swapFee == uint128_t(0))
- {
- locals.swapFee = QSWAP_FEE_BASE_100;
- }
- locals.feeToShareholders = div(locals.swapFee * uint128(state.get().shareholderFeeRate), uint128(QSWAP_FEE_BASE_100));
- locals.feeToQx = div(locals.swapFee * uint128(state.get().qxFeeRate), uint128(QSWAP_FEE_BASE_100));
- locals.feeToInvestRewards = div(locals.swapFee * uint128(state.get().investRewardsFeeRate), uint128(QSWAP_FEE_BASE_100));
- locals.feeToBurn = div(locals.swapFee * uint128(state.get().burnFeeRate), uint128(QSWAP_FEE_BASE_100));
-
- // Overflow protection: ensure all fees fit in uint64
- if (locals.feeToShareholders.high != 0 || locals.feeToQx.high != 0 ||
- locals.feeToInvestRewards.high != 0 || locals.feeToBurn.high != 0)
- {
- return;
- }
-
- // transfer assets from user to pool
- locals.transferredAssetAmountBefore = qpi.numberOfPossessedShares(
- input.assetName,
- input.assetIssuer,
- SELF,
- SELF,
- SELF_INDEX,
- SELF_INDEX
- );
- qpi.transferShareOwnershipAndPossession(
- input.assetName,
- input.assetIssuer,
- qpi.invocator(),
- qpi.invocator(),
- input.assetAmountIn,
- SELF
- );
- locals.transferredAssetAmountAfter = qpi.numberOfPossessedShares(
- input.assetName,
- input.assetIssuer,
- SELF,
- SELF,
- SELF_INDEX,
- SELF_INDEX
- );
-
- // pool does not receive enough asset, rollback any received shares
- if (locals.transferredAssetAmountAfter - locals.transferredAssetAmountBefore < input.assetAmountIn)
- {
- // return any shares that were transferred
- if (locals.transferredAssetAmountAfter > locals.transferredAssetAmountBefore)
- {
- qpi.transferShareOwnershipAndPossession(
- input.assetName,
- input.assetIssuer,
- SELF,
- SELF,
- locals.transferredAssetAmountAfter - locals.transferredAssetAmountBefore,
- qpi.invocator()
- );
- }
- return;
- }
-
- qpi.transfer(qpi.invocator(), locals.quAmountOut);
- output.quAmountOut = locals.quAmountOut;
-
- // update fee state after successful transfers
- state.mut().shareholderEarnedFee += locals.feeToShareholders.low;
- state.mut().qxEarnedFee += locals.feeToQx.low;
- state.mut().investRewardsEarnedFee += locals.feeToInvestRewards.low;
- state.mut().burnEarnedFee += locals.feeToBurn.low;
-
- // update pool states
- locals.poolBasicState.reservedAssetAmount += input.assetAmountIn;
- locals.totalFee = locals.quAmountOut + sint64(locals.feeToShareholders.low) + sint64(locals.feeToQx.low) + sint64(locals.feeToInvestRewards.low) + sint64(locals.feeToBurn.low);
- if (locals.poolBasicState.reservedQuAmount < locals.totalFee)
- {
- locals.poolBasicState.reservedQuAmount = 0;
- }
- else
- {
- locals.poolBasicState.reservedQuAmount -= locals.totalFee;
- }
- state.mut().mPoolBasicStates.set(locals.poolSlot, locals.poolBasicState);
-
- // Log SwapExactAssetForQu procedure
- locals.swapMessage._contractIndex = SELF_INDEX;
- locals.swapMessage._type = QSWAPSwapExactAssetForQu;
- locals.swapMessage.assetIssuer = input.assetIssuer;
- locals.swapMessage.assetName = input.assetName;
- locals.swapMessage.assetAmountIn = input.assetAmountIn;
- locals.swapMessage.assetAmountOut = output.quAmountOut;
- LOG_INFO(locals.swapMessage);
- }
-
- struct SwapAssetForExactQu_locals
- {
- SwapMessage swapMessage;
- id poolID;
- sint64 poolSlot;
- PoolBasicState poolBasicState;
- sint64 assetAmountIn;
- sint64 transferredAssetAmountBefore;
- sint64 transferredAssetAmountAfter;
-
- uint32 i0;
- uint128 i1, i2, i3;
- uint128 swapFee;
- uint128 feeToInvestRewards;
- uint128 feeToShareholders;
- uint128 feeToQx;
- uint128 feeToBurn;
-
- sint64 totalFee;
- };
-
- PUBLIC_PROCEDURE_WITH_LOCALS(SwapAssetForExactQu)
- {
- output.assetAmountIn = 0;
- if (qpi.invocationReward() > 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
-
- if ((input.assetAmountInMax <= 0 )||(input.quAmountOut <= 0))
- {
- return;
- }
-
- locals.poolID = input.assetIssuer;
- locals.poolID.u64._3 = input.assetName;
-
- locals.poolSlot = -1;
- for (locals.i0 = 0; locals.i0 < QSWAP_MAX_POOL; locals.i0 ++)
- {
- if (state.get().mPoolBasicStates.get(locals.i0).poolID == locals.poolID)
- {
- locals.poolSlot = locals.i0;
- break;
- }
- }
-
- if (locals.poolSlot == -1)
- {
- return;
- }
-
- locals.poolBasicState = state.get().mPoolBasicStates.get(locals.poolSlot);
-
- // check the liquidity validity
- if (locals.poolBasicState.totalLiquidity == 0)
- {
- return;
- }
-
- // pool does not hold enough asset
- if (input.quAmountOut >= locals.poolBasicState.reservedQuAmount)
- {
- return;
- }
-
- locals.assetAmountIn = getAmountInTakeFeeFromOutToken(
- input.quAmountOut,
- locals.poolBasicState.reservedAssetAmount,
- locals.poolBasicState.reservedQuAmount,
- state.get().swapFeeRate,
- locals.i1,
- locals.i2,
- locals.i3
- );
-
- // invalid input, assetAmountIn overflow
- if (locals.assetAmountIn == -1)
- {
- return;
- }
-
- // user does not hold enough asset
- if (qpi.numberOfPossessedShares(
- input.assetName,
- input.assetIssuer,
- qpi.invocator(),
- qpi.invocator(),
- SELF_INDEX,
- SELF_INDEX
- ) < locals.assetAmountIn )
- {
- return;
- }
-
- // not meet user amountIn reqiurement
- if (locals.assetAmountIn > input.assetAmountInMax)
- {
- return;
- }
-
- // swapFee = quAmountOut * 30/(10_000 - 30)
- // swapFee distribution: 27% shareholders, 5% QX, 3% invest&rewards, 1% burn, 64% LP
- locals.swapFee = div(uint128(input.quAmountOut) * uint128(state.get().swapFeeRate), uint128(QSWAP_SWAP_FEE_BASE - state.get().swapFeeRate));
- if (locals.swapFee == uint128_t(0))
- {
- locals.swapFee = QSWAP_FEE_BASE_100;
- }
- locals.feeToShareholders = div(locals.swapFee * uint128(state.get().shareholderFeeRate), uint128(QSWAP_FEE_BASE_100));
- locals.feeToQx = div(locals.swapFee * uint128(state.get().qxFeeRate), uint128(QSWAP_FEE_BASE_100));
- locals.feeToInvestRewards = div(locals.swapFee * uint128(state.get().investRewardsFeeRate), uint128(QSWAP_FEE_BASE_100));
- locals.feeToBurn = div(locals.swapFee * uint128(state.get().burnFeeRate), uint128(QSWAP_FEE_BASE_100));
-
- // Overflow protection: ensure all fees fit in uint64
- if (locals.feeToShareholders.high != 0 || locals.feeToQx.high != 0 ||
- locals.feeToInvestRewards.high != 0 || locals.feeToBurn.high != 0)
- {
- return;
- }
-
- locals.transferredAssetAmountBefore = qpi.numberOfPossessedShares(
- input.assetName,
- input.assetIssuer,
- SELF,
- SELF,
- SELF_INDEX,
- SELF_INDEX
- );
- qpi.transferShareOwnershipAndPossession(
- input.assetName,
- input.assetIssuer,
- qpi.invocator(),
- qpi.invocator(),
- locals.assetAmountIn,
- SELF
- );
- locals.transferredAssetAmountAfter = qpi.numberOfPossessedShares(
- input.assetName,
- input.assetIssuer,
- SELF,
- SELF,
- SELF_INDEX,
- SELF_INDEX
- );
-
- // pool does not receive enough asset, rollback any received shares
- if (locals.transferredAssetAmountAfter - locals.transferredAssetAmountBefore < locals.assetAmountIn)
- {
- // return any shares that were transferred
- if (locals.transferredAssetAmountAfter > locals.transferredAssetAmountBefore)
- {
- qpi.transferShareOwnershipAndPossession(
- input.assetName,
- input.assetIssuer,
- SELF,
- SELF,
- locals.transferredAssetAmountAfter - locals.transferredAssetAmountBefore,
- qpi.invocator()
- );
- }
- return;
- }
-
- qpi.transfer(qpi.invocator(), input.quAmountOut);
- output.assetAmountIn = locals.assetAmountIn;
-
- // update fee state after successful transfers
- state.mut().shareholderEarnedFee += locals.feeToShareholders.low;
- state.mut().qxEarnedFee += locals.feeToQx.low;
- state.mut().investRewardsEarnedFee += locals.feeToInvestRewards.low;
- state.mut().burnEarnedFee += locals.feeToBurn.low;
-
- // update pool states
- locals.poolBasicState.reservedAssetAmount += locals.assetAmountIn;
- locals.totalFee = input.quAmountOut + sint64(locals.feeToShareholders.low) + sint64(locals.feeToQx.low) + sint64(locals.feeToInvestRewards.low) + sint64(locals.feeToBurn.low);
- if (locals.poolBasicState.reservedQuAmount < locals.totalFee)
- {
- locals.poolBasicState.reservedQuAmount = 0;
- }
- else
- {
- locals.poolBasicState.reservedQuAmount -= locals.totalFee;
- }
- state.mut().mPoolBasicStates.set(locals.poolSlot, locals.poolBasicState);
-
- // Log SwapAssetForExactQu procedure
- locals.swapMessage._contractIndex = SELF_INDEX;
- locals.swapMessage._type = QSWAPSwapAssetForExactQu;
- locals.swapMessage.assetIssuer = input.assetIssuer;
- locals.swapMessage.assetName = input.assetName;
- locals.swapMessage.assetAmountIn = output.assetAmountIn;
- locals.swapMessage.assetAmountOut = input.quAmountOut;
- LOG_INFO(locals.swapMessage);
- }
-
- PUBLIC_PROCEDURE(TransferShareOwnershipAndPossession)
- {
- output.transferredAmount = 0;
-
- if (qpi.invocationReward() < state.get().cachedTransferFee)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- return;
- }
-
- if (input.amount <= 0)
- {
- if (qpi.invocationReward() > 0 )
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return;
- }
-
- if (qpi.numberOfPossessedShares(
- input.assetName,
- input.assetIssuer,
- qpi.invocator(),
- qpi.invocator(),
- SELF_INDEX,
- SELF_INDEX
- ) < input.amount)
- {
-
- if (qpi.invocationReward() > 0 )
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- return;
- }
-
- output.transferredAmount = qpi.transferShareOwnershipAndPossession(
- input.assetName,
- input.assetIssuer,
- qpi.invocator(),
- qpi.invocator(),
- input.amount,
- input.newOwnerAndPossessor
- ) < 0 ? 0 : input.amount;
-
- if (output.transferredAmount == 0)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward());
- }
- else
- {
- if (qpi.invocationReward() > state.get().cachedTransferFee)
- {
- qpi.transfer(qpi.invocator(), qpi.invocationReward() - state.get().cachedTransferFee);
- }
- state.mut().shareholderEarnedFee += state.get().cachedTransferFee;
- }
- }
-
- PUBLIC_PROCEDURE(SetInvestRewardsInfo)
- {
- output.success = false;
- if (qpi.invocator() != state.get().investRewardsId)
- {
- return;
- }
-
- state.mut().investRewardsId = input.newInvestRewardsId;
- output.success = true;
- }
-
- struct TransferShareManagementRights_locals
- {
- sint64 result;
- sint64 reward;
- sint64 refundAmount;
- sint64 requiredFee;
- bit success;
- };
-
- PUBLIC_PROCEDURE_WITH_LOCALS(TransferShareManagementRights)
- {
- locals.reward = qpi.invocationReward();
- locals.refundAmount = locals.reward;
-
- output.transferredNumberOfShares = 0;
-
- locals.success = false;
-
- if (qpi.numberOfPossessedShares(
- input.asset.assetName,
- input.asset.issuer,
- qpi.invocator(),
- qpi.invocator(),
- SELF_INDEX,
- SELF_INDEX) >= input.numberOfShares)
- {
- locals.result = qpi.releaseShares(
- input.asset,
- qpi.invocator(),
- qpi.invocator(),
- input.numberOfShares,
- input.newManagingContractIndex,
- input.newManagingContractIndex,
- locals.reward
- );
-
- if (locals.result != INVALID_AMOUNT && locals.result >= 0)
- {
- locals.success = true;
- locals.refundAmount = locals.reward - locals.result;
- }
- }
-
- if (locals.success)
- {
- output.transferredNumberOfShares = input.numberOfShares;
- }
-
- if (locals.refundAmount > 0)
- {
- qpi.transfer(qpi.invocator(), locals.refundAmount);
- }
- }
-
- REGISTER_USER_FUNCTIONS_AND_PROCEDURES()
- {
- // functions
- REGISTER_USER_FUNCTION(Fees, 1);
- REGISTER_USER_FUNCTION(GetPoolBasicState, 2);
- REGISTER_USER_FUNCTION(GetLiquidityOf, 3);
- REGISTER_USER_FUNCTION(QuoteExactQuInput, 4);
- REGISTER_USER_FUNCTION(QuoteExactQuOutput, 5);
- REGISTER_USER_FUNCTION(QuoteExactAssetInput, 6);
- REGISTER_USER_FUNCTION(QuoteExactAssetOutput, 7);
- REGISTER_USER_FUNCTION(InvestRewardsInfo, 8);
-
- // procedure
- REGISTER_USER_PROCEDURE(IssueAsset, 1);
- REGISTER_USER_PROCEDURE(TransferShareOwnershipAndPossession, 2);
- REGISTER_USER_PROCEDURE(CreatePool, 3);
- REGISTER_USER_PROCEDURE(AddLiquidity, 4);
- REGISTER_USER_PROCEDURE(RemoveLiquidity, 5);
- REGISTER_USER_PROCEDURE(SwapExactQuForAsset, 6);
- REGISTER_USER_PROCEDURE(SwapQuForExactAsset, 7);
- REGISTER_USER_PROCEDURE(SwapExactAssetForQu, 8);
- REGISTER_USER_PROCEDURE(SwapAssetForExactQu, 9);
- REGISTER_USER_PROCEDURE(SetInvestRewardsInfo, 10);
- REGISTER_USER_PROCEDURE(TransferShareManagementRights, 11);
- }
-
- INITIALIZE()
- {
- state.mut().swapFeeRate = 30; // 0.3%, must be less than 10000
- state.mut().poolCreationFeeRate = 20; // 20%, must be less than 100
-
- // swapFee distribution: 27% shareholders, 5% QX, 3% invest&rewards, 1% burn, 64% LP providers
- state.mut().shareholderFeeRate = 27; // 27% of swap fees to SC shareholders
- state.mut().investRewardsFeeRate = 3; // 3% of swap fees to Invest & Rewards
- state.mut().qxFeeRate = 5; // 5% of swap fees to QX
- state.mut().burnFeeRate = 1; // 1% of swap fees burned
-
- ASSERT(state.get().swapFeeRate < QSWAP_SWAP_FEE_BASE);
- ASSERT(state.get().shareholderFeeRate + state.get().investRewardsFeeRate + state.get().qxFeeRate + state.get().burnFeeRate <= 100);
- //
- state.mut().investRewardsId = ID(_V, _J, _G, _R, _U, _F, _W, _J, _C, _U, _S, _N, _H, _C, _Q, _J, _R, _W, _R, _R, _Y, _X, _A, _U, _E, _J, _F, _C, _V, _H, _Y, _P, _X, _W, _K, _T, _D, _L, _Y, _K, _U, _A, _C, _P, _V, _V, _Y, _B, _G, _O, _L, _V, _C, _J, _S, _F);
- }
-
- struct BEGIN_EPOCH_locals
- {
- QX::Fees_input feesInput;
- QX::Fees_output feesOutput;
- };
-
- BEGIN_EPOCH_WITH_LOCALS()
- {
- CALL_OTHER_CONTRACT_FUNCTION(QX, Fees, locals.feesInput, locals.feesOutput);
-
- if (interContractCallError == NoCallError)
- {
- state.mut().cachedIssuanceFee = locals.feesOutput.assetIssuanceFee;
- state.mut().cachedTransferFee = locals.feesOutput.transferFee;
- }
- }
-
- struct END_TICK_locals
- {
- uint64 toDistribute;
- uint64 toBurn;
- uint64 dividendPerComputor;
- sint64 transferredAmount;
- FailedDistributionMessage logMsg;
- };
-
- END_TICK_WITH_LOCALS()
- {
- // Distribute Invest & Rewards fees
- if (state.get().investRewardsEarnedFee > state.get().investRewardsDistributedAmount)
- {
- locals.toDistribute = state.get().investRewardsEarnedFee - state.get().investRewardsDistributedAmount;
- locals.transferredAmount = qpi.transfer(state.get().investRewardsId, locals.toDistribute);
- if (locals.transferredAmount < 0)
- {
- locals.logMsg._contractIndex = SELF_INDEX;
- locals.logMsg._type = QSWAPFailedDistribution;
- locals.logMsg.dst = state.get().investRewardsId;
- locals.logMsg.amount = locals.toDistribute;
- LOG_INFO(locals.logMsg);
- }
- else
- state.mut().investRewardsDistributedAmount += locals.toDistribute;
- }
-
- // Distribute QX fees as donation
- if (state.get().qxEarnedFee > state.get().qxDistributedAmount)
- {
- locals.toDistribute = state.get().qxEarnedFee - state.get().qxDistributedAmount;
- locals.transferredAmount = qpi.transfer(id(QX_CONTRACT_INDEX, 0, 0, 0), locals.toDistribute);
- if (locals.transferredAmount < 0)
- {
- locals.logMsg._contractIndex = SELF_INDEX;
- locals.logMsg._type = QSWAPFailedDistribution;
- locals.logMsg.dst = id(QX_CONTRACT_INDEX, 0, 0, 0);
- locals.logMsg.amount = locals.toDistribute;
- LOG_INFO(locals.logMsg);
- }
- else
- state.mut().qxDistributedAmount += locals.toDistribute;
- }
-
- // Distribute shareholder fees (to IPO shareholders via dividends)
- if (state.get().shareholderEarnedFee > state.get().shareholderDistributedAmount)
- {
- locals.dividendPerComputor = div((state.get().shareholderEarnedFee - state.get().shareholderDistributedAmount), 676ULL);
- if (locals.dividendPerComputor > 0 && qpi.distributeDividends(locals.dividendPerComputor))
- {
- state.mut().shareholderDistributedAmount += locals.dividendPerComputor * NUMBER_OF_COMPUTORS;
- }
- }
-
- // Burn fees (adds to contract execution fee reserve)
- if (state.get().burnEarnedFee > state.get().burnedAmount)
- {
- locals.toBurn = state.get().burnEarnedFee - state.get().burnedAmount;
- qpi.burn(locals.toBurn);
- state.mut().burnedAmount += locals.toBurn;
- }
- }
-
- PRE_ACQUIRE_SHARES()
- {
- output.allowTransfer = true;
- }
-};
diff --git a/src/mining/ant_colony/ant_colony.h b/src/mining/ant_colony/ant_colony.h
index b900f6a61..db935e476 100644
--- a/src/mining/ant_colony/ant_colony.h
+++ b/src/mining/ant_colony/ant_colony.h
@@ -444,7 +444,7 @@ class AntColony
// Constraint specific functions
// Resolves a parent for scoring. outParentRec is null for ROOT_REF, the caller derives the
- // per-identity root from the submitter's pubkey instead.
+ // shared epoch root from the root seed instead.
ValidityResult tryGetParent(const SolutionRef& parentRef,
const AntSolutionRecord** outParentRec) const;
diff --git a/src/mining/score_bpp9000.h b/src/mining/score_bpp9000.h
index 40468c8c4..039a98e62 100644
--- a/src/mining/score_bpp9000.h
+++ b/src/mining/score_bpp9000.h
@@ -11,16 +11,6 @@ namespace score_engine
// Largest L (mutations per step) the scorer clamps nonce[1] to
static constexpr unsigned int MAX_LUT_ENTRIES_PER_STEP = 10;
-// A bpp9000 nonce is canonical iff its score-irrelevant knob bytes are canonical:
-// nonce[0] = algo (enforced by routing), nonce[1] = L in [1, MAX_LUT_ENTRIES_PER_STEP], nonce[2] = K = 0
-static bool isCanonicalBpp9000Nonce(const unsigned char* nonce)
-{
- return (getAlgoType(nonce) == AlgoType::Bpp9000)
- && (nonce[1] >= 1)
- && (nonce[1] <= MAX_LUT_ENTRIES_PER_STEP)
- && (nonce[2] == 0);
-}
-
template
struct ScoreBpp9000
{
@@ -45,6 +35,17 @@ struct ScoreBpp9000
static_assert(lutSize <= lutStride, "LUT rows must fit the padded stride");
+ // A nonce is canonical if its score-irrelevant knob bytes are canonical:
+ // nonce[0] = algo (enforced by routing), nonce[1] = L in [1, MAX_LUT_ENTRIES_PER_STEP],
+ // nonce[2] = K. The standalone walk pins K to 0, so only 0 is canonical there.
+ static bool isCanonicalStandaloneNonce(const unsigned char* nonce)
+ {
+ return (getAlgoType(nonce) == AlgoType::Bpp9000)
+ && (nonce[1] >= 1)
+ && (nonce[1] <= MAX_LUT_ENTRIES_PER_STEP)
+ && (nonce[2] == 0);
+ }
+
// K is a real degree of freedom here: the walk restores K = nonce[2] as its explore-step count
static bool isCanonicalAntNonce(const unsigned char* nonce)
{
@@ -1073,8 +1074,9 @@ struct ScoreBpp9000
compact(bestANN, out);
}
- // Seed the ANN: root LUT from the pubkey alone (each computor's fixed root); mutation seeds from
- // pubkey+nonce (nonce[0..2] are the algo/L/K knobs, excluded from the RNG). Returns the start score.
+ // Standalone path only: root LUT from the pubkey alone; the ant path derives its shared epoch
+ // root via deriveRootANN(rootSeed) instead. Mutation seeds from pubkey+nonce (nonce[0..2] are
+ // the algo/L/K knobs, excluded from the RNG). Returns the start score.
unsigned int initializeANN(
const unsigned char* publicKey,
const unsigned char* nonce,
@@ -1168,14 +1170,16 @@ struct ScoreBpp9000
return computeScoreFromCurrent(L, K, cur);
}
- // Ant colony: the network every one of an identity's lineages starts from. Written to a buffer the
- // caller owns, so two roots can be derived on one engine without the first silently becoming the
- // second - a child scored against the wrong root would differ only in resourceTestingDigest.
+ // Ant colony: the shared per-epoch network every identity's tree starts from. rootSeed is the
+ // epoch-start spectrum digest, so all identities derive the identical root; only the mutation
+ // walks stay per-identity. Written to a buffer the caller owns, so two roots can be derived on
+ // one engine without the first silently becoming the second - a child scored against the wrong
+ // root would differ only in resourceTestingDigest.
// Uses currentANN as its working buffer, so it destroys whatever the engine was holding. Callers
// derive a root and then score from it, which overwrites currentANN anyway.
- void deriveRootANN(const unsigned char* publicKey, const unsigned char* pRandom2Pool, ANN& out)
+ void deriveRootANN(const unsigned char* rootSeed, const unsigned char* pRandom2Pool, ANN& out)
{
- deriveRootLut(publicKey, pRandom2Pool);
+ deriveRootLut(rootSeed, pRandom2Pool);
applyRootLut(currentANN);
compact(currentANN, out);
}
diff --git a/src/mining/score_engine.h b/src/mining/score_engine.h
index a95cb0482..a512d5ad3 100644
--- a/src/mining/score_engine.h
+++ b/src/mining/score_engine.h
@@ -12,6 +12,9 @@ struct ScoreEngine
ScoreBpp9000 _bpp9000Score;
unsigned char lastNonceByte0;
+ // The inheritable per-neuron LUT the ant colony branches on.
+ using AntAnn = typename ScoreBpp9000::ANN;
+
void initMemory()
{
setMem(&_bpp9000Score, sizeof(ScoreBpp9000), 0);
@@ -19,12 +22,6 @@ struct ScoreEngine
_bpp9000Score.initMemory();
}
- // Unused function
- void initMiningData(const unsigned char* randomPool)
- {
-
- }
-
// Load the task blocks into the active bpp9000 leaf; returns false on invalid topology/data.
bool loadTask(const unsigned char* topoBlock, const unsigned char* dataBlock)
{
@@ -39,8 +36,6 @@ struct ScoreEngine
unsigned int computeBpp9000Score(const unsigned char* publicKey, const unsigned char* nonce, const unsigned char* randomPool)
{
- // The score IS the error count - smaller is better. A timeout maps to the worst in-range value
- // rather than INVALID_SCORE_VALUE, which the score cache cannot store (it reads back as a miss).
const unsigned int failures = _bpp9000Score.computeScore(publicKey, nonce, randomPool);
return (failures == ScoreBpp9000::INFINITE_ERROR)
? (unsigned int)ScoreBpp9000::numberOfWindows
@@ -61,9 +56,19 @@ struct ScoreEngine
}
}
- // Each engine owns its canonical ant-nonce rule; this switch is the algorithm seam, so ingress
- // code stays algorithm-agnostic. Neuraxon is reserved and not ant-minable, so no nonce in its
- // slot is canonical.
+ // Each engine owns its canonical standalone-nonce rule
+ static bool isCanonicalStandaloneNonce(const unsigned char* nonce)
+ {
+ switch (getAlgoType(nonce))
+ {
+ case AlgoType::Bpp9000:
+ return ScoreBpp9000::isCanonicalStandaloneNonce(nonce);
+ default:
+ return false;
+ }
+ }
+
+ // Each engine owns its canonical ant-nonce rule
static bool isCanonicalAntNonce(const unsigned char* nonce)
{
switch (getAlgoType(nonce))
@@ -75,6 +80,33 @@ struct ScoreEngine
}
}
+ // Ant colony: the shared per-epoch network every identity's tree starts from; rootSeed is the
+ // epoch-start spectrum digest
+ void deriveAntRootANN(const unsigned char* rootSeed, const unsigned char* randomPool, AntAnn& out)
+ {
+ _bpp9000Score.deriveRootANN(rootSeed, randomPool, out);
+ }
+
+ // Ant colony: score a child by inheriting the parent's network and walking it with the child's
+ // own seeds. Returns INVALID_SCORE_VALUE for a non-canonical nonce or an unsupported algorithm.
+ unsigned int computeAntScoreFromParent(const AntAnn& parent, const unsigned char* publicKey,
+ const unsigned char* nonce, const unsigned char* anchorDigest, const unsigned char* randomPool)
+ {
+ switch (getAlgoType(nonce))
+ {
+ case AlgoType::Bpp9000:
+ return _bpp9000Score.computeScoreFromParent(parent, publicKey, nonce, anchorDigest, randomPool);
+ default:
+ return INVALID_SCORE_VALUE;
+ }
+ }
+
+ // Ant colony: the network that produced the score the walk returned.
+ void getAntBestANN(AntAnn& out)
+ {
+ _bpp9000Score.getBestANN(out);
+ }
+
// returns last computed output neurons of the active bpp9000 slot
m256i getLastOutput()
{
diff --git a/src/network_messages/ant_colony_message.h b/src/network_messages/ant_colony_message.h
index 98b123eb8..10c31ed2f 100644
--- a/src/network_messages/ant_colony_message.h
+++ b/src/network_messages/ant_colony_message.h
@@ -95,7 +95,7 @@ static_assert(sizeof(AntIdentityTreeResponse)
// RespondAntParentAnnHeader.status values.
constexpr unsigned char ANT_PARENT_ANN_STATUS_OK = 0; // ANN bytes follow the header
constexpr unsigned char ANT_PARENT_ANN_STATUS_NOT_FOUND = 1; // parentRef has no record
-constexpr unsigned char ANT_PARENT_ANN_STATUS_IS_ROOT = 2; // ROOT_REF; no ANN payload - miner derives its own per-identity root
+constexpr unsigned char ANT_PARENT_ANN_STATUS_IS_ROOT = 2; // ROOT_REF; no ANN payload - miner derives the shared epoch root
// ONE tree node's stored network, named by parentRef - the ANN state a miner mutates to extend
// that node. The tree itself is listed by the identity-tree query; this fetches the material for a
diff --git a/src/public_settings.h b/src/public_settings.h
index d4920889d..66d53cd88 100644
--- a/src/public_settings.h
+++ b/src/public_settings.h
@@ -73,12 +73,12 @@ static_assert(AUTO_FORCE_NEXT_TICK_THRESHOLD* TARGET_TICK_DURATION >= PEER_REFRE
// Config options that should NOT be changed by operators
#define VERSION_A 1
-#define VERSION_B 302
-#define VERSION_C 1
+#define VERSION_B 303
+#define VERSION_C 0
// Epoch and initial tick for node startup
-#define EPOCH 228
-#define TICK 76550000
+#define EPOCH 229
+#define TICK 77700000
#define TICK_IS_FIRST_TICK_OF_EPOCH 1 // Set to 0 if the network is restarted during the EPOCH with a new initial TICK
#define ARBITRATOR "AFZPUAIYVPNUYGJRQVLUKOPPVLHAZQTGLYAAUUNBXFTVTAMSBKQBLEIEPCVJ"
@@ -118,8 +118,8 @@ static constexpr unsigned int NEURAXON_SOLUTION_THRESHOLD_DEFAULT = 1;
// and hash-verified at node init
static unsigned short SCORE_BPP9000_TASK_FILE_NAME[] = L"bpp9000.task";
static constexpr unsigned char BPP9000_TOPOLOGY_HASH[32] =
- { 0x13, 0xe9, 0x9d, 0x5b, 0x2f, 0xca, 0x56, 0xaa, 0x78, 0x9c, 0xb9, 0x59, 0x57, 0x5f, 0x48, 0x39,
- 0x2f, 0x1a, 0x44, 0x90, 0x9a, 0x8e, 0xaf, 0x27, 0xf2, 0xde, 0x8f, 0x8d, 0x74, 0xb0, 0x7a, 0x6b };
+ { 0x76, 0xa3, 0xf5, 0x10, 0x20, 0x05, 0x9b, 0xf5, 0x22, 0x7f, 0x30, 0x20, 0x13, 0x69, 0xcb, 0x0a,
+ 0x32, 0x3b, 0x93, 0xcd, 0xc2, 0x59, 0x8e, 0x1f, 0x1c, 0x59, 0x66, 0xbd, 0x9c, 0x0d, 0xf4, 0xef };
static constexpr unsigned char BPP9000_DATA_HASH[32] =
{ 0x97, 0x9c, 0xdc, 0x22, 0x47, 0xd2, 0xca, 0x4e, 0xd3, 0xd6, 0x14, 0xbf, 0x27, 0x89, 0x63, 0x84,
0xcb, 0x1c, 0x9c, 0x3d, 0x80, 0x4a, 0xf6, 0xed, 0xe6, 0xb5, 0x9f, 0xc5, 0x2c, 0x0e, 0x3d, 0xfa };
diff --git a/src/qpi/impl/qpi_system_impl.h b/src/qpi/impl/qpi_system_impl.h
index 383dacad9..bb98845dc 100644
--- a/src/qpi/impl/qpi_system_impl.h
+++ b/src/qpi/impl/qpi_system_impl.h
@@ -1,14 +1,19 @@
-#pragma once
-
-#include "qpi/qpi.h"
-#include "system.h"
-
-unsigned short QPI::QpiContextFunctionCall::epoch() const
-{
- return system.epoch;
-}
-
-unsigned int QPI::QpiContextFunctionCall::tick() const
-{
- return system.tick;
-}
+#pragma once
+
+#include "qpi/qpi.h"
+#include "system.h"
+
+unsigned short QPI::QpiContextFunctionCall::epoch() const
+{
+ return system.epoch;
+}
+
+unsigned int QPI::QpiContextFunctionCall::tick() const
+{
+ return system.tick;
+}
+
+unsigned int QPI::QpiContextFunctionCall::initialTick() const
+{
+ return system.initialTick;
+}
diff --git a/src/qpi/qpi_context.h b/src/qpi/qpi_context.h
index 07854a4d9..032e79afa 100644
--- a/src/qpi/qpi_context.h
+++ b/src/qpi/qpi_context.h
@@ -185,6 +185,9 @@ namespace QPI
inline uint32 tick(
) const; // [0..999'999'999]
+ inline uint32 initialTick(
+ ) const;
+
inline uint8 year(
) const; // [0..99] (0 = 2000, 1 = 2001, ..., 99 = 2099)
diff --git a/src/qubic.cpp b/src/qubic.cpp
index 27929295a..621fae505 100644
--- a/src/qubic.cpp
+++ b/src/qubic.cpp
@@ -2,7 +2,6 @@
// #define INCLUDE_CONTRACT_TEST_EXAMPLES
-// #define OLD_QRAFFLE
// contract_def.h needs to be included first to make sure that contracts have minimal access
#include "contract_core/contract_def.h"
@@ -609,12 +608,14 @@ static void antColonyBeginEpoch()
// Every identity's root derives from this one value, so a node that seeded differently builds a
// different forest and diverges. Logged as an identity so operators can compare it across nodes
// by eye at epoch start, which is cheaper than finding out from a digest split later.
+#ifndef NDEBUG
CHAR16 digestChars[60 + 1];
getIdentity(gAntColony.rootSeed().m256i_u8, digestChars, true);
CHAR16 msg[128];
setText(msg, L"[ant-colony] Root seed = ");
appendText(msg, digestChars);
- logToConsole(msg);
+ addDebugMessage(msg);
+#endif
}
// DOGE merged-mining shares
@@ -3439,7 +3440,7 @@ static void processTickTransactionAntColonySolution(
}
else
{
- // A null parent record means root, the scorer derives the submitter's own root, since roots
+ // A null parent record means root, the scorer derives the shared epoch root, since roots
// are never stored and so cannot be handed in.
const AntColonyBpp9000T::Ann* parentAnn = nullptr;
if (parentRec != nullptr)
diff --git a/src/score.h b/src/score.h
index 31f0772c1..5798e8a4e 100644
--- a/src/score.h
+++ b/src/score.h
@@ -203,7 +203,8 @@ struct ScoreFunction
// Ant colony main score function
// score a child by inheriting its parent's network and walking it with the child's own seeds.
- // parentAnn == nullptr means the parent is the submitter's root, which is derived here from the pubkey
+ // parentAnn == nullptr means the parent is the epoch root, which is derived here from the
+ // epoch-start spectrum digest (currentRandomSeed) and is identical for every identity
// Returns INVALID_SCORE_VALUE for a non-canonical nonce, in which case outChildAnn is not written
// bestANN would still hold the previous call's network, and committing that would put one node's
// stale bytes into childAnnHash.
@@ -217,25 +218,25 @@ struct ScoreFunction
{
const int solutionBufIdx = (int)(processor_Number % solutionBufferCount);
LockGuard guard(solutionEngineLock[solutionBufIdx]);
- score_engine::ScoreBpp9000T& engine = _computeBuffer[solutionBufIdx]._bpp9000Score;
+ score_engine::ScoreEngineT& engine = _computeBuffer[solutionBufIdx];
// Derived into this slot's scratch rather than the engine's own buffer: deriveRootANN() uses
// currentANN as working space
const score_engine::ScoreBpp9000T::ANN* parent = parentAnn;
- // Depth 1, the start node of every public key
+ // Depth 1, the shared epoch root every identity starts from
if (parent == nullptr)
{
- engine.deriveRootANN(publicKey.m256i_u8, poolVec, _antRootScratch[solutionBufIdx]);
+ engine.deriveAntRootANN(currentRandomSeed.m256i_u8, poolVec, _antRootScratch[solutionBufIdx]);
parent = &_antRootScratch[solutionBufIdx];
}
- const unsigned int childScore = engine.computeScoreFromParent(
+ const unsigned int childScore = engine.computeAntScoreFromParent(
*parent, publicKey.m256i_u8, nonce.m256i_u8, anchorDigest.m256i_u8, poolVec);
if (childScore == score_engine::INVALID_SCORE_VALUE)
{
return childScore;
}
- engine.getBestANN(outChildAnn);
+ engine.getAntBestANN(outChildAnn);
return childScore;
}
// main score function
@@ -243,17 +244,9 @@ struct ScoreFunction
{
PROFILE_SCOPE();
- switch (score_engine::getAlgoType(nonce.m256i_u8))
+ if (!score_engine::ScoreEngineT::isCanonicalStandaloneNonce(nonce.m256i_u8))
{
- case score_engine::AlgoType::Bpp9000:
- if (!score_engine::isCanonicalBpp9000Nonce(nonce.m256i_u8))
- {
- return score_engine::INVALID_SCORE_VALUE;
- }
- break;
- default:
- // Unsupported algo
- return score_engine::INVALID_SCORE_VALUE;
+ return score_engine::INVALID_SCORE_VALUE;
}
if (isZero(miningSeed) || miningSeed != currentRandomSeed)
diff --git a/test/contract_nostromo.cpp b/test/contract_nostromo.cpp
index 6f9c8e67d..a16d2233b 100644
--- a/test/contract_nostromo.cpp
+++ b/test/contract_nostromo.cpp
@@ -1,1692 +1,4011 @@
#define NO_UEFI
-#include