## 5 Spatio-Temporal Big Data Collaborative Storage Mechanism
### Aggregation Proof Protocol  
When there are multiple clients initiating queries, the smart contract aggregates the proofs and aggregates them into a short proof. Further, when the data verifier queries again, if the queried set belongs to a subset of the already aggregated proofs, the off-chain database can send the aggregated proofs disaggregated directly to the clients, thus avoiding the need to compute the proofs again. The aggregation proof protocol is divided into two parts, the on-chain and off-chain executions, the on-chain execution aggregates \(S_{I},S_{I}\) into \(S_{K}\), and the off-chain aggregates \(\Lambda_{I}\) and \(\Lambda_{J}\) into \(\Lambda_{K}\). The data verifier receives \(\pi_{K}=(S_{K},A_{K})\) and can verify the data. Aggregation proof: input signature \(\delta_{n}\), two query outputs \((I,V_{I},\pi_{I})\), \((J,V_{I},\pi_{I})\), subscript indexes \(I\) and \(J\) to be aggregated, aggregated values \(V_{I}\) and \(V_{I}\), proofs to be aggregated \(\pi_{I}\) and \(\pi_{J}\). The protocol aggregates two proofs into one proof \(\pi_{K}\), where \(K=I\cup J\). The specific formula is as follows:  
\[S_{K}\leftarrow\mathit{Shamir}Trick(S_{I},S_{I},\prod_{i\in I}e_{i},\prod_{i \in I}e_{i}) \tag{16}\]  
\[A_{K}\gets VC.Agg\big{(}(S_{I},S_{J}),(I,V_{I},A_{I}),(I,V_{J},A_{J}) \big{)} \tag{17}\]  
Finally, return \(\pi_{K}=(S_{K},\Lambda_{K})\). The algorithm that the aggregation proof protocol executes in the smart contract is as Algorithm 2:```
1:\(\text{auxiliary verification information }S_{I},S_{I},\) index set \(I\), \(J\), \(\{e_{i}\}_{i\in I\cup J}\), proof \(V_{I},V_{J}\)
2:\(\text{auxiliary verification information }S_{I\cup J}\), aggregation proof \(A_{I\cup J}\)
3:\(product_{1}\gets 1\); \(product_{2}\gets 1\)
4:for each element \(i\) in \(I\)do
5:\(product_{1}\gets product_{1}\cdot e_{i}\)
6:endfor
7:for each element \(j\) in \(J\)do
8:\(product_{2}\gets product_{2}\cdot j\)
9:endfor
10:\(S_{k}\leftarrow\text{ShamirTrick}(S_{I},S_{J},product_{1},product_{2})\)
11:for each element \(j\) in \(J\)do
12:\(\phi_{j}\gets S_{j}^{-1/e_{j}}\)
13:endfor
14:for each element \(i\) in \(I\)do
15:\(\psi_{i}\gets S_{i}^{1/e_{i}}\)
16:endfor
17:\(S_{k}\leftarrow\text{ShamirTrick}(\frac{\Lambda_{I}}{\Pi_{j\in I}\psi_{j}^{ \gamma_{j}}},\frac{\Lambda_{I}}{\Pi_{i\in I}\psi_{i}^{\gamma_{i}}},product_{1 },product_{2})\);
18:return\(S_{K}\)
```

**Algorithm 2** Aggregation proof algorithms

### Security Analysis

We assess the correctness and security of the proposed scheme under the conditions that the protocol presupposes that the processes are consistent, the sender is correct, and the network is in a stable \"good\" state. Specifically, we explore the security performance of the whole scheme without any failures. We outline the security parameters of the proposed scheme. Intuitively, we necessitate that in a single query by a data verifier, a malicious off-chain storage server is unable to convince the data verifier that the forged data is true. To establish this, we permit the attacker A freely choose the system's history. From a starting empty state, progressively construct the history records, each consisting of updates (additions, deletions, modifications). The data verifier queries the summary \(\delta\) generated based on the history and the suggestions of the adversary A while getting the corresponding data results. **Theorem 1** (correctness). : _If the data owner and the off-chain storage server honestly execute our proposed scheme algorithm and aggregate proof protocol, the verification result obtained by the data verifier will always be a correct value._

**Proof.