Создание децентрализованного шифрования с @mysten/seal: Руководство для разработчиков
· 13 мин. чтения
Конфиденциальность становится общественной инфраструктурой. В 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 для обсуждений
Расширенные темы для изучения
- Пользовательские политики доступа: Создавайте сложную логику авторизации с помощью контрактов Move
- Кросс-чейн интеграция: Используйте Seal с другими блокчейн-сетями
- Управление ключами для предприятий: Настройте собственную инфраструктуру серверов ключей
- Аудит и соответствие требованиям: Внедрите логи рование и мониторинг для регулируемых сред
Примеры приложений
- Приложение для безопасного чата: Сквозное шифрование сообщений с помощью Seal
- Управление документами: Обмен корпоративными документами с контролем доступа
- Управление цифровыми правами: Распространение контента с политиками использования
- Аналитика, сохраняющая конфиденциальность: Рабочие процессы обработки зашифрованных данных
Заключение
Seal представляет собой фундаментальный сдвиг в сторону превращения конфиденциальности и шифрования в инфраструктурные проблемы в Web3. Объединяя шифрование на основе идентификаторов, пороговую безопасность и программируемый контроль доступа, он предоставляет разработчикам мощные инструменты для создания по-насто ящему безопасных и децентрализованных приложений.
Основные преимущества использования Seal включают:
- Отсутствие единой точки отказа: Распределенные серверы ключей устраняют центральные органы
- Программируемая безопасность: Политики доступа на основе смарт-контрактов обеспечивают гибкую авторизацию
- Удобство для разработчиков: SDK TypeScript легко интегрируется с существующими инструментами Web3
- Независимость от хранилища: Работает с Walrus, IPFS или любым другим решением для хранения
- Готовность к продакшену: Создан Mysten Labs с учетом корпоративных стандартов безопасности
Независимо от того, защищаете ли вы пользовательские данные, внедряете модели подписки или создаете сложные многосторонние приложения, Seal предоставляет криптографические примитивы и инфраструктуру контроля доступа, необходимые для уверенного создания.
Начните создавать сегодня и присоединяйтесь к растущей экосистеме разработчиков, которые делают конфиденциальность фундаментальной частью общественной инфраструктуры.
Готовы начать созда вать? Установите @mysten/seal и начните экспериментировать с примерами из этого руководства. Децентрализованная сеть ждет приложений, которые ставят конфиденциальность и безопасность на первое место.
