clbigdata (chenlong)

如何开发 solana 移动客户端

clbigdata — Thu, 26 Dec 2024 23:04:44 +0800

下面我将展示如何搭建一个连接到 Solana 本地测试网的移动客户端，并实现查看账户余额和发送交易的功能。我们将使用 React Native 和 Expo 来进行开发。好的，下面我将展示如何搭建一个连接到 Solana 本地测试网的移动客户端，并实现查看账户余额和发送交易的功能。我们将使用 React Native 和 Expo 来进行开发。

1. 设置开发环境

1.1 安装 Node.js 和 npm

确保你已经安装了 Node.js 和 npm，可以从 Node.js 官网下载并安装它们。

1.2 安装 Expo CLI

Expo CLI 是一个强大的工具，可以帮助你快速创建和管理 React Native 项目。

npm install -g expo-cli

1.3 创建新的 React Native 项目

使用 Expo CLI 创建一个新的 React Native 项目：

expo init SolanaMobileApp
cd SolanaMobileApp

在创建项目时，选择 "blank" 模板。

1.4 启动开发服务器

运行以下命令启动开发服务器：

expo start

或者下边三个命令随便选一个启动，但前提都是，本地已经安装了 android 或者 ios 的开发环境

- npm run android
- npm run ios
- npm run web

这将启动一个开发服务器，并在浏览器中打开一个控制面板。你可以使用 Expo Go 应用在手机上扫描 QR 码来预览应用。

2. 安装 Solana Web3.js 库

在项目目录中安装 Solana Web3.js 库：

npm install @solana/web3.js

3. 启动 Solana 本地测试网

使用 Solana CLI 启动本地测试验证器：

solana-test-validator

4. 编写代码实现查看余额和发送交易的功能

4.1 修改 App.js

打开 App.js 文件，并将其内容替换为以下代码：

import React, { useState } from 'react';
import { StyleSheet, Text, View, TextInput, Button, Alert } from 'react-native';
import { Connection, PublicKey, clusterApiUrl, LAMPORTS_PER_SOL, Keypair, Transaction, SystemProgram } from '@solana/web3.js';

const App = () => {
  const [publicKey, setPublicKey] = useState('');
  const [balance, setBalance] = useState(null);
  const [recipient, setRecipient] = useState('');
  const [amount, setAmount] = useState('');

  // 连接到 Solana 的本地测试网
  const connection = new Connection('http://127.0.0.1:8899');

  // 检查余额
  const handleCheckBalance = async () => {
    try {
      const pubKey = new PublicKey(publicKey);
      const balance = await connection.getBalance(pubKey);
      setBalance(balance / LAMPORTS_PER_SOL);
    } catch (error) {
      Alert.alert('Error', 'Invalid public key');
    }
  };

  // 发送交易
  const handleSendTransaction = async () => {
    try {
      // 使用你的私钥生成 Keypair
      const fromKeypair = Keypair.fromSecretKey(new Uint8Array([/* your secret key array here */]));
      const toPubkey = new PublicKey(recipient);
      const transaction = new Transaction().add(
        SystemProgram.transfer({
          fromPubkey: fromKeypair.publicKey,
          toPubkey: toPubkey,
          lamports: parseFloat(amount) * LAMPORTS_PER_SOL,
        })
      );

      const signature = await connection.sendTransaction(transaction, [fromKeypair]);
      await connection.confirmTransaction(signature);
      Alert.alert('Success', `Transaction successful with signature: ${signature}`);
    } catch (error) {
      Alert.alert('Error', 'Transaction failed');
    }
  };

  return (
    <View style={styles.container}>
      <Text style={styles.title}>Solana Mobile App</Text>
      <TextInput
        style={styles.input}
        placeholder="Enter Public Key"
        value={publicKey}
        onChangeText={setPublicKey}
      />
      <Button title="Check Balance" onPress={handleCheckBalance} />
      {balance !== null && <Text>Balance: {balance} SOL</Text>}
      <TextInput
        style={styles.input}
        placeholder="Recipient Public Key"
        value={recipient}
        onChangeText={setRecipient}
      />
      <TextInput
        style={styles.input}
        placeholder="Amount (SOL)"
        keyboardType="numeric"
        value={amount}
        onChangeText={setAmount}
      />
      <Button title="Send Transaction" onPress={handleSendTransaction} />
    </View>
  );
};

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: '#fff',
    alignItems: 'center',
    justifyContent: 'center',
    padding: 20,
  },
  title: {
    fontSize: 24,
    marginBottom: 20,
  },
  input: {
    height: 40,
    borderColor: 'gray',
    borderWidth: 1,
    marginBottom: 12,
    padding: 10,
    width: '100%',
  },
});

export default App;

关键点解释

连接到 Solana 本地测试网：
```
const connection = new Connection('http://127.0.0.1:8899');
```
我们使用 Connection 对象连接到 Solana 的本地测试网络。

检查余额：

const balance = await connection.getBalance(pubKey);
setBalance(balance / LAMPORTS_PER_SOL);

使用 getBalance 方法获取指定公钥的余额，并转换为 SOL 单位。

发送交易：

const transaction = new Transaction().add(
 SystemProgram.transfer({
   fromPubkey: fromKeypair.publicKey,
   toPubkey: toPubkey,
   lamports: parseFloat(amount) * LAMPORTS_PER_SOL,
 })
);
const signature = await connection.sendTransaction(transaction, [fromKeypair]);
await connection.confirmTransaction(signature);

创建和发送一个简单的 SOL 转账交易，并等待确认。

5. 启动应用

确保你已经启动了开发服务器，并使用 Expo Go 应用扫描 QR 码来预览你的应用。

总结

通过上述步骤，我们搭建了一个基本的 React Native 开发环境，并编写了一个简单的 Solana 移动客户端，具备查看余额和发送交易的功能。这个示例使用了 React Native 和 Solana 的 Web3.js 库，展示了如何与 Solana 区块链进行交互。你可以根据需要扩展这个示例，添加更多功能和优化。所有的代码托管到了：https://github.com/rogers3333/SolanaMobileApp

Solana@Web3.js-2.0：新特性

clbigdata — Sat, 30 Nov 2024 16:58:13 +0800

2.0 版新增功能

Solana JavaScript SDK 2.0 版，是在使用 web3.js 开发 Solana 应用程序时，对许多痛点进行了优化。

Tree-Shakability

web3.js（1.x）API 的面向对象设计使优化编译器无法从生产构建中，“tree-shake”未使用的代码。无论您在应用程序中使用了多少 web3.js API，到目前为止，都必须将其全部打包。

在这里了解有关 tree-shaking 的更多信息：

一个 API 不能是树 shaken 的例子是 Connection 类。它有几十个方法，但因为它是一个类，你别无选择，只能将每个方法都包含在应用程序的最终包中，无论你实际使用了多少方法。

微小的 JavaScript 捆绑包可能会导致部署到 Cloudflare 或 AWS Lambda 等云计算提供商时出现问题。由于下载和 JavaScript 解析时间较长，它们还会影响 Web 应用程序的启动性能。

2.0 版本是完全树抖动的，并将通过构建时检查强制执行。优化编译器现在可以消除应用程序不使用的库部分。

新库本身由@solana组织下的几个较小的模块化包组成，包括：

@solana/accounts：用于获取和解码账户
@solana/codecs：用于从一组原语中编写数据（反）序列化器或构建自定义数据（反）序列化器
@solana/errors：用于识别和细化@solana命名空间中抛出的编码错误
@solana/rpc：用于发送 RPC 请求
@solana/rpc-subscriptions：用于订阅 RPC 通知
@solana/signers：用于构建消息和/或交易签名者对象
@solana/sysvars：用于获取和解码 sysvar 帐户
@solana/transaction-messages：用于构建和转换 Solana 交易消息对象
@solana/transactions：用于编译和签署交易以提交给网络
还有更多！

其中一些包本身由较小的包组成。例如，由（针对核心 JSON RPC 规范类型）、（针对 Solana 特定的 RPC 方法）、（针对默认 HTTP 传输）等@solana/rpc组成。@solana/rpc-spec@solana/rpc-api@solana/rpc-transport-http

开发人员可以使用主库（）中的默认配置@solana/web3.js@next，或者导入任何需要通过组合进行定制的子包。

可组合内部构件

根据您的用例和对某些应用程序行为的容忍度，您可能希望将您的应用程序配置为与其他开发人员进行不同的权衡。web3.js（1.x）API 对所有开发人员强加了一套严格的通用默认设置，其中一些是不可能改变的。

到目前为止，无法自定义 web3.js 一直是令人十分伤心的原因：

Mango 团队希望定制交易确认策略，但所有这些功能都隐藏在 confirmTransaction 后面——一种静态的 Connection 方法。这是 GitHub 上 confirmTransaction 的代码。

Solana 开发人员'mPaella'希望我们在 RPC 中添加一个功能，在主 URL 失败的情况下，该功能将故障转移到一组备份 URL。

Solana 开发人员“epicface”希望在 RPC 传输中为自动时间窗口批处理提供一流的支持。这是他们的拉取请求。

许多人表示需要为失败的请求或事务定制重试逻辑。这是来自“dafyddd”的 pull 请求和来自“abrkn”的另一个 pull 请求，它们试图修改重试逻辑以适应各自的用例。

2.0 版本暴露了更多的内部内容，特别是在与 RPC 通信的情况下，并允许有意愿的开发人员从默认实现中组合新的实现，这些实现体现了几乎无限的自定义数组。

组成 web3.js 的各个模块以默认配置组装，让人联想到作为 npm 包@solana一部分的遗留库/web3.js@next，但那些希望以不同配置组装它们的人可以这样做。

通用类型在许多地方提供，允许您指定新的功能，通过组合和超类型对每个 API 进行扩展，并鼓励您创建自己的更高层次的固执己见的抽象。

事实上，我们希望你这样做，并将其中一些开源，供其他有类似需求的人使用。

现代 JavaScript；零依赖

现代 JavaScript 功能的进步为加密应用程序的开发人员提供了机会，例如使用本机 Ed25519 密钥并将大值表示为本机 bigint 的能力。

Web 孵化器社区小组主张在 Web Crypto API 中添加 Ed25519 支持，并且大多数现代 JavaScript 运行时都已获得支持。

引擎对 bigint 值的支持也变得司空见惯。JavaScript 中较旧的数字基元的最大值为 2^53-1，而 Rust 的 u64 可以表示高达 2^64 的值。

2.0 版本消除了 Ed25519 密码学、大量 polyfills 等的用户空间实现，转而支持自定义实现或使用原生 JavaScript 功能，从而减小了库的大小。它不依赖于第三方。

功能架构

web3.js（1.x）的面向对象、基于类的架构导致了不必要的包膨胀。你的应用程序别无选择，只能捆绑一个类的所有功能和依赖关系，无论你在运行时实际使用了多少方法。

基于类的架构也给触发双包危险的开发人员带来了独特的风险。这描述了如果你同时为 CommonJS 和 ES 模块构建，你可能会遇到的情况。当依赖树中存在同一类的两个副本时，就会出现这种情况，导致 instanceof 等检查失败。这引入了加重和难以调试的问题。

阅读更多关于双包装危险的信息：

NodeJS：双包危险

2.0 版本没有实现任何类（SolanaError 类除外），并在函数边界实现了尽可能薄的接口。

统计数据

2.0 版和旧版 1.x 之间的统计对比。

	1.x (Legacy)	2.0	+/- %
Total minified size of library	81 KB	57.5 KB	-29%
Total minified size of library (when runtime supports Ed25519)	81 KB	53 KB	-33%
Bundled size of a web application that executes a transfer of lamports	111 KB	23.9 KB	-78%
Bundled size of a web application that executes a transfer of lamports (when runtime supports Ed25519)	111 KB	18.2 KB	-83%
Performance of key generation, signing, and verifying signatures (Brave with Experimental API flag)	700 ops/s	7000 ops/s	+900%
First-load size for Solana Explorer	311 KB	228 KB	-26%

重新设计的库在很大程度上通过使用现代 JavaScript API 实现了这些加速和捆绑包大小的减少。

为了验证我们的工作，我们在 Solana Explorer 的主页上用新的 2.0 库替换了旧的 1.x 库。在不删除任何功能的情况下，首次加载包的总大小下降了 26%。如果你想深入了解，这里有一个 Callum McIntyre 的 X 线程。

2.0 版 API 概览

以下是如何使用新库与 RPC 交互、配置网络传输、使用 Ed25519 密钥以及序列化数据的概述。

RPC

2.0 版附带了 JSON RPC 规范的实现和Solana JSON RPC的类型规范。

负责管理与 RPC 通信的主要包是@solana/rpc。但是，此包利用更细粒度的包将 RPC 逻辑分解为更小的部分。即，这些包是：

@solana/rpc：包含与发送 Solana RPC 调用相关的所有逻辑。
@solana/rpc-api：使用类型描述所有 Solana RPC 方法。
@solana/rpc-transport-http：提供使用 HTTP 请求的 RPC 传输的具体实现。
@solana/rpc-spec：定义用于发送 RPC 请求的 JSON RPC 规范。
@solana/rpc-spec-types@solana/rpc：和两者使用的共享 JSON RPC 规范类型和帮助程序@solana/rpc-subscriptions（在下一节中描述）。
@solana/rpc-types@solana/rpc：和使用的共享 Solana RPC 类型和帮助程序@solana/rpc-subscriptions。

主@solana/web3.js包重新导出@solana/rpc包，因此，接下来我们将直接从库中导入 RPC 类型和函数。

例子

自己先创建一个前端项目，然后引入相关的依赖

npm install --save @solana/web3.js@next

所有的代码示例托管到了，github

发送一个请求

createSolanaRpc函数使用应满足大多数用例的默认 HTTP 传输与 RPC 服务器通信。您可以提供自己的传输或包装现有的传输，以您认为合适的任何方式与 RPC 服务器通信。在下面的示例中，我们显式创建了一个传输，并使用它通过 createSolanaRpcFromTransport 函数创建一个新的 RPC 客户端。

import { createSolanaRpcFromTransport, createDefaultRpcTransport } from '@solana/web3.js';

// Create an HTTP transport or any custom transport of your choice.
const transport = createDefaultRpcTransport({ url: 'https://api.devnet.solana.com' });

// Create an RPC client using that transport.
const rpc = createSolanaRpcFromTransport(transport);
//    ^? Rpc<SolanaRpcApi>

// Send a request.
const slot = await rpc.getSlot().send();

点击按钮弹出如下信息

自定义传输可以实现专门的功能，如协调多个传输、实现重试等。让我们来看一些具体的例子。

轮询

“轮询”传输是一种按顺序将请求分发到端点列表的传输。

官方给出的 demo

import { createDefaultRpcTransport, createSolanaRpcFromTransport, type RpcTransport } from '@solana/web3.js';

// Create an HTTP transport for each RPC server.
const transports = [
    createDefaultRpcTransport({ url: 'https://mainnet-beta.my-server-1.com' }),
    createDefaultRpcTransport({ url: 'https://mainnet-beta.my-server-2.com' }),
    createDefaultRpcTransport({ url: 'https://mainnet-beta.my-server-3.com' }),
];

// Set up the round-robin transport.
let nextTransport = 0;
async function roundRobinTransport<TResponse>(...args: Parameters<RpcTransport>): Promise<TResponse> {
    const transport = transports[nextTransport];
    nextTransport = (nextTransport + 1) % transports.length;
    return await transport(...args);
}

// Create an RPC client using the round-robin transport.
const rpc = createSolanaRpcFromTransport(roundRobinTransport);

我们改造一下

// 创建多个RPC客户端用于轮询（这里简化为创建两个示例）
  async createRpcClients() {
    const rpc1 = createSolanaRpc('http://127.0.0.1:8899');
    const rpc2 = createSolanaRpc('http://127.0.0.1:8898');
    this.rpcClients.push(rpc1, rpc2);
  },
  async roundRobinSlotRequest() {
    if (this.rpcClients.length === 0) {
      await this.createRpcClients();
    }
    try {
      const currentRpc = this.rpcClients[this.currentRpcIndex];
      this.slot = await currentRpc.getSlot().send();
      alert(`通过轮询获取到的slot信息为: ${this.slot}`);
      // 更新当前使用的RPC客户端索引，实现轮询效果
      this.currentRpcIndex = (this.currentRpcIndex + 1) % this.rpcClients.length;
    } catch (error) {
      alert(`轮询获取slot信息时出错: ${error}`);
    }
  }
},

通过多次点击按钮弹，会分别弹出如下信息

分片

分片传输是一种分布式传输，它根据请求本身的某些信息向特定服务器发送请求。下面是一个根据方法名称向不同服务器发送请求的示例：

官方的 demo

import { createDefaultRpcTransport, createSolanaRpcFromTransport, type RpcTransport } from '@solana/web3.js';

// Create multiple transports.
const transportA = createDefaultRpcTransport({ url: 'https://mainnet-beta.my-server-1.com' });
const transportB = createDefaultRpcTransport({ url: 'https://mainnet-beta.my-server-2.com' });
const transportC = createDefaultRpcTransport({ url: 'https://mainnet-beta.my-server-3.com' });
const transportD = createDefaultRpcTransport({ url: 'https://mainnet-beta.my-server-4.com' });

// Function to determine which shard to use based on the request method.
function selectShard(method: string): RpcTransport {
    switch (method) {
        case 'getAccountInfo':
        case 'getBalance':
            return transportA;
        case 'getLatestBlockhash':
        case 'getTransaction':
            return transportB;
        case 'sendTransaction':
            return transportC;
        default:
            return transportD;
    }
}

// Create a transport that selects the correct transport given the request method name.
async function shardingTransport<TResponse>(...args: Parameters<RpcTransport>): Promise<TResponse> {
    const payload = args[0].payload as { method: string };
    const selectedTransport = selectShard(payload.method);
    return (await selectedTransport(...args)) as TResponse;
}

// Create an RPC client using the sharding transport.
const rpc = createSolanaRpcFromTransport(shardingTransport);

改造后

// 创建多个传输对象（用于sharding）
    createTransports() {
      this.transportA = createDefaultRpcTransport({url: 'https://mainnet-beta.my-server-1.com'});
      this.transportB = createDefaultRpcTransport({url: 'https://mainnet-beta.my-server-2.com'});
      this.transportC = createDefaultRpcTransport({url: 'https://mainnet-beta.my-server-3.com'});
      this.transportD = createDefaultRpcTransport({url: 'https://mainnet-beta.my-server-4.com'});
    },
    // 根据请求方法选择分片（用于sharding）
    selectShard(method) {
      switch (method) {
        case 'getAccountInfo':
        case 'getBalance':
          return this.transportA;
        case 'getLatestBlockhash':
        case 'getTransaction':
          return this.transportB;
        case 'sendTransaction':
          return this.transportC;
        default:
          return this.transportD;
      }
    },
    // 实现分片传输逻辑（用于sharding）
    async shardingTransport(args) {
      const payload = args[0].payload;
      const method = payload.method;
      const selectedTransport = this.selectShard(method);

      return await selectedTransport.apply(null, args);
    },
    // 创建RPC客户端并执行sharding按钮点击操作
    async shardingButtonClick() {
      if (!this.transportA || !this.transportB || !this.transportC || !this.transportD) {
        this.createTransports();
      }
      // 创建RPC客户端
      this.rpc = createSolanaRpcFromTransport(this.shardingTransport);

      try {
        // 这里可以添加具体要执行的请求操作示例，比如获取账户信息
        const accountInfo = await this.rpc.getAccountInfo('your_account_address').send();
        alert(`获取到的账户信息为: ${accountInfo}`);
      } catch (error) {
        alert(`执行sharding操作时出错: ${error}`);
      }
    },
  },

这就是 solana web3.js sdk 2.0 其中一部分新特性的演示。

详情请参考

https://solana-labs.github.io/solana-web3.js/#a-tour-of-the-version-20-api

文中代码托管到了 github

https://github.com/rogers3333/solana-web3.js-learn

ZK Compression 简单介绍以及入门案例

clbigdata — Sat, 30 Nov 2024 14:24:34 +0800

Web3 与 ZK（零知识证明）背景
- 零知识证明（ZK）是 Web3 领域中一项关键的加密技术，它允许一方（证明者）向另一方（验证者）证实某项信息的真实性，同时不泄露其他任何额外信息。这项技术对提高数据安全性和保护用户隐私至关重要。
  在区块链应用如金融交易、身份认证中，零知识证明能够增强系统的隐私和安全性。例如，在注重隐私的区块链平台上，用户可以使用该技术证明自己有足够的余额进行转账，而无需透露具体的账户金额，从而保护了财务隐私并降低了安全风险。
  此外，零知识证明也被应用于数字身份验证、投票系统等领域，帮助个人和组织在保持隐私的同时参与在线活动，并确保操作的有效性和合法性。随着 Web3 的发展，零知识证明正成为创建更加开放透明且高度安全互联网基础设施的重要组成部分。
Solana 概述与数据处理特点
- Solana 是一个高性能的区块链平台，以其高吞吐量和低延迟而闻名。在 Solana 的生态系统中，数据处理的效率对于整个网络的性能至关重要。它需要处理大量的交易数据、智能合约状态等信息。
Solana 中 ZK Compression 的含义
- 在 Solana 中，ZK Compression（零知识证明压缩）同样是针对零知识证明相关数据的压缩机制。零知识证明在 Solana 中有多种应用场景，例如隐私保护的交易验证、去中心化身份验证等。
- 当使用零知识证明技术时，会产生证明数据和验证数据等内容。这些数据可能包含复杂的密码学计算结果和大量的数学结构，ZK Compression 就是要对这些数据进行压缩，以适应 Solana 的高性能要求。
Solana 中 ZK Compression 的重要性
- 提升网络效率：
  - Solana 的网络性能优势部分依赖于数据的高效处理和传输。通过压缩零知识证明数据，可以减少数据在网络节点之间传输所需的带宽和时间。在高并发交易场景下，这有助于维持 Solana 的低延迟特性，使得交易能够更快地被验证和确认。
  - 当在分布式的 Web3 网络中传输零知识证明相关的数据时，例如从一个节点传输到另一个节点或者从用户端传输到区块链节点，压缩后的数据可以大大减少网络带宽的占用，提高数据传输效率。这对于实时性要求较高的应用，如快速交易确认等场景非常重要。
- 优化存储成本：
  - 区块链存储需要考虑成本和空间利用效率。压缩后的零知识证明数据占用更少的存储空间，这对于 Solana 网络节点的存储资源管理非常重要。可以在有限的存储容量内存储更多的交易记录和相关证明，提高网络的整体存储效率。区块链的存储空间是有限且宝贵的。在 Web3 应用中，如去中心化金融（DeFi）、非同质化代币（NFT）市场等，大量的交易和操作需要记录。如果零知识证明的数据不进行压缩，会占用过多的区块链存储空间，导致存储成本增加并且降低整个系统的可扩展性。通过压缩，可以在相同的存储容量下记录更多的有效信息
- 增强隐私保护能力：
  - 在隐私敏感的应用场景中，如隐私保护的去中心化金融（DeFi）交易，ZK Compression 有助于进一步隐藏交易细节。较小的数据包在存储和传输过程中更难被分析和破解，从而加强了用户隐私保护。除了效率方面的好处，压缩零知识证明数据也有助于进一步保护隐私。较小的数据包在传输过程中被拦截或分析的风险相对较低，并且可以通过巧妙的压缩算法设计，将一些敏感信息更加隐蔽地存储，从而增强整个 Web3 系统的隐私保护能力
Solana 中 ZK Compression 的实现方式
- 协议层集成：
  - Solana 可能在其协议层设计了特定的机制来处理零知识证明压缩。这可能涉及到在交易打包和验证阶段，对包含零知识证明的数据进行自动压缩。例如，在节点接收交易时，对带有隐私保护需求的交易中的零知识证明部分进行压缩处理，然后再存储和转发。
- 与加密库协作：
  - Solana 利用现有的加密库和压缩技术来实现 ZK Compression。开发人员可能会使用诸如 Ristretto、Bulletproofs 等零知识证明库，并结合高效的压缩算法（如 zstd 等）来对证明数据进行压缩。在具体实现中，可能会在智能合约的编译阶段或者运行时，对生成的零知识证明进行压缩操作。

6.Solana 中 ZK Compression 的挑战与应对策略

兼容性问题：

挑战：Solana 生态系统中的多种应用和工具（如钱包、DApps）需要处理压缩后的零知识证明数据，这要求 ZK Compression 机制具有广泛的兼容性。
应对策略：通过制定统一标准和接口，并提供详细的开发文档和指南来帮助开发者。同时，进行广泛的测试以确保主流应用能够适应这种压缩机制。
性能权衡与优化：
挑战：虽然压缩有诸多好处，但也可能增加计算开销，影响交易验证时间和网络性能。
应对策略：研究高效的压缩算法，减少性能损耗。可以通过硬件加速或采用自适应压缩技术来提高效率，根据数据类型选择最佳压缩方法。
实现方式：
密码学算法 + 传统压缩：先用密码学手段对零知识证明数据进行预处理，再利用常规压缩算法（如 gzip）进行压缩。
同态加密压缩：对于支持同态加密的应用场景，在保持数据加密状态的同时对其进行压缩，从而在不泄露信息的前提下减小数据体积。
Solana 中 ZK Compression 的应用

** **Solana 中 ZK Compression 包含两个实践

客户端开发
链上程序开发

接下来从客户端开发给出简单的入门案例

ZK Compression RPC API是客户端和链上程序之间的粘合剂。它扩展了 Solana 的默认JSON RPC API,并添加了用于与 ZK Compression 状态交互的端点。要查看受支持的端点的完整列表，请访问JSON RPC 方法部分。

官网给出了 TypeScript 和 Rust SDK 用于与 ZK Compression 交互的教程

语言	软件开发工具包	描述
TypeScript	@lightprotocol/stateless.js	SDK to interact with compression programs via the ZK Compression RPC API
TypeScript	@lightprotocol/compressed-token	SDK to interact with the compressed token program
Rust	light-sdk	Rust client

接下来我们创建一个项目命名为 zk-compression-learn，并托管到 github。

官方给了两种安装方式

Package Manager	Command
NPM	Copy `plain npm install --save \ @lightprotocol/stateless.js \ @lightprotocol/compressed-token \ @solana/web3.js \ @coral-xyz/anchor \ @lightprotocol/zk-compression-cli`
Yarn	Copy `plain yarn add \ @lightprotocol/stateless.js \ @lightprotocol/compressed-token \ @solana/web3.js \ @coral-xyz/anchor \ @lightprotocol/zk-compression-cli`

在启动之前，我们要先搭建一下测试环境，启动一个测试节点，主要教程参考下边的连接。

https://github.com/helius-labs/photon

我们先打开两个命令行窗口

第一步：先启动 solana 的测试环境，输入如下命令

solana-test-validator

第二步：启动photon，输入如下命令

photon

这样就启动了 solana 的本地测试环境，当然了，还有个更省事的，一键启动所有的测试环境

light test-validator

通过light config --get 命令，可以看到当前启动的端口情况

────────────── ───────────────────── 
Solana RPC URL http://127.0.0.1:8899 
Indexer URL    http://127.0.0.1:8784 
Prover URL     http://127.0.0.1:3001

接下来，我门用官方给出的例子来对关键点几个接口进行测试，拷贝下来创建一个新项目，就 OK 了

https://github.com/Lightprotocol/example-web-client

然后进入到项目安装 zk compression 的依赖，我们这里采用第一种 NPM 的方式

npm install --save \
    @lightprotocol/stateless.js \
    @lightprotocol/compressed-token \
    @solana/web3.js \
    @coral-xyz/anchor \
    @lightprotocol/zk-compression-cli

出现如下命令表示安装成功

进入项目，结构如图所示

接下来，我们先来第一个案例，用于与本地的 dev 环境进行交互，代码如下


const TestConnectionButton: FC = () => {
  const onClick = useCallback(async () => {
    try {
      let slot = await connectionForTest.getSlot();
      console.log("=====" + slot);

      let health = await connectionForTest.getIndexerHealth(slot);
      console.log("+++++"+health);
      // "Ok"
    } catch (error) {
      console.error("Error testing the connection:", error);
    }
  }, []);

  return (
      <button
          style={{
            fontSize: "1rem",
            padding: "1rem",
            backgroundColor: "#ff0000",
            cursor: "pointer",
          }}
          onClick={onClick}
          disabled={!connectionForTest}
      >
        测试连接
      </button>
  );
}

启动项目，打开浏览器进行访问

会发现多了一个按钮，我们打开 F12，进入浏览器开发者模式，点击浏览器的控制台，然后再次点击我们新加入的按钮。

出现如下内容，表示连接成功

接下来，进行第二个案例。这个案例就是进行一系列交易操作，代码如下。


const PerformTokenOperationsButton: FC = () => {
  const { publicKey, sendTransaction } = useWallet();

  const onClick = useCallback(async () => {
    if (!publicKey) throw new WalletNotConnectedError();

    try {
      // Airdrop lamports to pay fees
      await confirmTx(
          connectionForTest,
          await connectionForTest.requestAirdrop(payer.publicKey, 10e9)
      );

      await confirmTx(
          connectionForTest,
          await connectionForTest.requestAirdrop(tokenRecipient.publicKey, 1e6)
      );

      // Create a compressed token mint
      const { mint, transactionSignature } = await createMint(
          connectionForTest,
          payer,
          payer.publicKey,
          9 // Number of decimals
      );

      console.log(`create-mint  success! txId: ${transactionSignature}`);

      // Mint compressed tokens to the payer's account
      const mintToTxId = await mintTo(
          connectionForTest,
          payer,
          mint,
          payer.publicKey, // Destination
          payer,
          1e9 // Amount
      );

      console.log(`Minted 1e9 tokens to ${payer.publicKey} was a success!`);
      console.log(`txId: ${mintToTxId}`);

      // Transfer compressed tokens
      // @ts-ignore
      const transferTxId = await transfer(
          connectionForTest,
          payer,
          mint,
          7e8, // Amount
          payer, // Owner
          tokenRecipient.publicKey // To address
      );

      console.log(`Transfer of 7e8 ${mint} to ${tokenRecipient.publicKey} was a success!`);
      console.log(`txId: ${transferTxId}`);
    } catch (error) {
      console.error("Error performing token operations:", error);
    }
  }, [publicKey, sendTransaction]);

  return (
      <button
          style={{
            fontSize: "1rem",
            padding: "1rem",
            backgroundColor: "#0066ff",
            cursor: "pointer",
          }}
          onClick={onClick}
          disabled={!publicKey}
      >
        交易操作
      </button>
  );
}

然后会生成一个新的按钮

再点击这个按钮之前，我们现连接钱包，也就是项目的第一个按钮，连接钱包后，点击交易操作按钮。会生成一系列的交易信息

至此，zk compression 的介绍以及简单入门就结束啦。

详细代码请参考链接：https://github.com/rogers3333/zk-compression-learn