@openzeppelin/relayer-plugin-channels 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 OpenZeppelin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,504 @@
+# Channels Plugin
+
+A plugin for OpenZeppelin Relayer that enables parallel transaction submission on Stellar using channel accounts with fee bumping. Channel accounts provide unique sequence numbers for parallel transaction submission, preventing sequence number conflicts.
+
+## Quick Start
+
+**Want to get started quickly?** Check out the [Channels Plugin Example](https://github.com/OpenZeppelin/openzeppelin-relayer/tree/main/examples/channels-plugin-example) which includes a pre-configured relayer setup, Docker Compose configuration, and step-by-step instructions. This is the fastest way to get the Channels plugin up and running.
+
+For manual installation and configuration details, continue reading below.
+
+## Prerequisites
+
+- Node.js >= 18
+- pnpm >= 10
+- OpenZeppelin Relayer
+
+## Installation & Setup
+
+The Channels plugin can be added to any OpenZeppelin Relayer in two ways:
+
+### 1. Install from npm (recommended)
+
+```bash
+# From the root of your Relayer repository
+cd plugins
+mkdir channels
+cd channels
+pnpm add @openzeppelin/relayer-plugin-channels
+```
+
+### 2. Use a local build (for development / debugging)
+
+```bash
+# Clone and build the plugin
+git clone https://github.com/openzeppelin/relayer-plugin-channels.git
+cd relayer-plugin-channels
+pnpm install
+pnpm build
+```
+
+Now reference the local build from your Relayer's `plugins/package.json`:
+
+```jsonc
+{
+  "dependencies": {
+    "@openzeppelin/relayer-plugin-channels": "file:../../relayer-plugin-channels",
+  },
+}
+```
+
+Install dependencies:
+
+```bash
+pnpm install
+```
+
+---
+
+### Create the plugin wrapper
+
+Inside the Relayer create a directory for the plugin and expose its handler:
+
+```bash
+mkdir -p plugins/channels
+```
+
+`plugins/channels/index.ts`
+
+```ts
+export { handler } from "@openzeppelin/relayer-plugin-channels";
+```
+
+### Configure the Relayer
+
+Before setting environment variables, you need to configure your Relayer's `config.json` with the fund account and channel accounts. Create or update your `config/config.json`:
+
+```json
+{
+  "relayers": [
+    {
+      "id": "channels-fund",
+      "name": "Channels Fund Account",
+      "network": "testnet",
+      "paused": false,
+      "network_type": "stellar",
+      "signer_id": "channels-fund-signer",
+      "policies": {
+        "concurrent_transactions": true
+      }
+    },
+    {
+      "id": "channel-001",
+      "name": "Channel Account 001",
+      "network": "testnet",
+      "paused": false,
+      "network_type": "stellar",
+      "signer_id": "channel-001-signer"
+    },
+    {
+      "id": "channel-002",
+      "name": "Channel Account 002",
+      "network": "testnet",
+      "paused": false,
+      "network_type": "stellar",
+      "signer_id": "channel-002-signer"
+    }
+  ],
+  "notifications": [],
+  "signers": [
+    {
+      "id": "channels-fund-signer",
+      "type": "local",
+      "config": {
+        "path": "config/keys/channels-fund.json",
+        "passphrase": {
+          "type": "env",
+          "value": "KEYSTORE_PASSPHRASE_FUND"
+        }
+      }
+    },
+    {
+      "id": "channel-001-signer",
+      "type": "local",
+      "config": {
+        "path": "config/keys/channel-001.json",
+        "passphrase": {
+          "type": "env",
+          "value": "KEYSTORE_PASSPHRASE_CHANNEL_001"
+        }
+      }
+    },
+    {
+      "id": "channel-002-signer",
+      "type": "local",
+      "config": {
+        "path": "config/keys/channel-002.json",
+        "passphrase": {
+          "type": "env",
+          "value": "KEYSTORE_PASSPHRASE_CHANNEL_002"
+        }
+      }
+    }
+  ],
+  "networks": "./config/networks",
+  "plugins": [
+    {
+      "id": "channels",
+      "path": "channel/index.ts",
+      "timeout": 30,
+      "emit_logs": true,
+      "emit_traces": true
+    }
+  ]
+}
+```
+
+**Important Configuration Notes:**
+
+- **Fund Account** (`channels-fund`): Must have `"concurrent_transactions": true` in policies to enable parallel transaction processing
+- **Channel Accounts**: Create at least 2 for better throughput (you can add more as `channel-003`, etc.)
+- **Network**: Use `testnet` for testing or `mainnet` for production
+- **Signers**: Each relayer references a signer by `signer_id`, and signers are defined separately with keystore paths
+- **Keystore Files**: You'll need to create keystore files for each account - see [OpenZeppelin Relayer documentation](https://docs.openzeppelin.com/relayer) for details on creating and managing keys
+- **Plugin Registration**: The `path` points to your plugin wrapper file relative to the plugins directory
+
+For more details on Relayer configuration, see the [OpenZeppelin Relayer documentation](https://docs.openzeppelin.com/relayer).
+
+### Configure Environment Variables
+
+Set the required environment variables for the plugin:
+
+```bash
+# Required environment variables
+export STELLAR_NETWORK="testnet"        # or "mainnet"
+export SOROBAN_RPC_URL="https://soroban-testnet.stellar.org"
+export FUND_RELAYER_ID="channels-fund"
+export PLUGIN_ADMIN_SECRET="your-secret-here"  # Required for management API
+
+# Optional environment variables
+export LOCK_TTL_SECONDS=10              # default: 30, min: 3, max: 30
+export MAX_FEE=1000000                  # default: 1,000,000 stroops
+```
+
+Your Relayer should now contain:
+
+```
+relayer/
+└─ plugins/
+   └─ channels/
+      ├─ package.json           # lists the dependency
+      └─ index.ts
+```
+
+### Initialize Channel Accounts
+
+Before using the Channels plugin, you must configure channel accounts using the management API:
+
+```bash
+curl -X POST http://localhost:8080/api/v1/plugins/channels/call \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "params": {
+      "management": {
+        "action": "setChannelAccounts",
+        "adminSecret": "your-secret-here",
+        "relayerIds": ["channel-0001", "channel-0002", "channel-0003"]
+      }
+    }
+  }'
+```
+
+The Channels plugin is now ready to serve Soroban transactions 🚀
+
+## Development
+
+### Building from Source
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build the plugin
+pnpm build
+
+# Run tests
+pnpm test
+
+# Lint and format
+pnpm lint
+pnpm format
+```
+
+## Overview
+
+The Channels plugin accepts Soroban operations and handles all the complexity of getting them on-chain:
+
+- Automatic fee bumping using a dedicated fund account
+- Parallel transaction execution with a pool of channel accounts
+- Transaction simulation and resource management
+- Error handling and confirmation waiting
+
+## Architecture
+
+- **Fund Account**: Holds funds and pays for fee bumps
+- **Channel Accounts**: Provide unique sequence numbers for parallel transaction submission
+- The channel account is the transaction source and signer; the fund account wraps it in a fee bump
+
+## Management API
+
+The Channels plugin provides a management API to dynamically configure channel accounts. This API requires authentication via the `PLUGIN_ADMIN_SECRET` environment variable.
+
+### List Channel Accounts
+
+Get the current list of configured channel accounts:
+
+```bash
+curl -X POST http://localhost:8080/api/v1/plugins/channels/call \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "params": {
+      "management": {
+        "action": "listChannelAccounts",
+        "adminSecret": "your-secret-here"
+      }
+    }
+  }'
+```
+
+**Response:**
+
+```json
+{
+  "relayerIds": ["channel-0001", "channel-0002", "channel-0003"]
+}
+```
+
+### Set Channel Accounts
+
+Configure the channel accounts that the plugin will use. This replaces the entire list:
+
+```bash
+curl -X POST http://localhost:8080/api/v1/plugins/channels/call \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "params": {
+      "management": {
+        "action": "setChannelAccounts",
+        "adminSecret": "your-secret-here",
+        "relayerIds": ["channel-0001", "channel-0002", "channel-0003"]
+      }
+    }
+  }'
+```
+
+**Response:**
+
+```json
+{
+  "ok": true,
+  "appliedRelayerIds": ["channel-0001", "channel-0002", "channel-0003"]
+}
+```
+
+**Important Notes:**
+
+- You must configure at least one channel account before the plugin can process transactions
+- The management API will prevent removing accounts that are currently locked (in use). On failure it throws a plugin error with status 409, code `LOCKED_CONFLICT`, and `details.locked` listing blocked IDs.
+- All relayer IDs must exist in your OpenZeppelin Relayer configuration
+- The `adminSecret` must match the `PLUGIN_ADMIN_SECRET` environment variable
+
+## API Usage
+
+### Submit with Transaction XDR
+
+Submit a complete, signed transaction:
+
+```bash
+curl -X POST http://localhost:8080/api/v1/plugins/channels/call \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "params": {
+      "xdr": "AAAAAgAAAAB..."
+    }
+  }'
+```
+
+### Submit with Function and Auth
+
+Submit just the Soroban function and auth entries:
+
+```bash
+curl -X POST http://localhost:8080/api/v1/plugins/channels/call \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "params": {
+      "func": "AAAABAAAAAEAAAAGc3ltYm9s...",
+      "auth": ["AAAACAAAAAEAAAA..."]
+    }
+  }'
+```
+
+### Parameters
+
+- `xdr` (string): Complete transaction envelope XDR (signed, not fee-bump)
+- `func` (string): Soroban host function XDR (base64)
+- `auth` (array): Array of Soroban authorization entry XDRs (base64)
+
+**Note**: Provide either `xdr` OR `func`+`auth`, not both.
+
+### Response
+
+Responses follow the Relayer envelope `{ success, data, error }`.
+
+Success example:
+
+```json
+{
+  "success": true,
+  "data": {
+    "transactionId": "tx_123456",
+    "status": "confirmed",
+    "hash": "1234567890abcdef..."
+  },
+  "error": null
+}
+```
+
+Plugin error example:
+
+```json
+{
+  "success": false,
+  "data": {
+    "code": "POOL_CAPACITY",
+    "details": {}
+  },
+  "error": "Too many transactions queued. Please try again later"
+}
+```
+
+## How It Works
+
+1. **Request Validation**: Validates input parameters (xdr OR func+auth)
+2. **Channel Account Pool**: Acquires an available channel account from the pool
+3. **Transaction Building**: For func+auth, builds transaction with channel as source
+4. **Simulation**: Simulates transaction to obtain sorobanData and resource fee
+5. **Signing**: Channel account signs the transaction
+6. **Fee Calculation**: Calculates dynamic max_fee based on resource fee
+7. **Fee Bumping**: Fund account wraps transaction with fee bump
+8. **Submission**: Sends to Stellar network and waits for confirmation
+9. **Pool Release**: Returns channel account to the pool
+
+## Validation Rules
+
+### Input Validation
+
+- Must provide `xdr` OR `func`+`auth` (not both)
+- XDR must not be a fee-bump envelope
+- All parameters must be valid base64 XDR
+
+### Transaction Validation (XDR mode)
+
+- Envelope type must be `envelopeTypeTx` (not fee bump)
+- TimeBounds maxTime must be within 30 seconds from now
+
+## KV Schema
+
+### Membership List
+
+- **Key**: `<network>:channel:relayer-ids`
+- **Value**: `{ relayerIds: string[] }`
+
+### Channel Locks
+
+- **Key**: `<network>:channel:in-use:<relayerId>`
+- **Value**: `{ token: string, lockedAt: ISOString }`
+- **TTL**: Configured by `LOCK_TTL_SECONDS`.
+
+## Error Codes
+
+- `CONFIG_MISSING`: Missing required environment variable
+- `UNSUPPORTED_NETWORK`: Invalid network type
+- `INVALID_PARAMS`: Invalid request parameters
+- `INVALID_XDR`: Failed to parse XDR
+- `INVALID_ENVELOPE_TYPE`: Not a regular transaction envelope
+- `INVALID_TIME_BOUNDS`: TimeBounds too far in the future
+- `NO_CHANNELS_CONFIGURED`: No channel accounts have been configured via management API
+- `POOL_CAPACITY`: All channel accounts in use
+- `RELAYER_UNAVAILABLE`: Relayer not found
+- `SIMULATION_FAILED`: Transaction simulation failed
+- `ONCHAIN_FAILED`: Transaction failed on-chain
+- `WAIT_TIMEOUT`: Transaction wait timeout
+- `MANAGEMENT_DISABLED`: Management API not enabled
+- `UNAUTHORIZED`: Invalid admin secret
+- `LOCKED_CONFLICT`: Cannot remove locked channel accounts
+
+## License
+
+MIT
+
+---
+
+## Smoke Test Contract
+
+This repo includes a minimal Soroban contract and smoke test script that exercise the Channels plugin with different authorization methods.
+
+### Contract
+
+- **Path**: `contracts/smoke-contract`
+- **Functions**:
+  - `no_auth_bump(n: u32) -> u32` — No auth required; returns n+1
+  - `write_with_address_auth(addr: Address, value: u32)` — Requires address auth; writes value to storage
+  - `read_value(addr: Address) -> u32` — Reads stored value for address
+
+Build/optimize/deploy with the Stellar CLI:
+
+```bash
+# Using helper script
+bash contracts/smoke-contract/contract.sh build
+bash contracts/smoke-contract/contract.sh optimize
+bash contracts/smoke-contract/contract.sh deploy --network testnet --account test-account
+```
+
+### Smoke Test Script
+
+- **Path**: `scripts/smoke.ts`
+- **Requirements**:
+  - Node.js 18+
+  - Stellar CLI (`stellar`) configured with a key
+  - Channels plugin running at base URL
+
+Environment variables:
+
+```bash
+export BASE_URL="http://localhost:8080"      # relayer origin
+export API_KEY="<relayer-api-key>"           # required
+export NETWORK="testnet"                     # or "mainnet"
+export RPC_URL="https://soroban-testnet.stellar.org"
+export ACCOUNT_NAME="test-account"           # key in `stellar keys`
+export CONTRACT_ID="CDXX..."                 # deployed smoke-contract
+```
+
+Run (args override env):
+
+```bash
+pnpm ts-node scripts/smoke.ts \
+  --api-key YOUR_API_KEY \
+  --account-name test-account \
+  --contract-id CDXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+
+# Show all options in the script header
+```
+
+What it does:
+
+- Health-checks the relayer
+- XDR submit-only: signs a small self-payment and submits via fee bump
+- func+auth (no auth): calls `no_auth_bump(42)` using a channel account
+- func+auth (address auth): calls `write_with_address_auth(addr, 777)` with signed auth entries

package/dist/build.d.ts

@@ -0,0 +1,21 @@
+/**
+ * build.ts
+ *
+ * Transaction rebuild logic to use channel account as source.
+ */
+import { Transaction } from "@stellar/stellar-sdk";
+export interface RebuildParams {
+    inputXdr: string;
+    channelAddress: string;
+    channelSequence: string;
+    fundAddress: string;
+    networkPassphrase: string;
+}
+/**
+ * Rebuild transaction with channel account as source
+ * - Set transaction source to channel account with current sequence
+ * - Preserve memo, timeBounds, etc.
+ * - Copy operations ensuring their source equals the fund address
+ */
+export declare function rebuildWithChannel(params: RebuildParams): Transaction;
+//# sourceMappingURL=build.d.ts.map

package/dist/build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build.d.ts","sourceRoot":"","sources":["../src/build.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,WAAW,EAAe,MAAM,sBAAsB,CAAC;AAIhE,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,aAAa,GAAG,WAAW,CA6GrE"}

package/dist/build.js

@@ -0,0 +1,100 @@
+"use strict";
+/**
+ * build.ts
+ *
+ * Transaction rebuild logic to use channel account as source.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rebuildWithChannel = rebuildWithChannel;
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const relayer_sdk_1 = require("@openzeppelin/relayer-sdk");
+const constants_1 = require("./constants");
+/**
+ * Rebuild transaction with channel account as source
+ * - Set transaction source to channel account with current sequence
+ * - Preserve memo, timeBounds, etc.
+ * - Copy operations ensuring their source equals the fund address
+ */
+function rebuildWithChannel(params) {
+    const { inputXdr, channelAddress, channelSequence, fundAddress, networkPassphrase, } = params;
+    // Parse input transaction
+    let inputTx;
+    try {
+        const envelope = stellar_sdk_1.xdr.TransactionEnvelope.fromXDR(inputXdr, "base64");
+        // Ensure it's a regular transaction envelope (not fee bump)
+        if (envelope.switch() !== stellar_sdk_1.xdr.EnvelopeType.envelopeTypeTx()) {
+            throw (0, relayer_sdk_1.pluginError)("Input must be a regular transaction envelope (not fee bump)", {
+                code: "INVALID_ENVELOPE_TYPE",
+                status: constants_1.HTTP_STATUS.BAD_REQUEST,
+            });
+        }
+        inputTx = new stellar_sdk_1.Transaction(envelope, networkPassphrase);
+    }
+    catch (error) {
+        if (error.code === "INVALID_ENVELOPE_TYPE") {
+            throw error;
+        }
+        throw (0, relayer_sdk_1.pluginError)("Failed to parse input transaction XDR", {
+            code: "INVALID_XDR",
+            status: constants_1.HTTP_STATUS.BAD_REQUEST,
+            details: {
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+    // Validate timeBounds
+    if (inputTx.timeBounds) {
+        const now = Math.floor(Date.now() / 1000);
+        const maxTime = Number(inputTx.timeBounds.maxTime);
+        if (maxTime > 0) {
+            const maxAllowedTime = now + constants_1.TIME.MAX_TIME_BOUND_OFFSET_SECONDS;
+            if (maxTime > maxAllowedTime) {
+                throw (0, relayer_sdk_1.pluginError)(`Transaction maxTime is too far in the future. Max allowed: ${constants_1.TIME.MAX_TIME_BOUND_OFFSET_SECONDS} seconds from now`, {
+                    code: "INVALID_TIME_BOUNDS",
+                    status: constants_1.HTTP_STATUS.BAD_REQUEST,
+                    details: { maxTime, maxAllowedTime },
+                });
+            }
+        }
+    }
+    // Validate operations: all operation sources must be fund address or missing
+    for (let i = 0; i < inputTx.operations.length; i++) {
+        const op = inputTx.operations[i];
+        if (op.source && op.source !== fundAddress) {
+            throw (0, relayer_sdk_1.pluginError)(`Operation ${i} has source ${op.source} but must be ${fundAddress} or omitted`, {
+                code: "INVALID_OPERATION_SOURCE",
+                status: constants_1.HTTP_STATUS.BAD_REQUEST,
+                details: {
+                    operationIndex: i,
+                    operationSource: op.source,
+                    expectedSource: fundAddress,
+                },
+            });
+        }
+    }
+    // Manipulate the transaction envelope XDR directly to change source and sequence
+    // This is the most reliable approach that preserves all transaction details
+    const envelope = inputTx.toEnvelope();
+    const txBody = envelope.v1().tx();
+    // Update source account to channel address
+    const channelAccountId = stellar_sdk_1.StrKey.decodeEd25519PublicKey(channelAddress);
+    const channelMuxed = stellar_sdk_1.xdr.MuxedAccount.keyTypeEd25519(channelAccountId);
+    txBody.sourceAccount(channelMuxed);
+    // Update sequence number
+    // Sequence numbers in Stellar are represented as Int64 in XDR
+    const seqNum = stellar_sdk_1.xdr.Int64.fromString(channelSequence);
+    txBody.seqNum(seqNum);
+    // Update operation sources to fund address if not set
+    const fundAccountId = stellar_sdk_1.StrKey.decodeEd25519PublicKey(fundAddress);
+    const fundMuxed = stellar_sdk_1.xdr.MuxedAccount.keyTypeEd25519(fundAccountId);
+    const operations = txBody.operations();
+    for (let i = 0; i < operations.length; i++) {
+        const op = operations[i];
+        // If operation doesn't have a source, set it to fund address
+        if (!op.sourceAccount()) {
+            op.sourceAccount(fundMuxed);
+        }
+    }
+    // Create new transaction from modified envelope
+    return new stellar_sdk_1.Transaction(envelope, networkPassphrase);
+}

package/dist/config.d.ts

@@ -0,0 +1,31 @@
+/**
+ * config.ts
+ *
+ * Environment-driven configuration for the channel accounts plugin.
+ */
+export interface ChannelAccountsConfig {
+    fundRelayerId: string;
+    network: "testnet" | "mainnet";
+    rpcUrl: string;
+}
+/**
+ * Load configuration from environment variables
+ */
+export declare function loadConfig(): ChannelAccountsConfig;
+/**
+ * Get the network passphrase based on the configuration
+ */
+export declare function getNetworkPassphrase(network: "testnet" | "mainnet"): string;
+/**
+ * Get the per-channel lock TTL in seconds (default 30)
+ */
+export declare function getLockTtlSeconds(): number;
+/**
+ * Get the max fee for fee bump transactions
+ */
+export declare function getMaxFee(): number;
+/**
+ * Get the admin secret for management API
+ */
+export declare function getAdminSecret(): string | undefined;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,MAAM,WAAW,qBAAqB;IACpC,aAAa,EAAE,MAAM,CAAC;IACtB,OAAO,EAAE,SAAS,GAAG,SAAS,CAAC;IAC/B,MAAM,EAAE,MAAM,CAAC;CAChB;AAcD;;GAEG;AACH,wBAAgB,UAAU,IAAI,qBAAqB,CAiBlD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,SAAS,GAAG,SAAS,GAAG,MAAM,CAE3E;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,MAAM,CAY1C;AAED;;GAEG;AACH,wBAAgB,SAAS,IAAI,MAAM,CAQlC;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,MAAM,GAAG,SAAS,CAKnD"}