Создание децентрализованного шифрования с @mysten/seal: Руководство для разработчиков

Конфиденциальность становится общественной инфраструктурой. В 2025 году разработчикам нужны инструменты, которые сделают шифрование таким же простым, как хранение данных. Seal от Mysten Labs предоставляет именно это — децентрализованное управление секретами с контролем доступа в блокчейне. Это руководство научит вас создавать безопасные Web3-приложения, используя шифрование на основе идентификаторов, пороговую безопасность и программируемые политики доступа.

---

Введение: Почему Seal важен для Web3

Традиционные облачные приложения полагаются на централизованные системы управления ключами, где один провайдер контролирует доступ к зашифрованным данным. Хотя это удобно, это создает опасные единые точки отказа. Если провайдер скомпрометирован, отключается или решает ограничить доступ, ваши данные становятся недоступными или уязвимыми.

Seal полностью меняет эту парадигму. Разработанный Mysten Labs для блокчейна Sui, Seal — это децентрализованный сервис управления секретами (DSM), который обеспечивает:

• Шифрование на основе идентификаторов, при котором контент защищается до того, как покинет вашу среду
• Пороговое шифрование, которое распределяет доступ к ключам между несколькими независимыми узлами
• Контроль доступа в блокчейне с временными блокировками, токен-гейтингом и настраиваемой логикой авторизации
• Независимый от хранилища дизайн, который работает с Walrus, IPFS или любым другим решением для хранения

Независимо от того, создаете ли вы безопасные приложения для обмена сообщениями, платформы с ограниченным доступом к контенту или переводы активов с временной блокировкой, Seal предоставляет необходимые криптографические примитивы и инфраструктуру контроля доступа.

---

Начало работы

Предварительные требования

Прежде чем приступить к работе, убедитесь, что у вас есть:

• Установленный Node.js 18+
• Базовое знакомство с TypeScript/JavaScript
• Кошелек Sui для тестирования (например, Sui Wallet)
• Понимание концепций блокчейна

Установка

Установите SDK Seal через npm:

npm install @mysten/seal

Вам также понадобится Sui SDK для взаимодействия с блокчейном:

npm install @mysten/sui

Настройка проекта

Создайте новый проект и инициализируйте его:

mkdir seal-tutorial
cd seal-tutorial
npm init -y
npm install @mysten/seal @mysten/sui typescript @types/node

Создайте простую конфигурацию TypeScript:

// tsconfig.json
{
  "compilerOptions": {
    "target": "ES2020",
    "module": "commonjs",
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true,
    "forceConsistentCasingInFileNames": true
  }
}

---

Основные концепции: Как работает Seal

Прежде чем писать код, давайте разберемся в архитектуре Seal:

1. Шифрование на основе идентификаторов (IBE)

В отличие от традиционного шифрования, где вы шифруете данные с помощью публичного ключа, IBE позволяет шифровать данные для идентификатора (например, адреса электронной почты или адреса Sui). Получатель может расшифровать данные только в том случае, если он может доказать, что контролирует этот идентификатор.

2. Пороговое шифрование

Вместо того чтобы доверять одному серверу ключей, Seal использует t-из-n пороговые схемы. Вы можете настроить 3 из 5 серверов ключей, что означает, что любые 3 сервера могут сотрудничать для предоставления ключей дешифрования, но 2 или меньше не могут.

3. Контроль доступа в блокчейне

Политики доступа обеспечиваются смарт-контрактами Sui. Прежде чем сервер ключей предоставит ключи дешифрования, он проверяет, соответствует ли запрашивающий требованиям политики в блокчейне (владение токенами, временные ограничения и т. д.).

4. Сеть серверов ключей

Распределенные серверы ключей проверяют политики доступа и генерируют ключи дешифрования. Эти серверы управляются различными сторонами для обеспечения отсутствия единой точки контроля.

---

Базовая реализация: Ваше первое приложение Seal

Давайте создадим простое приложение, которое шифрует конфиденциальные данные и контролирует доступ через политики блокчейна Sui.

Шаг 1: Инициализация клиента Seal

// src/seal-client.ts
import { SealClient } from "@mysten/seal";
import { SuiClient } from "@mysten/sui/client";

export async function createSealClient() {
  // Initialize Sui client for testnet
  const suiClient = new SuiClient({
    url: "https://fullnode.testnet.sui.io",
  });

  // Configure Seal client with testnet key servers
  const sealClient = new SealClient({
    suiClient,
    keyServers: [
      "https://keyserver1.seal-testnet.com",
      "https://keyserver2.seal-testnet.com",
      "https://keyserver3.seal-testnet.com",
    ],
    threshold: 2, // 2-of-3 threshold
    network: "testnet",
  });

  return { sealClient, suiClient };
}

Шаг 2: Простое шифрование/дешифрование

// src/basic-encryption.ts
import { createSealClient } from "./seal-client";

async function basicExample() {
  const { sealClient } = await createSealClient();

  // Data to encrypt
  const sensitiveData = "This is my secret message!";
  const recipientAddress =
    "0x742d35cc6d4c0c08c0f9bf3c9b2b6c64b3b4f5c6d7e8f9a0b1c2d3e4f5a6b7c8";

  try {
    // Encrypt data for a specific Sui address
    const encryptedData = await sealClient.encrypt({
      data: Buffer.from(sensitiveData, "utf-8"),
      recipientId: recipientAddress,
      // Optional: add metadata
      metadata: {
        contentType: "text/plain",
        timestamp: Date.now(),
      },
    });

    console.log("Encrypted data:", {
      ciphertext: encryptedData.ciphertext.toString("base64"),
      encryptionId: encryptedData.encryptionId,
    });

    // Later, decrypt the data (requires proper authorization)
    const decryptedData = await sealClient.decrypt({
      ciphertext: encryptedData.ciphertext,
      encryptionId: encryptedData.encryptionId,
      recipientId: recipientAddress,
    });

    console.log("Decrypted data:", decryptedData.toString("utf-8"));
  } catch (error) {
    console.error("Encryption/decryption failed:", error);
  }
}

basicExample();

---

Контроль доступа с помощью смарт-контрактов Sui

Настоящая мощь Seal заключается в программируемом контроле доступа. Давайте создадим пример шифрования с временной блокировкой, где данные могут быть расшифрованы только по истечении определенного времени.

Шаг 1: Развертывание контракта контроля доступа

Сначала нам нужен смарт-контракт Move, который определяет нашу политику доступа:

// contracts/time_lock.move
module time_lock::policy {
    use sui::clock::{Self, Clock};
    use sui::object::{Self, UID};
    use sui::tx_context::{Self, TxContext};

    public struct TimeLockPolicy has key, store {
        id: UID,
        unlock_time: u64,
        authorized_user: address,
    }

    public fun create_time_lock(
        unlock_time: u64,
        authorized_user: address,
        ctx: &mut TxContext
    ): TimeLockPolicy {
        TimeLockPolicy {
            id: object::new(ctx),
            unlock_time,
            authorized_user,
        }
    }

    public fun can_decrypt(
        policy: &TimeLockPolicy,
        user: address,
        clock: &Clock
    ): bool {
        let current_time = clock::timestamp_ms(clock);
        policy.authorized_user == user && current_time >= policy.unlock_time
    }
}

Шаг 2: Интеграция с Seal

// src/time-locked-encryption.ts
import { createSealClient } from "./seal-client";
import { TransactionBlock } from "@mysten/sui/transactions";

async function createTimeLocked() {
  const { sealClient, suiClient } = await createSealClient();

  // Create access policy on Sui
  const txb = new TransactionBlock();

  const unlockTime = Date.now() + 60000; // Unlock in 1 minute
  const authorizedUser =
    "0x742d35cc6d4c0c08c0f9bf3c9b2b6c64b3b4f5c6d7e8f9a0b1c2d3e4f5a6b7c8";

  txb.moveCall({
    target: "time_lock::policy::create_time_lock",
    arguments: [txb.pure(unlockTime), txb.pure(authorizedUser)],
  });

  // Execute transaction to create policy
  const result = await suiClient.signAndExecuteTransactionBlock({
    transactionBlock: txb,
    signer: yourKeypair, // Your Sui keypair
  });

  const policyId = result.objectChanges?.find(
    (change) => change.type === "created",
  )?.objectId;

  // Now encrypt with this policy
  const sensitiveData = "This will unlock in 1 minute!";

  const encryptedData = await sealClient.encrypt({
    data: Buffer.from(sensitiveData, "utf-8"),
    recipientId: authorizedUser,
    accessPolicy: {
      policyId,
      policyType: "time_lock",
    },
  });

  console.log("Time-locked data created. Try decrypting after 1 minute.");

  return {
    encryptedData,
    policyId,
    unlockTime,
  };
}

---

Практические примеры

Пример 1: Приложение для безопасного обмена сообщениями

// src/secure-messaging.ts
import { createSealClient } from "./seal-client";

class SecureMessenger {
  private sealClient: any;

  constructor(sealClient: any) {
    this.sealClient = sealClient;
  }

  async sendMessage(
    message: string,
    recipientAddress: string,
    senderKeypair: any,
  ) {
    const messageData = {
      content: message,
      timestamp: Date.now(),
      sender: senderKeypair.toSuiAddress(),
      messageId: crypto.randomUUID(),
    };

    const encryptedMessage = await this.sealClient.encrypt({
      data: Buffer.from(JSON.stringify(messageData), "utf-8"),
      recipientId: recipientAddress,
      metadata: {
        type: "secure_message",
        sender: senderKeypair.toSuiAddress(),
      },
    });

    // Store encrypted message on decentralized storage (Walrus)
    return this.storeOnWalrus(encryptedMessage);
  }

  async readMessage(encryptionId: string, recipientKeypair: any) {
    // Retrieve from storage
    const encryptedData = await this.retrieveFromWalrus(encryptionId);

    // Decrypt with Seal
    const decryptedData = await this.sealClient.decrypt({
      ciphertext: encryptedData.ciphertext,
      encryptionId: encryptedData.encryptionId,
      recipientId: recipientKeypair.toSuiAddress(),
    });

    return JSON.parse(decryptedData.toString("utf-8"));
  }

  private async storeOnWalrus(data: any) {
    // Integration with Walrus storage
    // This would upload the encrypted data to Walrus
    // and return the blob ID for retrieval
  }

  private async retrieveFromWalrus(blobId: string) {
    // Retrieve encrypted data from Walrus using blob ID
  }
}

Пример 2: Платформа контента с токен-гейтингом

// src/gated-content.ts
import { createSealClient } from "./seal-client";

class ContentGating {
  private sealClient: any;
  private suiClient: any;

  constructor(sealClient: any, suiClient: any) {
    this.sealClient = sealClient;
    this.suiClient = suiClient;
  }

  async createGatedContent(
    content: string,
    requiredNftCollection: string,
    creatorKeypair: any,
  ) {
    // Create NFT ownership policy
    const accessPolicy = await this.createNftPolicy(
      requiredNftCollection,
      creatorKeypair,
    );

    // Encrypt content with NFT access requirement
    const encryptedContent = await this.sealClient.encrypt({
      data: Buffer.from(content, "utf-8"),
      recipientId: "nft_holders", // Special recipient for NFT holders
      accessPolicy: {
        policyId: accessPolicy.policyId,
        policyType: "nft_ownership",
      },
    });

    return {
      contentId: encryptedContent.encryptionId,
      accessPolicy: accessPolicy.policyId,
    };
  }

  async accessGatedContent(
    contentId: string,
    userAddress: string,
    userKeypair: any,
  ) {
    // Verify NFT ownership first
    const hasAccess = await this.verifyNftOwnership(userAddress, contentId);

    if (!hasAccess) {
      throw new Error("Access denied: Required NFT not found");
    }

    // Decrypt content
    const decryptedContent = await this.sealClient.decrypt({
      encryptionId: contentId,
      recipientId: userAddress,
    });

    return decryptedContent.toString("utf-8");
  }

  private async createNftPolicy(collection: string, creator: any) {
    // Create Move contract that checks NFT ownership
    // Returns policy object ID
  }

  private async verifyNftOwnership(user: string, contentId: string) {
    // Check if user owns required NFT
    // Query Sui for NFT ownership
  }
}

Пример 3: Передача активов с временной блокировкой

// src/time-locked-transfer.ts
import { createSealClient } from "./seal-client";

async function createTimeLockTransfer(
  assetData: any,
  recipientAddress: string,
  unlockTimestamp: number,
  senderKeypair: any,
) {
  const { sealClient, suiClient } = await createSealClient();

  // Create time-lock policy on Sui
  const timeLockPolicy = await createTimeLockPolicy(
    unlockTimestamp,
    recipientAddress,
    senderKeypair,
    suiClient,
  );

  // Encrypt asset transfer data
  const transferData = {
    asset: assetData,
    recipient: recipientAddress,
    unlockTime: unlockTimestamp,
    transferId: crypto.randomUUID(),
  };

  const encryptedTransfer = await sealClient.encrypt({
    data: Buffer.from(JSON.stringify(transferData), "utf-8"),
    recipientId: recipientAddress,
    accessPolicy: {
      policyId: timeLockPolicy.policyId,
      policyType: "time_lock",
    },
  });

  console.log(`Asset locked until ${new Date(unlockTimestamp)}`);

  return {
    transferId: encryptedTransfer.encryptionId,
    unlockTime: unlockTimestamp,
    policyId: timeLockPolicy.policyId,
  };
}

async function claimTimeLockTransfer(
  transferId: string,
  recipientKeypair: any,
) {
  const { sealClient } = await createSealClient();

  try {
    const decryptedData = await sealClient.decrypt({
      encryptionId: transferId,
      recipientId: recipientKeypair.toSuiAddress(),
    });

    const transferData = JSON.parse(decryptedData.toString("utf-8"));

    // Process the asset transfer
    console.log("Asset transfer unlocked:", transferData);

    return transferData;
  } catch (error) {
    console.error("Transfer not yet unlocked or access denied:", error);
    throw error;
  }
}

---

Интеграция с децентрализованным хранилищем Walrus

Seal бесшовно работает с Walrus, децентрализованным решением для хранения данных от Sui. Вот как интегрировать оба:

// src/walrus-integration.ts
import { createSealClient } from "./seal-client";

class SealWalrusIntegration {
  private sealClient: any;
  private walrusClient: any;

  constructor(sealClient: any, walrusClient: any) {
    this.sealClient = sealClient;
    this.walrusClient = walrusClient;
  }

  async storeEncryptedData(
    data: Buffer,
    recipientAddress: string,
    accessPolicy?: any,
  ) {
    // Encrypt with Seal
    const encryptedData = await this.sealClient.encrypt({
      data,
      recipientId: recipientAddress,
      accessPolicy,
    });

    // Store encrypted data on Walrus
    const blobId = await this.walrusClient.store(encryptedData.ciphertext);

    // Return reference that includes both Seal and Walrus info
    return {
      blobId,
      encryptionId: encryptedData.encryptionId,
      accessPolicy: encryptedData.accessPolicy,
    };
  }

  async retrieveAndDecrypt(
    blobId: string,
    encryptionId: string,
    userKeypair: any,
  ) {
    // Retrieve from Walrus
    const encryptedData = await this.walrusClient.retrieve(blobId);

    // Decrypt with Seal
    const decryptedData = await this.sealClient.decrypt({
      ciphertext: encryptedData,
      encryptionId,
      recipientId: userKeypair.toSuiAddress(),
    });

    return decryptedData;
  }
}

// Usage example
async function walrusExample() {
  const { sealClient } = await createSealClient();
  const walrusClient = new WalrusClient("https://walrus-testnet.sui.io");

  const integration = new SealWalrusIntegration(sealClient, walrusClient);

  const fileData = Buffer.from("Important document content");
  const recipientAddress = "0x...";

  // Store encrypted
  const result = await integration.storeEncryptedData(
    fileData,
    recipientAddress,
  );

  console.log("Stored with Blob ID:", result.blobId);

  // Later, retrieve and decrypt
  const decrypted = await integration.retrieveAndDecrypt(
    result.blobId,
    result.encryptionId,
    recipientKeypair,
  );

  console.log("Retrieved data:", decrypted.toString());
}

---

Пороговое шифрование: Расширенная конфигурация

Для производственных приложений вам потребуется настроить пользовательское пороговое шифрование с несколькими серверами ключей:

// src/advanced-threshold.ts
import { SealClient } from "@mysten/seal";

async function setupProductionSeal() {
  // Configure with multiple independent key servers
  const keyServers = [
    "https://keyserver-1.your-org.com",
    "https://keyserver-2.partner-org.com",
    "https://keyserver-3.third-party.com",
    "https://keyserver-4.backup-provider.com",
    "https://keyserver-5.fallback.com",
  ];

  const sealClient = new SealClient({
    keyServers,
    threshold: 3, // 3-of-5 threshold
    network: "mainnet",
    // Advanced options
    retryAttempts: 3,
    timeoutMs: 10000,
    backupKeyServers: [
      "https://backup-1.emergency.com",
      "https://backup-2.emergency.com",
    ],
  });

  return sealClient;
}

async function robustEncryption() {
  const sealClient = await setupProductionSeal();

  const criticalData = "Mission critical encrypted data";

  // Encrypt with high security guarantees
  const encrypted = await sealClient.encrypt({
    data: Buffer.from(criticalData, "utf-8"),
    recipientId: "0x...",
    // Require all 5 servers for maximum security
    customThreshold: 5,
    // Add redundancy
    redundancy: 2,
    accessPolicy: {
      // Multi-factor requirements
      requirements: ["nft_ownership", "time_lock", "multisig_approval"],
    },
  });

  return encrypted;
}

---

Лучшие практики безопасности

1. Управление ключами

// src/security-practices.ts

// GOOD: Use secure key derivation
import { generateKeypair } from "@mysten/sui/cryptography/ed25519";

const keypair = generateKeypair();

// GOOD: Store keys securely (example with environment variables)
const keypair = Ed25519Keypair.fromSecretKey(process.env.PRIVATE_KEY);

// BAD: Never hardcode keys
const badKeypair = Ed25519Keypair.fromSecretKey(
  "hardcoded-secret-key-12345", // Don't do this!
);

2. Проверка политики доступа

// Always validate access policies before encryption
async function secureEncrypt(data: Buffer, recipient: string) {
  const { sealClient } = await createSealClient();

  // Validate recipient address
  if (!isValidSuiAddress(recipient)) {
    throw new Error("Invalid recipient address");
  }

  // Check policy exists and is valid
  const policy = await validateAccessPolicy(policyId);
  if (!policy.isValid) {
    throw new Error("Invalid access policy");
  }

  return sealClient.encrypt({
    data,
    recipientId: recipient,
    accessPolicy: policy,
  });
}

3. Обработка ошибок и запасные варианты

// Robust error handling
async function resilientDecrypt(encryptionId: string, userKeypair: any) {
  const { sealClient } = await createSealClient();

  try {
    return await sealClient.decrypt({
      encryptionId,
      recipientId: userKeypair.toSuiAddress(),
    });
  } catch (error) {
    if (error.code === "ACCESS_DENIED") {
      throw new Error("Access denied: Check your permissions");
    } else if (error.code === "KEY_SERVER_UNAVAILABLE") {
      // Try with backup configuration
      return await retryWithBackupServers(encryptionId, userKeypair);
    } else if (error.code === "THRESHOLD_NOT_MET") {
      throw new Error("Insufficient key servers available");
    } else {
      throw new Error(`Decryption failed: ${error.message}`);
    }
  }
}

4. Проверка данных

// Validate data before encryption
function validateDataForEncryption(data: Buffer): boolean {
  // Check size limits
  if (data.length > 1024 * 1024) {
    // 1MB limit
    throw new Error("Data too large for encryption");
  }

  // Check for sensitive patterns (optional)
  const dataStr = data.toString();
  if (containsSensitivePatterns(dataStr)) {
    console.warn("Warning: Data contains potentially sensitive patterns");
  }

  return true;
}

---

Оптимизация производительности

1. Пакетные операции

// Batch multiple encryptions for efficiency
async function batchEncrypt(dataItems: Buffer[], recipients: string[]) {
  const { sealClient } = await createSealClient();

  const promises = dataItems.map((data, index) =>
    sealClient.encrypt({
      data,
      recipientId: recipients[index],
    }),
  );

  return Promise.all(promises);
}

2. Кэширование ответов сервера ключей

// Cache key server sessions to reduce latency
class OptimizedSealClient {
  private sessionCache = new Map();

  async encryptWithCaching(data: Buffer, recipient: string) {
    let session = this.sessionCache.get(recipient);

    if (!session || this.isSessionExpired(session)) {
      session = await this.createNewSession(recipient);
      this.sessionCache.set(recipient, session);
    }

    return this.encryptWithSession(data, session);
  }
}

---

Тестирование вашей интеграции Seal

Модульное тестирование

// tests/seal-integration.test.ts
import { describe, it, expect } from "jest";
import { createSealClient } from "../src/seal-client";

describe("Seal Integration", () => {
  it("should encrypt and decrypt data successfully", async () => {
    const { sealClient } = await createSealClient();
    const testData = Buffer.from("test message");
    const recipient =
      "0x742d35cc6d4c0c08c0f9bf3c9b2b6c64b3b4f5c6d7e8f9a0b1c2d3e4f5a6b7c8";

    const encrypted = await sealClient.encrypt({
      data: testData,
      recipientId: recipient,
    });

    expect(encrypted.encryptionId).toBeDefined();
    expect(encrypted.ciphertext).toBeDefined();

    const decrypted = await sealClient.decrypt({
      ciphertext: encrypted.ciphertext,
      encryptionId: encrypted.encryptionId,
      recipientId: recipient,
    });

    expect(decrypted.toString()).toBe("test message");
  });

  it("should enforce access control policies", async () => {
    // Test that unauthorized users cannot decrypt
    const { sealClient } = await createSealClient();

    const encrypted = await sealClient.encrypt({
      data: Buffer.from("secret"),
      recipientId: "authorized-user",
    });

    await expect(
      sealClient.decrypt({
        ciphertext: encrypted.ciphertext,
        encryptionId: encrypted.encryptionId,
        recipientId: "unauthorized-user",
      }),
    ).rejects.toThrow("Access denied");
  });
});

---

Развертывание в продакшене

Конфигурация среды

// config/production.ts
export const productionConfig = {
  keyServers: [
    process.env.KEY_SERVER_1,
    process.env.KEY_SERVER_2,
    process.env.KEY_SERVER_3,
    process.env.KEY_SERVER_4,
    process.env.KEY_SERVER_5,
  ],
  threshold: 3,
  network: "mainnet",
  suiRpc: process.env.SUI_RPC_URL,
  walrusGateway: process.env.WALRUS_GATEWAY,
  // Security settings
  maxDataSize: 1024 * 1024, // 1MB
  sessionTimeout: 3600000, // 1 hour
  retryAttempts: 3,
};

Мониторинг и логирование

// utils/monitoring.ts
export class SealMonitoring {
  static logEncryption(encryptionId: string, recipient: string) {
    console.log(`[SEAL] Encrypted data ${encryptionId} for ${recipient}`);
    // Send to your monitoring service
  }

  static logDecryption(encryptionId: string, success: boolean) {
    console.log(
      `[SEAL] Decryption ${encryptionId}: ${success ? "SUCCESS" : "FAILED"}`,
    );
  }

  static logKeyServerHealth(serverUrl: string, status: string) {
    console.log(`[SEAL] Key server ${serverUrl}: ${status}`);
  }
}

---

Ресурсы и дальнейшие шаги

Официальная документация

• Seal Documentation: https://seal-docs.wal.app/
• GitHub Repository: https://github.com/MystenLabs/seal
• Sui Documentation: https://docs.sui.io/
• Walrus Documentation: https://docs.wal.app/

Сообщество и поддержка

• Sui Discord: Присоединяйтесь к каналу #seal для поддержки сообщества
• GitHub Issues: Сообщайте об ошибках и запрашивайте функции
• Форумы для разработчиков: Форумы сообщества Sui для обсуждений

Расширенные темы для изучения

1. Пользовательские политики доступа: Создавайте сложную логику авторизации с помощью контрактов Move
2. Кросс-чейн интеграция: Используйте Seal с другими блокчейн-сетями
3. Управление ключами для предприятий: Настройте собственную инфраструктуру серверов ключей
4. Аудит и соответствие требованиям: Внедрите логирование и мониторинг для регулируемых сред

Примеры приложений

• Приложение для безопасного чата: Сквозное шифрование сообщений с помощью Seal
• Управление документами: Обмен корпоративными документами с контролем доступа
• Управление цифровыми правами: Распространение контента с политиками использования
• Аналитика, сохраняющая конфиденциальность: Рабочие процессы обработки зашифрованных данных

---

Заключение

Seal представляет собой фундаментальный сдвиг в сторону превращения конфиденциальности и шифрования в инфраструктурные проблемы в Web3. Объединяя шифрование на основе идентификаторов, пороговую безопасность и программируемый контроль доступа, он предоставляет разработчикам мощные инструменты для создания по-настоящему безопасных и децентрализованных приложений.

Основные преимущества использования Seal включают:

• Отсутствие единой точки отказа: Распределенные серверы ключей устраняют центральные органы
• Программируемая безопасность: Политики доступа на основе смарт-контрактов обеспечивают гибкую авторизацию
• Удобство для разработчиков: SDK TypeScript легко интегрируется с существующими инструментами Web3
• Независимость от хранилища: Работает с Walrus, IPFS или любым другим решением для хранения
• Готовность к продакшену: Создан Mysten Labs с учетом корпоративных стандартов безопасности

Независимо от того, защищаете ли вы пользовательские данные, внедряете модели подписки или создаете сложные многосторонние приложения, Seal предоставляет криптографические примитивы и инфраструктуру контроля доступа, необходимые для уверенного создания.

Начните создавать сегодня и присоединяйтесь к растущей экосистеме разработчиков, которые делают конфиденциальность фундаментальной частью общественной инфраструктуры.

---

Готовы начать создавать? Установите @mysten/seal и начните экспериментировать с примерами из этого руководства. Децентрализованная сеть ждет приложений, которые ставят конфиденциальность и безопасность на первое место.