Digital shopping mall management SaaS system

Abstract

The invention relates to the technical field of e-commerce, and relates to a digital shopping mall management SaaS system, and the system comprises the steps: collecting shopping mall call and network events, and generating an embedded vector through optical reserve wavelength division multiplexing nonlinear mapping; under the constraint of the causal structure in the last round, the de-noising diffusion model generates twinborn events, an updated causal graph is formed through incremental Bayesian information criterion learning, and a causal feature tensor is obtained through random walk embedding; a reinforcement learning framework formed by the neural morphological execution network and the GPU evaluation network fuses tensors with inventory, price and promotion business data into a value state, and outputs a price adjustment-discount-replenishment strategy; the strategy is compiled into a WebAssembly micro contract, and the components are subjected to hot replacement without shutdown through a BPF sandbox; generating a zero-knowledge proof for the micro contract and storing the proof on the side chain of the block chain; in the gray stage, profit, inventory and cost feedback is collected and written back to a data link to complete self-adaptive closed loop; according to the invention, millisecond-level strategy iteration, second-level security release and extreme scene robust operation are realized.

Description

Technical Field

[0001] The present invention relates to the technical field of e-commerce, and particularly to a digital mall management SaaS system. Background Art

[0002] As online retail enters a new stage of second-level traffic fluctuations and multi-channel linkages, merchants generally still rely on a local system of "offline reports + manual thresholds": using a correlation statistical model to predict sales volume daily or weekly, and then batch-adjusting prices, replenishments, and discounts through operation and maintenance scripts. This model has three limitations: First, the prediction model and thresholds are updated offline, and cannot be corrected in a timely manner in the face of millisecond-level traffic surges such as flash sales and public opinion-driven sales, often resulting in over-selling of inventory or dilution of profits; Second, the model only captures relevant features and lacks causal identification. Once the input distribution drifts due to holidays, rising logistics costs, or competitor subsidies, the prediction error quickly amplifies and reversely expands the business risk; Third, the rule issuance depends on the rolling restart of the entire container, the release time is in minutes, and there is a lack of version hashing and public verification, which not only affects the user experience but also increases the compliance audit cost. The lack of a traceable chain also makes it difficult to locate the source of strategy mistakes afterwards. Therefore, a digital mall urgently needs a cloud SaaS architecture that can capture call behaviors in milliseconds, update the causal structure incrementally online, output multi-objective strategies in real time, and achieve a fully verifiable closed loop through zero-downtime release in a secure sandbox and on-chain evidence storage. Summary of the Invention

[0003] In view of the many problems existing in the above-mentioned prior art, the present invention provides a digital mall management SaaS system. The system of the present invention first captures the mall call flow with eBPF, and the optical reserve mapping unfolds the event flow in high dimensions; the causal control diffusion model generates twin extreme samples and updates the dependence graph in real time through incremental BIC learning, and Node2Vec embeds into a tensor. Based on this, neuromorphic-GPU reinforcement learning outputs price adjustment, discount, and replenishment strategies, and then the micro contract performs second-level hot replacement in the sandbox and stores evidence on the chain. The closed-loop iteration makes the profit, inventory, and promotion costs converge to the optimal Pareto frontier in the long term.

[0004] As Figure 1 shown, a digital mall management SaaS system, characterized by comprising:

[0005] An event data generation unit, configured to collect system call data and network communication data of a merchant operating environment to generate atomic event data; generate twin event data according to a causal structure control diffusion probability generation model; merge the twin event data with the atomic event data, and form a current causal structure through an incremental causal discovery algorithm; perform feature embedding on the current causal structure to obtain causal feature tensor data;

[0006] A policy learning unit for combining the causal feature tensor data with business data into value state data and outputting policy data based on the value state data according to a reinforcement learning framework;

[0007] A component update unit for generating a component change instruction according to the policy data, compiling the component change instruction into an executable micro-contract and hot-replacing the mall function components in a secure sandbox environment, collecting business feedback data during a preset gray-scale verification period, and sending the business feedback data to the event data generation unit and the policy learning unit respectively for cyclic update.

[0008] Preferably, the event data generation unit includes a kernel probe module and a data preprocessing module. The kernel probe module collects system call information and network communication information of the merchant operation environment through the eBPF mechanism, and the data preprocessing module formats the system call information and the network communication information into key-value records and outputs the atomic event data.

[0009] Preferably, the event data generation unit further includes an optical reserve mapping module. The optical reserve mapping module performs a non-linear mapping on the atomic event data by using wavelength division multiplexing to generate an embedding vector, and inputs the embedding vector into the diffusion probability generation model.

[0010] Preferably, the diffusion probability generation model is a denoising diffusion probability model, which uses a multi-scale convolutional network to complete forward perturbation and backward reconstruction, and takes the embedding vector and the causal structure as conditional inputs.

[0011] Preferably, the incremental causal discovery algorithm includes an edge addition stage and an edge deletion stage. In the edge addition stage, edges are added between candidate node pairs according to the Bayesian information criterion, and in the edge deletion stage, edges that do not meet the set criteria are removed according to the Bayesian information criterion.

[0012] Preferably, the policy learning unit includes an execution network set on a neuromorphic processor and an evaluation network set on a graphics processor. The execution network outputs policy data in the form of pulses, and the evaluation network calculates the state value according to the value state data and backpropagates the temporal difference error.

[0013] Preferably, the policy learning unit further includes a weight adjustment module. The weight adjustment module updates the reward weight vector according to the pulse density of the execution network to balance the profit index, the inventory index and the promotion cost index.

[0014] Preferably, the component update unit includes a micro-contract compilation module. The micro-contract compilation module converts the component change instruction into a WebAssembly micro-contract.

[0015] Preferably, the component update unit further includes a verification module, which generates a zero-knowledge proof of the WebAssembly micro-contract and records the zero-knowledge proof on the blockchain side chain.

[0016] Preferably, it further includes a business data interface unit, which obtains inventory information, price information, and promotion information and provides the business data to the policy learning unit.

[0017] Compared with the prior art, the advantages and beneficial effects of the present invention are as follows:

[0018] The present invention generates through optical reserve non-linear mapping + causal control diffusion, explicitly exposing extreme loads;

[0019] The present invention realizes millisecond-level structure update and overcomes concept drift through incremental Bayesian causal learning;

[0020] The present invention realizes sub-millisecond policy output through collaborative reinforcement learning of a neuromorphic execution network and a GPU evaluation network;

[0021] The present invention realizes non-stop publishing through WebAssembly micro-contract + BPF sandbox hot replacement;

[0022] The present invention realizes public verification of contract integrity through zero-knowledge proof side chain evidence storage. BRIEF DESCRIPTION OF THE DRAWINGS

[0023] Figure 1 It is a structural block diagram of the system of the present invention;

[0024] Figure 2 It is a full-link closed-loop architecture diagram of the present invention;

[0025] Figure 3 It is an event data generation depth pipeline diagram of the present invention;

[0026] Figure 4 It is an internal interaction diagram of the policy learning unit of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0027] Hereinafter, embodiments of the present disclosure will be described with reference to the accompanying drawings. However, it should be understood that these descriptions are exemplary only and are not intended to limit the scope of the present disclosure. In the following detailed description, for the sake of explanation, many specific details are set forth to provide a comprehensive understanding of the embodiments of the present disclosure. However, obviously, one or more embodiments can also be implemented without these specific details. In addition, in the following description, descriptions of well-known structures and technologies are omitted to avoid unnecessarily confusing the concepts of the present disclosure.

[0028] The terms used herein are merely for describing specific embodiments and are not intended to limit the present disclosure. The terms "including", "comprising", etc. used herein indicate the presence of the described features, steps, operations, and / or components, but do not exclude the presence or addition of one or more other features, steps, operations, or components.

[0029] All terms used herein (including technical and scientific terms) have the meanings commonly understood by those skilled in the art, unless otherwise defined. It should be noted that the terms used herein should be interpreted as having a meaning consistent with the context of this specification and should not be interpreted in an idealized or overly rigid manner.

[0030] A digital mall management SaaS system, characterized by comprising:

[0031] An event data generation unit, configured to collect system call data and network communication data of a merchant operation environment to generate atomic event data; generate twin event data according to a causal structure control diffusion probability generation model; merge the twin event data with the atomic event data, and form a current causal structure through an incremental causal discovery algorithm; perform feature embedding on the current causal structure to obtain causal feature tensor data;

[0032] The work of the event data generation unit is carried out around four consecutive links: behavior collection, twin generation, causal update, and feature embedding. The principle and application effect in the digital mall scenario are described below from the system perspective, and a complete embodiment is added to illustrate the closed-loop operation process.

[0033] First, as Figure 2 shown, the system loads eBPF kernel probes in each merchant container. eBPF can run bytecode in the kernel space. The present invention uses this mechanism to directly hook into the system call entry and the transport layer packet receiving entry to intercept the full-link call sequence of "order placement - payment - logistics" in real time. The probe encodes the intercepted information into key-value pairs to form atomic event data. Since the sampling is located in the kernel state, the data naturally has a time sequence and can be batch processed by the GPU as a whole in the user state without additional sorting, providing a stable and low-latency data stream for subsequent parallel computing.

[0034] To expose the model to extreme business pressure during the training phase, the system introduces a diffusion probability generation model conditioned on the causal structure. The causal adjacency matrix A t-1 obtained in the previous cycle is decomposed into a covariance term and an attention bias term: the covariance term regulates the forward noise distribution, and the attention bias term affects the channel weights of the reverse network, enabling the twin generation to not only follow the historical causal direction but also explore sparse regions not covered by the real data. The generated twin event stream is merged with the atomic event data to form a unified event sequence, providing richer and more robust samples for causal learning.

[0035] The causal graph update adopts an incremental structure learning strategy. The algorithm only searches locally for the differences between the old structure and the new samples, and performs a two-stage discrimination of "adding edges - deleting edges". If adding an edge X→Y to the node pair X, Y makes:

[0036] ΔBIC = -2Δln L + Δd·ln m < 0

[0037] where Δln L is the logarithmic likelihood gain, Δd is the change in degrees of freedom, and m is the sample size, then retain this edge; otherwise, delete it. The incremental strategy avoids traversing the entire graph and can converge to the new maximum a posteriori structure within a single loop, meeting the latency requirements of real-time scenarios.

[0038] The new graph is transformed into a causal feature tensor through random walk and Skip-Gram embedding. The random walk outputs a node sequence, maps the nodes to a vector space by maximizing the co-occurrence probability, and the tensor is input into the policy learning unit together with business variables such as inventory, price, and promotion. Since the tensor encodes the directionality and intensity between events, the policy network can clearly identify the causal chain that is most explanatory for profit and inventory fluctuations during gradient backpropagation, improving the interpretability of decisions.

[0039] Four links form a closed loop: real-time sampling ensures the integrity of behavior, conditional diffusion expands the observation domain, incremental learning stabilizes the causal structure, and the embedding tensor compresses the structural information into a fixed-length vector. When entering the promotion peak, the spike request and payment call show a short-term burst. The twin event streams repeatedly present such extreme sequences during the training phase, prompting the causal graph to timely introduce a new edge of "spike request → payment request"; the embedding tensor then amplifies the weight of this causal path in the value function, and the policy learning unit adjusts the inventory threshold and dynamic pricing accordingly. The business monitoring end observes that the payment timeout rate decreases and the inventory deviation converges. Thus, the event data generation unit not only provides high-granularity observations but also forms an adaptive loop of data - model - decision through feedback with the policy end, enabling the digital mall to maintain the balance between revenue and inventory in high-concurrency scenarios.

[0040] Preferably, as Figure 3 shown, the event data generation unit includes a kernel probe module and a data preprocessing module. The kernel probe module collects system call information and network communication information of the merchant's operating environment through the eBPF mechanism, and the data preprocessing module formats the system call information and the network communication information into key-value records and outputs the atomic event data.

[0041] eBPF allows for the dynamic loading of bytecode in the Linux kernel space and attaching it to hook points for execution. This invention selects two types of hook points: one type is located at the system call entry points (such as sys_enter_openat2, sys_enter_sendto, etc.), and the other type is located at the transport layer packet receiving functions (tcp_recvmsg, udp_recvmsg). When the probe is triggered at the hook point, it reads the registers and protocol headers to construct a minimized event fragment:

[0042] evt = <cid, tid, t, code, len>

[0043] where cid is the container ID, tid is the thread ID, t is the nanosecond timestamp, code is the call or packet type encoding, and len is the payload length. Key implementation points:

[0044] Use BPF_RINGBUF_OUTPUT to establish a zero-copy buffer between the kernel and user space;

[0045] For each event, only record the necessary metadata to avoid copying large objects;

[0046] Enable batch submission in the mmap area for high-concurrency merchants to reduce system call overhead.

[0047] Under the stress test of an eight-core virtual machine, the probe stably outputs more than one hundred thousand events per second, with the CPU occupancy rate below 3%, providing the ability to capture microsecond-level behaviors for the mall's spike purchase scenario.

[0048] Principle of the data preprocessing module: The event stream pushed by the probe is still in the original structure and is difficult to be directly processed by the GPU. The data preprocessing module resides in the user state and is responsible for two operations: formatting and batching.

[0049] Adopt a custom KV-Codec to write the five-tuple into a fixed-length sixteen-byte message segment. The key is the double hash value hash(cid, tid), and the value is the combined field code << 48 | len; the timestamp is cached separately in a chronological queue to ensure the insertion order is the time order, and no further sorting is required later.

[0050] Transport the chronological queue to the GPU through io_uring and aggregate it into batches according to a fixed window size. To balance throughput and latency, the window threshold and the maximum waiting time limit are triggered by "either-or": send directly when the batch reaches the upper limit, or send after waiting for the threshold time.

[0051] After formatting, the volume of the event is reduced by approximately 60%; the batching mechanism enables the GPU to obtain aligned loading blocks, maximizing the utilization of the video memory bandwidth and keeping the end-to-end latency at the order of ten milliseconds.

[0052] In one embodiment, the mall launches a limited-time flash sale, and a large number of clients simultaneously pull the product interface and poll the inventory. It is expected that the system call peak will increase by an order of magnitude within ten milliseconds after the start of the flash sale.

[0053] The kernel probe captures the product interface GET request at sys_enter_recvmsg and records the event code = 0x31.

[0054] The data preprocessing module aggregates 50,000 events within a two-millisecond window, generates a batch index, and sends it to the GPU.

[0055] Subsequently, the causal learning unit discovers that the path weight of "product interface GET → inventory update" soars, and the policy learning unit immediately calls the component update unit to lower the single-purchase limit.

[0056] One minute after the start of the flash sale, the server CPU peak drops by 15%; the payment success rate increases by 8% compared to the scenario without adaptive control, achieving real-time monitoring and dynamic current limiting.

[0057] Preferably, the event data generation unit further includes an optical reserve mapping module. The optical reserve mapping module performs a non-linear mapping on the atomic event data in a wavelength-division multiplexing manner to generate an embedding vector, and inputs the embedding vector into the diffusion probability generation model.

[0058] The optical reserve mapping module is essentially an "optical inner product expansion". The system encodes the atomic event data stream into a voltage signal through a digital-to-analog converter, and this signal drives a group of modulators to modulate more than a dozen laser carriers into pulse trains. The laser carriers are located in different wavelength channels and are injected into a ring fiber cavity in parallel through wavelength-division multiplexing technology. There are weak echoes and scattering inside the fiber cavity, which is equivalent to a recursive network with a time delay. Its state evolution can be approximately written as:

[0059] x(t + 1) = f(W in u(t) + W res x(t))

[0060] where u(t) is the current pulse amplitude vector, W in describes the modulation coupling, W res is determined by the fiber feedback, and f(·) is the inherent non-linear response. With the help of wavelength-division multiplexing, multiple wavelength channels share the structure in the cavity but do not interfere with each other, which is equivalent to observing the state trajectories under multiple different initial conditions simultaneously, and equivalently generating high-order features with dozens of times the dimension. The outgoing pulse is converted back to the electrical domain through a photodetector, and a fixed-length embedding vector can be obtained by accumulating a sliding window. This embedding vector is immediately sent into the diffusion probability generation model, replacing the traditional MLP pre-coding, so that the diffusion model sees a highly expanded, time-memory-bearing, and already implicitly non-linearly interacting representation at the first layer.

[0061] In practical applications, wavelength multiplexing: Each laser carrier represents a logical channel. The event stream is mapped to pulse amplitude and phase through a codebook and then synchronously written through an array modulator; optical fiber loop: The loop length determines the state delay, and the coupling ratio is set to ensure that self-excited oscillation does not occur in the cavity; readout: The high-speed photodetector outputs parallel currents, and the serial-parallel converter stitches multi-channel samples into a single vector; asynchronous write-back: The mapped vector is directly written into the GPU video memory without persistent caching, reducing the I / O overhead.

[0062] The propagation time of the optical fiber cavity is much less than the clock period of the electronic recurrent network, and the mapping delay can be ignored at the same depth; each event segment is simultaneously expanded in the time domain and wavelength domain through wavelength division multiplexing, and rich interaction features can be obtained at the first layer of the diffusion model without additional convolution or self-attention for primary feature extraction; optical noise follows a stationary statistical distribution, and the diffusion model naturally accommodates noise, and the mapping error will not damage downstream training.

[0063] In one embodiment, the mall enters the warm-up ten seconds before zero o'clock, and a large number of clients poll the inventory.

[0064] The atomic event data stream maps the "inventory polling RPC" to a continuous pulse train and injects it into the sixteen-channel wavelength channel; the multiplexed pulses in the ring cavity experience several cycles, introducing sub-nanosecond phase perturbations, and the output forms a one-hundred-and-twenty-dimensional embedding vector; the diffusion model generates a twin sequence of "inventory polling peak → payment queuing" accordingly, explicitly completing the unappeared queuing risk; the causal graph timely adds an edge of "polling peak → queuing", and the policy learning unit reduces the upper limit of single-user concurrent requests.

[0065] After the official flash sale starts, the payment queuing time is reduced by about one-third compared with the non-mapping scheme, and the peak CPU occupancy of the backend API is maintained within the safe threshold, indicating that the optical reserve mapping exposes the extreme state in advance and effectively supports policy adaptation.

[0066] The optical reserve mapping module, through physical-level parallelism and inherent nonlinearity, hands over the high-order expansion that is difficult to calculate in real time in the electronic domain to photonics, providing almost instant high-dimensional features for extreme loads and black swan traffic in the digital mall scenario, making the diffusion model and causal inference more forward-looking and robust.

[0067] Preferably, the diffusion probability generation model is a denoising diffusion probability model, which uses a multi-scale convolutional network to complete forward perturbation and backward reconstruction, and uses the embedding vector and the causal structure as conditional inputs.

[0068] The system first receives the embedded vector output by the optical reserve mapping module. This vector undergoes K steps of Gaussian noise injection, and the noise covariance is derived from the symmetric part of the causal adjacency matrix, ensuring that the noise direction is related to the existing edge weights. The forward process gradually destroys the original signal to obtain an approximately isotropic noise end point.

[0069] Entering the reverse phase, the multi-scale convolutional network restores the signal layer by layer with time resolution. The network injects the anti-symmetric part of the causal adjacency matrix as a channel bias bypass in each convolutional block, enabling the network to refer to the causal direction while picking frequency band features; the embedded vector is used as a global condition to adjust the amplitudes of features at each scale through the feature recalibration module. After such processing, the network restores the overall trend at the low-scale level and recovers fine-grained spikes at the high-scale level, and finally outputs a twin event sequence.

[0070] Since the mall traffic distribution changes with the promotion rhythm, the model reads the latest causal matrix and updates the noise covariance in each closed-loop cycle, and at the same time adjusts the convolutional layer normalization factor using the online quantization scheme to make the reconstruction result always fit the latest business situation.

[0071] The noise covariance brings randomness, and the causal bias constrains the direction. The generated sequence covers both rare peaks and does not violate the historical dependence relationship. The multi-scale convolutional network captures the trading cycle in a long time window and tracks spike calls in a short time window, making the twin sequence sensitive to both inventory pressure and payment blockage. By adjusting the noise scheduler, more aggressive or conservative load scenarios can be actively generated, providing a debuggable script for stress drills.

[0072] In one embodiment, the mall plans to start a flash sale at 2 am. Twelve hours before training, the operation team requests the model to generate spikes ten times the historical average load to drill the backend capacity.

[0073] Set conditions: The causal matrix shows that the edge weight of "product page request → payment interface" is the largest; the embedded vector is derived from the previous round of optical reserve mapping. The model amplifies the noise covariance in the corresponding edge weight direction and selects a longer noise sequence in the scheduler.

[0074] Forward-backward process: The embedded vector undergoes a complete diffusion, and the reverse network simultaneously introduces the amplified causal bias. The reconstruction result presents multiple coherent peak segments of "product page request → payment interface", and the peak interval is shorter than the historical minimum interval.

[0075] Since the twin sequence triggers the payment interface overlimit, the policy learning unit actively splits the inventory batches and delays the issuance of some coupons before the drill. After the drill, the monitoring data shows that the peak CPU occupancy of the backend remains within the safe threshold, and the payment delay does not exceed the set upper limit.

[0076] Preferably, the incremental causal discovery algorithm includes an edge addition stage and an edge deletion stage. In the edge addition stage, edges are added between candidate node pairs according to the Bayesian information criterion. In the edge deletion stage, edges that do not meet the set criteria are removed according to the Bayesian information criterion.

[0077] The incremental causal discovery algorithm is the core logic in the digital mall management SaaS system that converts the "unified event sequence" into a directed dependency graph in real time. It only modifies the local area of the graph in each loop through the "edge addition - edge deletion" double stage to shorten the recomputation cost and keep the structure consistent with the latest business.

[0078] Candidate set limitation: The system maintains an adjacency matrix A t-1 . When a new unified event sequence ε t arrives, candidates are only established for the following node pairs: node pairs with an increase in conditional mutual information within the past sampling window; node pairs that currently have no direct edge connection or the existing edge weight has dropped to near the threshold. This ensures that the search space grows linearly with the sample increment and does not explode with the total number of nodes.

[0079] In the edge addition stage, a directed edge X→Y is tentatively added to each candidate undirected pair (X, Y). The gain of this operation on the Bayesian information criterion BIC = -2ln L + dln m is calculated. If ΔBIC < 0, it means that the likelihood increase is sufficient to offset the increase in model complexity, then the edge is retained and the local structure is updated. In the present invention, the conditional distribution is only re - estimated within the closure of nodes X and Y, and the cost is proportional to the square of the local degree, ensuring that the single - batch delay is lower than the business threshold.

[0080] In the edge deletion stage, the existing edges are traversed, and it is reversely checked whether deleting an edge causes an increase in BIC. If ΔBIC ≤ 0 after deletion, it means that the contribution of this edge is insufficient or it has been replaced by a new path, and the edge is immediately removed. Edge deletion is also limited to the local closure, maintaining the incremental characteristic.

[0081] Loop convergence: Edge addition and edge deletion are alternated until no structural changes are triggered in one traversal. The present invention limits the maximum number of executions per loop to three rounds to avoid long - tail search. Finally, a new adjacency matrix A t and edge weights are output.

[0082] The structure update time has a linear relationship with the incremental sample size. During the peak promotion period, it still converges within milliseconds and will not slow down the policy learning. The edge deletion stage continuously clears transient pulse relationships, preventing occasional noise from remaining in the causal graph for a long time and improving the policy interpretability. The alternation of edge addition and deletion gives the newly added edge weights a "cold start" period, and the policy learning end will not significantly adjust the inventory threshold due to a single surge, reducing jitter.

[0083] In one embodiment, a co - branded sneaker is launched in the mall, and the flash sale entrance / api / flash_buy is opened. There is no such node in the causal graph before the launch.

[0084] The unified event sequence shows a high-frequency pattern of "flash sale interface → payment interface". The node pair (flash_buy, pay) enters the candidate set.

[0085] After calculating and adding flash_buy → pay, ΔBIC < 0, the new edge is retained and the initial edge weight is recorded.

[0086] For the old edge marketing_click → pay detected in the same batch, the likelihood improvement is insufficient, and this edge is removed during the edge deletion stage.

[0087] In the next cycle, since the causal graph already contains flash_buy → pay, the diffusion model incorporates the payment peak into the noise covariance, and the twin event stream shows a denser payment congestion sequence. Based on this, the policy learning unit raises the inventory threshold in advance and releases coupons in batches.

[0088] When the new product flash sale is launched, the peak CPU occupancy ratio of the payment interface is about 20% lower than that of the test group without using incremental causal adjustment, and the inventory debt event does not occur, indicating that the edge addition - edge deletion strategy timely captures the new product traffic path and guides policy adaptation.

[0089] As Figure 4 shown, a policy learning unit is used to combine the causal feature tensor data with business data into value state data, and output policy data based on the value state data according to the reinforcement learning framework;

[0090] The task of the policy learning unit is to integrate "causal feature tensor + controllable business variables" into a learnable value state, and output a three-dimensional policy of price adjustment - promotion - replenishment under the reinforcement learning framework, so that the mall maintains a dynamic balance among profit, inventory, and promotion cost. The unit works in the order of "state construction → decision network collaboration → weight adaptation → closed-loop update" internally.

[0091] State construction - Structurally interpretable inputs. The causal feature tensor carries the directionality and intensity between event nodes, and business metrics such as inventory balance, current selling price, and discount ratio reflect the operable quantities. The interface layer concatenates the two into a fixed-length vector, called the value state. In this way, the network can see both the key dependencies extracted by incremental causal learning and simultaneously refer to the immediate business metrics, making the decision more interpretable.

[0092] Decision Network Collaboration - Actor-Critic Division of Labor. The execution network (actor) runs on neuromorphic hardware and uses pulse coding for event-triggered forward propagation of value states. The output action vector contains three components: price adjustment range, discount depth, and inventory adjustment. The pulse mode is naturally suitable for high-frequency updates and low power consumption. The evaluation network (critic) is deployed on the GPU and is responsible for estimating the expected return of the current state and generating gradient signals. The critic guides the convergence direction of the execution network based on the temporal difference error. The two cooperate iteratively and can converge to a local optimal strategy within dozens to hundreds of steps. Temporal difference error:

[0093] δ t = r t + γV θ (s t+1 ) - V θ (s t )

[0094] where s t is the current value state; r t is the immediate reward; V θ (·) is the state value estimated by the critic; γ is the discount factor. θ represents the set of critic parameters.

[0095] Weight Adaptation - Multi-objective Dynamic Balance. The mall hopes to simultaneously increase profits, reduce inventory deviation, and compress promotion costs. The policy learning unit maintains a set of reward weights that roll over time. Based on the pulse density output by the execution network and the historical fluctuations of each indicator, the weight generator adjusts the three-dimensional weights in real time and calculates the scalar reward:

[0096]

[0097] π t : current profit; q t : current inventory; q ＊ : target inventory; c t : promotion cost; The i-th dynamic weight. Output by the weight generator and used to automatically find the balance point among the three indicators.

[0098] When the pulse density shows that profit is overly pursued and inventory fluctuations increase, the weight generator increases the inventory penalty weight, prompting subsequent strategies to pay more attention to safety inventory; vice versa.

[0099] Closed-loop Update - Self-evolution Driven by Gray-scale Verification. After the policy data is hot-replaced into the online micro-contract, the profit increment and inventory deviation are collected in real time within the gray-scale window. At the end of the window: The monitoring data is fed back to the critic to update the target network parameters and refresh the state value estimation; at the same time, the key business indicators are sent back to the weight generator to fine-tune the three-dimensional weights to ensure that the reward function in the next cycle is still consistent with the business objectives. This closed-loop ensures that the policy is synchronized with the business performance and will not fail due to changes in the market environment or promotion rhythm.

[0100] Preferably, the policy learning unit includes an execution network disposed on a neuromorphic processor and an evaluation network disposed on a graphics processor. The execution network outputs policy data in the form of pulses, and the evaluation network calculates the state value based on the value state data and backpropagates the time difference error.

[0101] The policy learning unit adopts a heterogeneous collaborative structure of "neuromorphic execution network + GPU evaluation network" to provide millisecond-level decision output and real-time value evaluation in the digital mall scenario.

[0102] Execution Network: Pulse-based Policy Generation. The execution network is deployed on a neuromorphic processor. This chip implements a pulsed neuron model with circuits, and each pulse represents an event trigger, which is naturally suitable for processing the high-concurrency and strong-beat data streams in the mall. The value state vector s t After entering the chip, it is first converted into a pulse train through voltage encoding; the internal layer integrates the pulses with plastic synaptic weights, and when the membrane potential reaches the threshold, an output pulse is triggered. Finally, three pulse counts are obtained at the output layer:

[0103]

[0104] They are mapped proportionally to the policy increment:

[0105] a t = [Δp t , Δd t , Δq t

[0106] They respectively correspond to the price adjustment range, discount depth, and replenishment quantity adjustment. The pulse-amplitude mapping eliminates the conventional activation function and quantization steps, making the delay mainly depend on the membrane potential integration time, which usually falls within the sub-millisecond level.

[0107] Evaluation Network: Value Calculation and Error Backpropagation. The evaluation network runs on the GPU and is implemented by a multi-layer perceptron. It inputs the same state vector s t , and outputs the state value: V θ (s t ), and receives the immediate reward r t at the next moment, and calculates the time difference error:

[0108] δt = r t + γV θ (s t+1 ) - V θ (s t )

[0109] where γ is the discount factor. The error δ t returns to the neuromorphic chip through an off-chip high-speed link as the learning signal for the plastic synapse.

[0110] For the linkage principle, the synaptic update follows the pulse-STDP (spike-timing-dependent plasticity) rule, but the amplitude is modulated by δ t Modulation:

[0111]

[0112] Variable meanings, w ij : synaptic weight connecting i to j; η: learning rate; Binary indicator of whether a pulse appears within the window. Positive error promotes an increase in the synaptic weight positively correlated with the reward, and negative error weakens it. The execution network can adapt to the new value gradient within hundreds of pulse cycles.

[0113] The neuromorphic chip works in an event-driven manner, outputting an action when the pulse count saturation value is reached and is not bound by a fixed clock. Pulse neurons only consume power when an event arrives; during the low-traffic period at night, the execution network has almost no energy consumption. The GPU is responsible for floating-point precision value evaluation, and the chip is responsible for microsecond response. During the high-load period, the two work in parallel without blocking each other.

[0114] In one embodiment, the mall launches a limited blind box activity with extremely low inventory and a traffic explosion.

[0115] The causal tensor shows a sharp increase in the weight of "blind box interface → inventory depletion", and the inventory balance quickly approaches zero. The input pulse density of the execution network rapidly increases, and the output action Δq t > 0 (release the secondary warehouse inventory) Δd t < 0 (lower the discount), which is pushed to the component update unit in milliseconds. The GPU observes the profit recovery and the reduction of inventory deviation, generating a positive error δ t > 0, driving the synaptic weight to be strengthened in the direction of the existing strategy. When the blind box is sold out, the inventory debt is zero, and the payment failure rate remains at an acceptable level.

[0116] This process demonstrates that the pulse execution network provides sub-millisecond replenishment decisions in extreme scenarios of urgent inventory, while the GPU evaluation network is responsible for long-term revenue evaluation and reverse shaping of the strategy. The two together ensure the double balance of the mall's revenue and experience.

[0117] Preferably, the policy learning unit further includes a weight adjustment module, which updates the reward weight vector according to the pulse density of the execution network to balance the profit index, inventory index, and promotion cost index.

[0118] The weight adjustment module is responsible for dynamically allocating the weights of profit, inventory, and promotion cost inside the multi-objective reward function, so that the policy learning unit automatically keeps the gradient amplitudes of the three indicators of the same order under different business scenarios, avoiding extreme oscillations such as "pursuing profit leading to inventory imbalance" or "overstocking to compress profit".

[0119] Pulse density perception: The output layer of the execution network contains three groups of pulse channels, which drive the price adjustment, discount, and replenishment components respectively. The module performs softmax normalization on the pulse count within a decision window of one frame to obtain the density vector

[0120]

[0121] where Price adjustment pulse count; Discount adjustment pulse count; Replenishment pulse count. The pulse density reflects the current attention of the execution network: if the proportion of price pulses increases, it means that the network is more inclined to increase profit; if the proportion of replenishment pulses increases, it means that it pays attention to inventory safety.

[0122] Target difference calculation: The system maintains the expected density vector d ＊ , which is given by the operation strategy or historical equilibrium level. The module calculates the difference:

[0123] Δd t =d t -d ＊

[0124] Weight vector update: The reward weight is updated using a simple approximate gradient step method:

[0125] w t+1 =Norm(w t -ηΔd t )

[0126] where η: adjustment step size; Norm(·): positive projection onto the probability simplex to ensure and

[0127] In this way, when the execution network over-outputs replenishment pulses, the inventory penalty weight w (2) will increase; if the profit channel is suppressed, the profit weight w (1) will be improved. The module can achieve real-time weight rebalancing through the pulse side signal without analyzing the gradients of business indicators.

[0128] Pulse counts accumulate in microseconds, and weight updates are completed within milliseconds, making them suitable for high-frequency scenarios like flash sales. Weights are always normalized to prevent overweighting of a single indicator. Using pulses as a signal source eliminates floating-point operations and offers strong noise immunity. Operations personnel can directly view pulse proportions and weight vectors to understand why strategies favor price reductions or reduced replenishment.

[0129] In one example, with eight hours left before Black Friday, the operator lowered the discounts across the entire store, and the discount pulse density on the execution network soared within a 32ms window. Execution process:

[0130] The weight adjustment module detects Profit pulse density decreased;

[0131] Automatically increase the profit weight w according to the above formula (1) , reduce the promotion cost weight w (3) ;

[0132] In the next batch of pulses, the execution network reduces the discount depth output and moderately increases the selling price;

[0133] Post-release monitoring by Grayscale showed that the profit curve stopped falling and turned positive, and the inventory consumption rate approached the target trajectory.

[0134] At the end of the Black Friday window, compared with the baseline group without weight adjustment, the mall's gross profit increased while inventory occupancy remained at the same level, indicating that the weight adjustment module successfully restored the profit share amid the extreme price reduction impulse and achieved a balance among the three indicators.

[0135] A component update unit is used to generate component change instructions according to the policy data, compile the component change instructions into executable micro-contracts and hot-replace mall functional components in a secure sandbox environment, collect business feedback data during a preset grayscale verification period, and send the business feedback data to the event data generation unit and the policy learning unit respectively to achieve cyclic updates.

[0136] The component update unit enables the "paper policies" generated by the policy learning unit to be truly implemented online, while also injecting the behavioral effects back into the data-model chain, achieving a full-stack closed loop. Its working sequence can be summarized into four steps: instruction generation, micro-contract compilation, sandbox hot replacement, and phased verification and feedback.

[0137] Instruction generation, strategy data to programming intermediate code, action vector a output by the strategy learning unit t =[Δp t ,Δd t ,Δq t ] is first converted into a component change instruction through template conversion. The instruction uses JSON-IR to describe the target component, the modified fields, and the scope of effectiveness. For example:

[0138] {

[0139] "component": "pricing",

[0140] "op": "delta",

[0141] "price": -0.03,

[0142] "sku_set": "flash_buy"

[0143] }

[0144] Pricing, promotion, and replenishment all share the same instruction syntax, so the strategy side can drive multiple adjustments within one transmission.

[0145] Micro - contract compilation: IR - to - WASM. The instruction stream enters the micro - contract compilation pipeline: the semantic checker verifies the field legality and permissions; the code generator translates JSON - IR into WebAssemblyText; wasm - opt compresses and generates bytecode to obtain an executable micro - contract.

[0146] Through the "IR→WASM" double - layer abstraction, the update logic does not depend on the mall backend language stack; at runtime, any strategy can be loaded as long as WASM is supported.

[0147] Secure sandbox hot replacement. The mall running nodes are pre - installed with the BPF JIT sandbox. When the sandbox loads a contract: it constructs a new BPF program to point the function pointer to the contract export; uses atomic swap to replace the old address to avoid downtime; sets the maximum number of execution steps to prevent infinite loops.

[0148] The entire replacement process is completed within a single thread, and the user side cannot perceive power outages or reconnections. Since the WASM bytecode has been statically verified before loading, the sandbox only needs to perform a lightweight measurement again at the JIT stage to ensure that the contract is both secure and efficient.

[0149] Gray - scale verification and closed - loop feedback. After replacement, it only takes effect on a certain percentage of traffic to form a gray - scale group. The system collects three types of business feedback data during a preset period: 1. Revenue - related: the profit difference between the gray - scale group and the control group; 2. Inventory - related: the target inventory deviation curve; 3. User experience: the payment delay distribution.

[0150] If "profit does not decrease, inventory fluctuations converge, and delays do not exceed the threshold" are all met at the same time, then the traffic is increased until it reaches full volume; otherwise, the rollback logic is triggered to reset the old components. Regardless of the result, the complete feedback JSON will be written back traceably:

[0151] Event data generation unit: Mark gray - scale labels for the next round of causal learning; Policy learning unit: Incorporate the temporal difference error in the form of r t to update the network parameters.

[0152] Preferably, the component update unit includes a micro-contract compilation module, which converts the component change instruction into a WebAssembly micro-contract.

[0153] The micro-contract compilation module is responsible for immediately converting high-level component change instructions into WebAssembly micro-contracts that can be uploaded to the chain and run in a sandbox; it is the key bridge in the "policy -> code -> hot replacement" link. The module internally contains four-level pipelining: semantic parsing, static verification, bytecode generation, and product encapsulation.

[0154] Semantic parsing: The component change instruction comes from the policy learning unit and usually represents the target component, operation type, and parameter fields in JSON-IR. The parser converts the IR into abstract syntax nodes according to a preset syntax tree. For example, "op": "delta", "price": -0.02" of the price component will be mapped to DeltaOpNode(-0.02). During the parsing stage, the completeness of fields and the legality of the scope are also checked to prevent missing parameters or cross-component over-authorization.

[0155] Static verification: After parsing, the verification stage generates an equivalent control-data flow graph for each syntax node and performs two types of checks: type safety to ensure that numerical operations do not overflow the preset fixed-point format; resource limit to calculate the maximum stack depth of the instruction sequence and compare it with the sandbox limit; if the rules are violated, compilation is immediately rejected to avoid incorrect logic from entering the running state.

[0156] Bytecode generation: The compiler outputs Wasm text in the order of module -> function -> instruction, and then generates binary bytecode through wasm-opt. The generation policy follows the following principles:

[0157] Minimum interface: Only export affected functions such as update_price, apply_discount;

[0158] No external imports: All dependencies are implemented inside the contract to ensure portability;

[0159] Deterministic operation: Disable floating-point and random number instructions to avoid differences in on-chain verification.

[0160] After completion, the bytecode is calculated for its hash and written into the deployment manifest together with the policy data to ensure the traceability of subsequent hot replacement and on-chain evidence storage.

[0161] Product encapsulation. The final product includes: a.wasm file; version metadata (component name, instruction hash, creation time); optional debug symbols for grayscale backtracking. The encapsulator packages these three and pushes them to the BPF sandbox loader via a gRPC stream. Since the bytecode has passed static verification, the sandbox only needs to perform minimal measurement to start the replacement, and the entire process usually takes only a few tens of milliseconds.

[0162] The business layer only needs to output JSON-IR and does not need to know the multi-language implementation of the backend; compilation-verification-packaging is a pure user-state operation, and there is no disk I / O in the main process, adapting to high-frequency policy iteration; the Wasm bytecode structure is simple and easy to recalculate by multiple parties, meeting the requirements of zero-knowledge proof and on-chain auditing.

[0163] In one embodiment, during the Black Friday event, the policy learning unit pushes the following instructions:

[0164] {

[0165] "component":"promotion",

[0166] "op":"step_discount",

[0167] "steps":[[1,0.05],[3,0.10],[5,0.15]],

[0168] "sku_set":"electronics"

[0169] }

[0170] Semantic parsing maps the three-step ladder to a loop node for tierinsteps {if qty >= tier.qty...}. Static verification finds that the array length meets the threshold and there is no floating-point calculation, and it passes the check. The bytecode generation outputs a Wasm file that only contains the function apply_step_discount, and uses integer multiplication internally to complete the discount. The encapsulation push ends and is loaded into the sandbox, with a 10% grayscale traffic. After fifteen minutes, data verification shows that both profit and average order value are improving, and the grayscale is amplified and recorded on the chain. The contract takes less than thirty seconds from JSON to becoming effective, demonstrating the fast delivery and security guarantee capabilities of the micro-contract compilation module in the big promotion scenario.

[0171] Preferably, the component update unit further includes a verification module, and the verification module generates a zero-knowledge proof of the WebAssembly micro-contract and records the zero-knowledge proof on the side chain of the blockchain.

[0172] The verification module of the component update unit embeds "code security" and "verifiable release" into the automatic online process. Through zero-knowledge proof and side-chain deposit, the integrity and compliance of each WebAssembly micro-contract are written as publicly verifiable facts without disclosing business secrets.

[0173] Declare the proposition to be proved. For the compiled bytecode wasm, the verification module needs to prove two things externally: its hash value h is equal to keccak256(wasm), ensuring that the on-chain record is consistent with the actual deployment;

[0174] The "security policy check" returns true: no floating-point instructions, no unauthorized calls, and the logical branch depth is within the limit. Let P(wasm) represent the boolean output of the policy check, then the statement to be proved can be written as

[0175] SAT(h,wasm) = [h = Hash(wasm)] ∧ [P(wasm) = 1]

[0176] where h: public hash commitment; Hash(·): Keccak-256 hash function; P(·): security policy check function.

[0177] Circuitization and proof. The micro-contract compilation pipeline translates the above statement into a zk-SNARK circuit in the user state:

[0178] The hash circuit implements the bit-level iteration of Keccak-256;

[0179] The policy circuit counts the bytecode instructions and simulates the permission table, and outputs zero if there is a violation.

[0180] The generation tool (based on circom or arkworks) outputs proof π and the public input h. The verification module calls the Groth16 proof system and outputs the (π,h) binary tuple.

[0181] On-chain record. The side-chain node stores the lightweight contract Verifier.sol, which embeds the Groth16 verification key.

[0182] The verification module packs (π,h) into a transaction and broadcasts it to the side-chain:

[0183] {

[0184] "hash":"0x2abf…",

[0185] "proof":"0x9c01…",

[0186] "component":"pricing",

[0187] "version":"v20241112-01"}

[0188] After the side-chain consensus layer completes the verification, it writes the hash and timestamp into the state tree, and any third party can recheck the contract's legality without seeing the source code.

[0189] Once the hash-proof is written to the chain, an undeniable version signature is formed; verifiers only need to look at the hash and proof, without having to obtain the actual bytecode; the constant-level verification latency of Groth16 is less than a millisecond and does not slow down hot replacement.

[0190] In one embodiment, the Double Twelve ladder discount contract:

[0191] The micro-contract is compiled to generate the bytecode wasm0;

[0192] The verification module calculates the hash h0 and generates a circuit witness through circom, and outputs π0;

[0193] The side-chain transaction Tx0=(h0,π0) is packaged and the consensus is completed within two seconds;

[0194] The operation and maintenance team only sees a green tick "verified" on the dashboard and can confirm that the contract has passed the security check without having to read the internal logic;

[0195] If a dispute occurs a week later, a third party can pull the h0 on the chain and re-verify π0 against the running wasm0 online to ensure an evidence closed-loop.

[0196] This process demonstrates that the verification module introduces strong consistency security guarantees in a millisecond-level online rhythm without exposing the details of business strategies, and is particularly suitable for the sensitive pricing logic of multi-tenant shopping malls.

[0197] Preferably, it further includes a business data interface unit, which obtains inventory information, price information, and promotion information and provides the business data to the policy learning unit.

[0198] The business data interface unit undertakes the conversion of "business ledger → learnable features" to ensure that the policy learning unit always grasps the three most directly controllable quantities of the physical inventory, pricing, and promotion intensity of the shopping mall. Its core is divided into three steps: data aggregation, time alignment, and feature packaging, and it maintains millisecond-level synchronization with the policy learning unit through an event stream.

[0199] Data Aggregation: A multi-source consistent view where inventory information comes from the warehousing microservice, price information comes from the product center, and promotion information comes from the marketing engine. The interface unit enables Change Data Capture (CDC) in bypass mode and writes the latest snapshots of three Kafka topics into the local state table; at the same time, it listens for incremental events and continuously patches the snapshots. Since CDC only replicates row-level updates, the throughput is isolated from the main business and does not affect the order placement latency.

[0200] Time Alignment: Unified sampling points, with different update frequencies for inventory, price, and promotion. The interface unit introduces a sliding time window to align the three-stream events according to the timestamp of the most recent update; if a certain field has no new value in the current window, the previous valid value is backfilled to ensure that the triples sent to the policy learning unit at the same moment have consistent physical semantics. In this way, the policy network will not confuse expired inventory with new pricing when calculating gradients.

[0201] Feature Packing: Vectorize the business volume, and the aligned triples are encoded into a business vector b t . The encoding rule is to concatenate according to the SKU dimension:

[0202] The inventory balance is mapped to the normalized remaining percentage;

[0203] The price change is represented by the logarithmic increase or decrease to prevent the absolute price difference from dominating the gradient;

[0204] The promotion intensity is converted into a discount factor.

[0205] This vector is directly concatenated to the causal feature tensor to form the value state and sent to the policy learning unit.

[0206] CDC + sliding window ensures lock-free replication of business table updates, while the policy side can still learn about the latest changes in milliseconds; the unified time base eliminates the cross-source latency difference, making the gradients of the three goals of profit, inventory, and promotion of the same order of magnitude and avoiding training oscillations; if subsequent features such as integral deductions or freight subsidies are added, only the topic and field mappings need to be appended in the interface unit, and the policy side is unaware.

[0207] In one embodiment, during a live streaming e-commerce event, the inventory of a certain product is running low. The host suddenly names SKU-B in the live streaming room, and the sales volume soars instantly. The warehousing microservice reduces the available quantity to 20 within two seconds; the interface unit CDC captures the change, and the sliding window immediately updates the inventory dimension.

[0208] State Update: The inventory percentage in b t drops sharply;

[0209] Policy Output: After receiving the new state, the execution network reduces the discount depth, raises the selling price, and at the same time triggers an urgent replenishment contract to the component update unit;

[0210] Feedback: The gray-scale window shows that the profit has recovered and the inventory has gradually returned to the target range.

[0211] This example shows that the business data interface unit can synchronize the inventory decline at the millisecond level in the scenario of sudden sales volume, supporting the strategy learning unit to bid and limit the flow in a timely manner, and avoiding overselling and profit loss.

[0212] Those skilled in the art should understand that the embodiments of the present application can be provided as a method, a system, or a computer program product. Therefore, the present application can adopt the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware aspects.

[0213] The above are only the embodiments of the present application and are not used to limit the present application. For those skilled in the art, various changes and modifications can be made to the present application. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application shall be included within the scope of the claims of the present application.

Claims

1. A digital mall management SaaS system, characterized in that It includes: An event data generation unit, which is used to collect system call data and network communication data of the merchant operation environment to generate atomic event data; Generate twin event data according to the causal structure control diffusion probability generation model; merge the twin event data with the atomic event data, and form the current causal structure through the incremental causal discovery algorithm; perform feature embedding on the current causal structure to obtain causal feature tensor data; A policy learning unit, which is used to combine the causal feature tensor data with business data into value state data, and output policy data based on the reinforcement learning framework according to the value state data; A component update unit, which is used to generate component change instructions according to the policy data, compile the component change instructions into executable micro-contracts and hot-replace the mall function components in the secure sandbox environment, collect business feedback data during the preset gray-scale verification period, and send the business feedback data to the event data generation unit and the policy learning unit respectively to achieve cyclic update.

2. The system according to claim 1, wherein The event data generation unit includes a kernel probe module and a data preprocessing module. The kernel probe module collects system call information and network communication information of the merchant operation environment through the eBPF mechanism, and the data preprocessing module formats the system call information and the network communication information into key-value records and outputs the atomic event data.

3. The system according to claim 2, wherein The event data generation unit further includes an optical reserve mapping module. The optical reserve mapping module performs non-linear mapping on the atomic event data by using wavelength division multiplexing to generate an embedding vector, and inputs the embedding vector into the diffusion probability generation model.

4. The system according to claim 3, characterized in that, The diffusion probability generation model is a denoising diffusion probability model, which uses a multi-scale convolutional network to complete forward perturbation and backward reconstruction, and takes the embedding vector and the causal structure as conditional inputs.

5. The system according to claim 3, wherein The incremental causal discovery algorithm includes an edge addition stage and an edge deletion stage. In the edge addition stage, edges are added between candidate node pairs according to the Bayesian information criterion, and in the edge deletion stage, edges that do not meet the set criteria are removed according to the Bayesian information criterion.

6. The system according to claim 1, wherein The policy learning unit includes an execution network set on a neuromorphic processor and an evaluation network set on a graphics processor. The execution network outputs policy data in the form of pulses, and the evaluation network calculates the state value according to the value state data and backpropagates the temporal difference error.

7. The system according to claim 6, characterized in that, The policy learning unit further includes a weight adjustment module. The weight adjustment module updates the reward weight vector according to the pulse density of the execution network to balance the profit index, inventory index and promotion cost index.

8. The system according to claim 1, wherein The component update unit includes a micro-contract compilation module, and the micro-contract compilation module converts the component change instructions into WebAssembly micro-contracts.

9. The system according to claim 8, wherein The component update unit further includes a verification module. The verification module generates a zero-knowledge proof of the WebAssembly micro-contract and records the zero-knowledge proof on the blockchain side chain.

10. The system according to claim 1, wherein It also includes a business data interface unit, and the business data interface unit obtains inventory information, price information and promotion information and provides the business data to the policy learning unit.

Images