@solana/mpp 0.0.0 → 0.1.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 solana-mpp-sdk contributors
+
+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,227 @@
+<p align="center">
+  <img src="assets/banner.png" alt="MPP" width="100%" />
+</p>
+
+# @solana/mpp
+
+Solana payment method for the [Machine Payments Protocol](https://mpp.dev).
+
+**MPP** is [an open protocol proposal](https://paymentauth.org) that lets any HTTP API accept payments using the `402 Payment Required` flow.
+
+> [!IMPORTANT]
+> This repository is under active development. The [Solana MPP spec](https://github.com/tempoxyz/mpp-specs/pull/188) is not yet finalized — APIs and wire formats are subject to change.
+
+## Install
+
+```bash
+pnpm add @solana/mpp
+```
+
+Peer dependencies:
+
+```bash
+pnpm add @solana/kit mppx
+# Optional — for Swig session authorization:
+pnpm add @swig-wallet/kit
+```
+
+## Features
+
+**Charge** (one-time payments)
+- Native SOL and SPL token transfers (USDC, PYUSD, Token-2022, etc.)
+- Two settlement modes: pull (`type="transaction"`, default) and push (`type="signature"`)
+- Fee sponsorship: server pays transaction fees on behalf of clients
+- Replay protection via consumed transaction signatures
+
+**Session** (metered / streaming payments)
+- Voucher-based payment channels with monotonic cumulative amounts
+- Multiple authorization modes: `unbounded`, `regular_budget`, `swig_session`
+- Auto-open, auto-topup, and close lifecycle
+- [Swig](https://build.onswig.com) smart wallet integration for on-chain spend limits
+
+**General**
+- Works with [ConnectorKit](https://www.connectorkit.dev), `@solana/kit` keypair signers, and [Solana Keychain](https://github.com/solana-foundation/solana-keychain) remote signers
+- Server pre-fetches `recentBlockhash` to save client an RPC round-trip
+- Transaction simulation before broadcast to prevent wasted fees
+
+## Architecture
+
+```
+sdk/src/
+├── Methods.ts              # Shared charge + session schemas
+├── constants.ts            # Token programs, USDC mints, RPC URLs
+├── server/
+│   ├── Charge.ts           # Server: challenge, verify, broadcast
+│   └── Session.ts          # Server: session channel management
+├── client/
+│   ├── Charge.ts           # Client: build tx, sign, send
+│   └── Session.ts          # Client: session lifecycle
+└── session/
+    ├── Types.ts            # Session types and interfaces
+    ├── Voucher.ts          # Voucher signing and verification
+    ├── ChannelStore.ts     # Persistent channel state
+    └── authorizers/        # Pluggable authorization strategies
+        ├── UnboundedAuthorizer.ts
+        ├── BudgetAuthorizer.ts
+        └── SwigSessionAuthorizer.ts
+```
+
+**Exports:**
+- `@solana/mpp` — shared schemas, session types, and authorizers
+- `@solana/mpp/server` — server-side charge + session, `Mppx`, `Store`
+- `@solana/mpp/client` — client-side charge + session, `Mppx`
+
+## Quick Start
+
+### Charge (one-time payment)
+
+**Server:**
+
+```ts
+import { Mppx, solana } from '@solana/mpp/server'
+
+const mppx = Mppx.create({
+  secretKey: process.env.MPP_SECRET_KEY,
+  methods: [
+    solana.charge({
+      recipient: 'RecipientPubkey...',
+      splToken: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
+      decimals: 6,
+    }),
+  ],
+})
+
+const result = await mppx.charge({
+  amount: '1000000', // 1 USDC
+  currency: 'USDC',
+})(request)
+
+if (result.status === 402) return result.challenge
+return result.withReceipt(Response.json({ data: '...' }))
+```
+
+**Client:**
+
+```ts
+import { Mppx, solana } from '@solana/mpp/client'
+
+const mppx = Mppx.create({
+  methods: [solana.charge({ signer })], // any TransactionSigner
+})
+
+const response = await mppx.fetch('https://api.example.com/paid-endpoint')
+```
+
+### Session (metered payments)
+
+**Server:**
+
+```ts
+import { Mppx, solana } from '@solana/mpp/server'
+
+const mppx = Mppx.create({
+  secretKey: process.env.MPP_SECRET_KEY,
+  methods: [
+    solana.session({
+      recipient: 'RecipientPubkey...',
+      asset: { kind: 'sol', decimals: 9 },
+      channelProgram: 'ChannelProgramId...',
+      pricing: { unit: 'request', amountPerUnit: '10', meter: 'api_calls' },
+      sessionDefaults: { suggestedDeposit: '1000', ttlSeconds: 60 },
+    }),
+  ],
+})
+```
+
+**Client:**
+
+```ts
+import { Mppx, solana } from '@solana/mpp/client'
+import { UnboundedAuthorizer } from '@solana/mpp'
+
+const mppx = Mppx.create({
+  methods: [
+    solana.session({
+      signer,
+      authorizer: new UnboundedAuthorizer({ signer, buildOpenTx, buildTopupTx }),
+    }),
+  ],
+})
+
+const response = await mppx.fetch('https://api.example.com/metered-endpoint')
+```
+
+### Fee Sponsorship (charge)
+
+The server can pay transaction fees on behalf of clients:
+
+```ts
+// Server — pass a TransactionPartialSigner to cover fees
+solana.charge({
+  recipient: '...',
+  signer: feePayerSigner, // KeyPairSigner, Keychain SolanaSigner, etc.
+})
+
+// Client — no changes needed, fee payer is handled automatically
+```
+
+## How It Works
+
+### Charge Flow
+
+1. Client requests a resource
+2. Server returns **402 Payment Required** with a challenge (`recipient`, `amount`, `currency`, `recentBlockhash`)
+3. Client builds and signs a Solana transfer transaction
+4. Server simulates, broadcasts, confirms on-chain, and verifies the transfer
+5. Server returns the resource with a `Payment-Receipt` header
+
+With fee sponsorship, the client partially signs (transfer authority only) and the server co-signs as fee payer before broadcasting.
+
+### Session Flow
+
+1. First request: server returns 402, client opens a channel (deposit + voucher)
+2. Subsequent requests: client sends updated vouchers with monotonic cumulative amounts
+3. Server deducts from the channel balance per its pricing config
+4. When balance runs low: client tops up the channel
+5. On close: final voucher settles the channel
+
+## Demo
+
+An interactive playground with a React frontend and Express backend, running against [Surfpool](https://surfpool.run).
+
+- Charge flow demo: `http://localhost:5173/charges`
+- Session flow demo: `http://localhost:5173/sessions`
+
+```bash
+surfpool start
+pnpm demo:install
+pnpm demo:server
+pnpm demo:app
+```
+
+See [demo/README.md](demo/README.md) for full details.
+
+## Development
+
+```bash
+pnpm install
+
+just fmt              # Format and lint
+just build            # Typecheck
+just test             # Unit tests (charge + session, no network)
+just test-integration # Integration tests (requires Surfpool)
+just test-all         # All tests
+just pre-commit       # fmt + typecheck + unit tests
+```
+
+## Spec
+
+This SDK implements the [Solana Charge Intent](https://github.com/tempoxyz/mpp-specs/pull/188) for the [HTTP Payment Authentication Scheme](https://paymentauth.org).
+
+Session method docs and implementation notes:
+
+- [docs/methods/sessions.md](docs/methods/sessions.md)
+
+## License
+
+MIT

package/dist/Methods.d.ts

@@ -0,0 +1,272 @@
+import { z } from 'mppx';
+/**
+ * Solana charge method — shared schema used by both server and client.
+ *
+ * Supports two settlement modes:
+ *
+ * - **Pull mode** (`type="transaction"`, default): Client signs the
+ *   transaction and sends the bytes to the server. The server broadcasts,
+ *   confirms, and verifies the transfer on-chain.
+ *
+ * - **Push mode** (`type="signature"`): Client broadcasts the transaction
+ *   itself and sends the confirmed signature. The server verifies on-chain.
+ */
+export declare const charge: {
+    readonly intent: "charge";
+    readonly name: "solana";
+    readonly schema: {
+        readonly credential: {
+            readonly payload: z.ZodMiniObject<{
+                /** Base58-encoded transaction signature (when type="signature"). */
+                signature: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                /** Base64-encoded serialized signed transaction (when type="transaction"). */
+                transaction: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                /** Payload type: "transaction" (server broadcasts) or "signature" (client already broadcast). */
+                type: z.ZodMiniString<string>;
+            }, z.core.$strip>;
+        };
+        readonly request: z.ZodMiniObject<{
+            /** Amount in smallest unit (lamports for SOL, base units for SPL tokens). */
+            amount: z.ZodMiniString<string>;
+            /** Identifies the unit for amount. "SOL" for native, or token symbol/mint (e.g. "USDC"). */
+            currency: z.ZodMiniString<string>;
+            /** Human-readable memo describing the resource or service being paid for. */
+            description: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            /** Merchant's reference (e.g., order ID, invoice number) for reconciliation. */
+            externalId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            methodDetails: z.ZodMiniObject<{
+                /** Token decimals (required for SPL token transfers). */
+                decimals: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+                /** If true, server pays transaction fees. Client must use the server's feePayerKey. */
+                feePayer: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+                /** Server's base58-encoded public key for fee payment. Present when feePayer is true. */
+                feePayerKey: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                /** Solana network: mainnet-beta, devnet, or localnet. */
+                network: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                /** Server-provided base58-encoded recent blockhash. Saves the client an RPC round-trip. */
+                recentBlockhash: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                /** Unique reference ID for this charge (server-generated, used for tracking). */
+                reference: z.ZodMiniString<string>;
+                /** SPL token mint address. If absent, payment is in native SOL. */
+                splToken: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                /** Token program address (TOKEN_PROGRAM or TOKEN_2022_PROGRAM). Defaults to TOKEN_PROGRAM. */
+                tokenProgram: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            }, z.core.$strip>;
+            /** Base58-encoded recipient public key. */
+            recipient: z.ZodMiniString<string>;
+        }, z.core.$strip>;
+    };
+};
+/**
+ * Solana session method shared schema used by both server and client.
+ *
+ * Supports four credential actions:
+ *
+ * - **open**: opens a payment channel, records deposit, and anchors setup tx.
+ * - **update**: submits a new monotonic voucher for cumulative usage.
+ * - **topup**: increases channel escrow using a separate topup transaction.
+ * - **close**: final voucher update used to finalize channel settlement.
+ */
+export declare const session: {
+    readonly intent: "session";
+    readonly name: "solana";
+    readonly schema: {
+        readonly credential: {
+            readonly payload: z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
+                /** Session lifecycle action. */
+                action: z.ZodMiniLiteral<"open">;
+                /** Authorization mode selected by the authorizer implementation. */
+                authorizationMode: z.ZodMiniString<string>;
+                /** Optional advertised authorizer capabilities for client hints. */
+                capabilities: z.ZodMiniOptional<z.ZodMiniObject<{
+                    /** Allowed action subset advertised by the authorizer. */
+                    allowedActions: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+                    /** Maximum cumulative authorized amount for this channel. */
+                    maxCumulativeAmount: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                }, z.core.$strip>>;
+                /** Unique channel identifier generated by the client authorizer. */
+                channelId: z.ZodMiniString<string>;
+                /** Initial escrow amount committed for this channel. */
+                depositAmount: z.ZodMiniString<string>;
+                /** Optional voucher expiration timestamp in ISO-8601 format. */
+                expiresAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                /** On-chain transaction reference proving open/setup step. */
+                openTx: z.ZodMiniString<string>;
+                /** Wallet payer for this channel (base58 public key). */
+                payer: z.ZodMiniString<string>;
+                /** Signed session voucher payload for open action. */
+                voucher: z.ZodMiniObject<{
+                    /** Base58/encoded signature over canonical voucher bytes. */
+                    signature: z.ZodMiniString<string>;
+                    /** Signature scheme discriminator (`ed25519` or `swig-session`). */
+                    signatureType: z.ZodMiniString<string>;
+                    /** Voucher signer public key. */
+                    signer: z.ZodMiniString<string>;
+                    voucher: z.ZodMiniObject<{
+                        /** Chain identifier, for example `solana:mainnet-beta`. */
+                        chainId: z.ZodMiniString<string>;
+                        /** Channel identifier bound to this voucher. */
+                        channelId: z.ZodMiniString<string>;
+                        /** Channel program address expected by server verifier. */
+                        channelProgram: z.ZodMiniString<string>;
+                        /** Monotonic cumulative authorized amount. */
+                        cumulativeAmount: z.ZodMiniString<string>;
+                        /** Optional voucher expiration timestamp in ISO-8601 format. */
+                        expiresAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                        /** Meter name for priced usage tracking. */
+                        meter: z.ZodMiniString<string>;
+                        /** Wallet payer bound to this voucher. */
+                        payer: z.ZodMiniString<string>;
+                        /** Channel recipient service wallet. */
+                        recipient: z.ZodMiniString<string>;
+                        /** Monotonic sequence number for replay protection. */
+                        sequence: z.ZodMiniNumber<number>;
+                        /** Server-provided nonce for challenge binding. */
+                        serverNonce: z.ZodMiniString<string>;
+                        /** Meter units associated with this authorization update. */
+                        units: z.ZodMiniString<string>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodMiniObject<{
+                /** Session lifecycle action. */
+                action: z.ZodMiniLiteral<"update">;
+                /** Existing channel identifier targeted by this update. */
+                channelId: z.ZodMiniString<string>;
+                /** Signed session voucher payload for usage update. */
+                voucher: z.ZodMiniObject<{
+                    /** Base58/encoded signature over canonical voucher bytes. */
+                    signature: z.ZodMiniString<string>;
+                    /** Signature scheme discriminator (`ed25519` or `swig-session`). */
+                    signatureType: z.ZodMiniString<string>;
+                    /** Voucher signer public key. */
+                    signer: z.ZodMiniString<string>;
+                    voucher: z.ZodMiniObject<{
+                        /** Chain identifier, for example `solana:mainnet-beta`. */
+                        chainId: z.ZodMiniString<string>;
+                        /** Channel identifier bound to this voucher. */
+                        channelId: z.ZodMiniString<string>;
+                        /** Channel program address expected by server verifier. */
+                        channelProgram: z.ZodMiniString<string>;
+                        /** Monotonic cumulative authorized amount. */
+                        cumulativeAmount: z.ZodMiniString<string>;
+                        /** Optional voucher expiration timestamp in ISO-8601 format. */
+                        expiresAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                        /** Meter name for priced usage tracking. */
+                        meter: z.ZodMiniString<string>;
+                        /** Wallet payer bound to this voucher. */
+                        payer: z.ZodMiniString<string>;
+                        /** Channel recipient service wallet. */
+                        recipient: z.ZodMiniString<string>;
+                        /** Monotonic sequence number for replay protection. */
+                        sequence: z.ZodMiniNumber<number>;
+                        /** Server-provided nonce for challenge binding. */
+                        serverNonce: z.ZodMiniString<string>;
+                        /** Meter units associated with this authorization update. */
+                        units: z.ZodMiniString<string>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodMiniObject<{
+                /** Session lifecycle action. */
+                action: z.ZodMiniLiteral<"topup">;
+                /** Additional escrow amount to add to channel deposit. */
+                additionalAmount: z.ZodMiniString<string>;
+                /** Existing channel identifier targeted by this topup. */
+                channelId: z.ZodMiniString<string>;
+                /** On-chain transaction reference proving topup execution. */
+                topupTx: z.ZodMiniString<string>;
+            }, z.core.$strip>, z.ZodMiniObject<{
+                /** Session lifecycle action. */
+                action: z.ZodMiniLiteral<"close">;
+                /** Existing channel identifier targeted by this close. */
+                channelId: z.ZodMiniString<string>;
+                /** Optional on-chain settlement transaction reference for this close. */
+                closeTx: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                /** Signed final voucher payload for close action. */
+                voucher: z.ZodMiniObject<{
+                    /** Base58/encoded signature over canonical voucher bytes. */
+                    signature: z.ZodMiniString<string>;
+                    /** Signature scheme discriminator (`ed25519` or `swig-session`). */
+                    signatureType: z.ZodMiniString<string>;
+                    /** Voucher signer public key. */
+                    signer: z.ZodMiniString<string>;
+                    voucher: z.ZodMiniObject<{
+                        /** Chain identifier, for example `solana:mainnet-beta`. */
+                        chainId: z.ZodMiniString<string>;
+                        /** Channel identifier bound to this voucher. */
+                        channelId: z.ZodMiniString<string>;
+                        /** Channel program address expected by server verifier. */
+                        channelProgram: z.ZodMiniString<string>;
+                        /** Monotonic cumulative authorized amount. */
+                        cumulativeAmount: z.ZodMiniString<string>;
+                        /** Optional voucher expiration timestamp in ISO-8601 format. */
+                        expiresAt: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                        /** Meter name for priced usage tracking. */
+                        meter: z.ZodMiniString<string>;
+                        /** Wallet payer bound to this voucher. */
+                        payer: z.ZodMiniString<string>;
+                        /** Channel recipient service wallet. */
+                        recipient: z.ZodMiniString<string>;
+                        /** Monotonic sequence number for replay protection. */
+                        sequence: z.ZodMiniNumber<number>;
+                        /** Server-provided nonce for challenge binding. */
+                        serverNonce: z.ZodMiniString<string>;
+                        /** Meter units associated with this authorization update. */
+                        units: z.ZodMiniString<string>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+            }, z.core.$strip>], "action">;
+        };
+        readonly request: z.ZodMiniObject<{
+            asset: z.ZodMiniObject<{
+                /** Token decimals for amount normalization. */
+                decimals: z.ZodMiniNumber<number>;
+                /** Asset kind: native SOL or SPL token. */
+                kind: z.ZodMiniString<string>;
+                /** SPL mint address when kind is `spl`. */
+                mint: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                /** Optional ticker/symbol used for display. */
+                symbol: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            }, z.core.$strip>;
+            /** Channel program address used to verify vouchers and actions. */
+            channelProgram: z.ZodMiniString<string>;
+            /** Solana network name, for example mainnet-beta, devnet, localnet. */
+            network: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            /** Optional pricing contract used to derive debit increments. */
+            pricing: z.ZodMiniOptional<z.ZodMiniObject<{
+                /** Price per unit in asset base units. */
+                amountPerUnit: z.ZodMiniString<string>;
+                /** Meter identifier for usage accounting. */
+                meter: z.ZodMiniString<string>;
+                /** Optional minimum debit to apply per request. */
+                minDebit: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                /** Logical unit name charged by the service. */
+                unit: z.ZodMiniString<string>;
+            }, z.core.$strip>>;
+            /** Service recipient wallet that receives settlement funds. */
+            recipient: z.ZodMiniString<string>;
+            /** Optional server hints for default session behavior. */
+            sessionDefaults: z.ZodMiniOptional<z.ZodMiniObject<{
+                /** Optional close behavior hint for client UX. */
+                closeBehavior: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                /** Optional settlement cadence policy hints. */
+                settleInterval: z.ZodMiniOptional<z.ZodMiniObject<{
+                    kind: z.ZodMiniString<string>;
+                    minIncrement: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                    seconds: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+                }, z.core.$strip>>;
+                /** Suggested channel deposit to use on auto-open. */
+                suggestedDeposit: z.ZodMiniOptional<z.ZodMiniString<string>>;
+                /** Suggested time-to-live for channel/session in seconds. */
+                ttlSeconds: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+            }, z.core.$strip>>;
+            /** Optional server-side verifier policy hints. */
+            verifier: z.ZodMiniOptional<z.ZodMiniObject<{
+                /** Supported authorization modes for this endpoint. */
+                acceptAuthorizationModes: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+                /** Maximum allowable client/server clock skew in seconds. */
+                maxClockSkewSeconds: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+};
+//# sourceMappingURL=Methods.d.ts.map

package/dist/Methods.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Methods.d.ts","sourceRoot":"","sources":["../sdk/src/Methods.ts"],"names":[],"mappings":"AAAA,OAAO,EAAU,CAAC,EAAE,MAAM,MAAM,CAAC;AAEjC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,MAAM;;;;;;gBAMH,oEAAoE;;gBAEpE,8EAA8E;;gBAE9E,iGAAiG;;;;;YAKrG,6EAA6E;;YAE7E,4FAA4F;;YAE5F,6EAA6E;;YAE7E,gFAAgF;;;gBAG5E,yDAAyD;;gBAEzD,uFAAuF;;gBAEvF,yFAAyF;;gBAEzF,yDAAyD;;gBAEzD,2FAA2F;;gBAE3F,iFAAiF;;gBAEjF,mEAAmE;;gBAEnE,8FAA8F;;;YAGlG,2CAA2C;;;;CAIrD,CAAC;AAqCH;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO;;;;;;gBAOA,gCAAgC;;gBAEhC,oEAAoE;;gBAEpE,oEAAoE;;oBAG5D,0DAA0D;;oBAE1D,6DAA6D;;;gBAIrE,oEAAoE;;gBAEpE,wDAAwD;;gBAExD,gEAAgE;;gBAEhE,8DAA8D;;gBAE9D,yDAAyD;;gBAEzD,sDAAsD;;oBAjDtE,6DAA6D;;oBAE7D,oEAAoE;;oBAEpE,iCAAiC;;;wBA7BjC,2DAA2D;;wBAE3D,gDAAgD;;wBAEhD,2DAA2D;;wBAE3D,8CAA8C;;wBAE9C,gEAAgE;;wBAEhE,4CAA4C;;wBAE5C,0CAA0C;;wBAE1C,wCAAwC;;wBAExC,uDAAuD;;wBAEvD,mDAAmD;;wBAEnD,6DAA6D;;;;;gBA0D7C,gCAAgC;;gBAEhC,2DAA2D;;gBAE3D,uDAAuD;;oBAzDvE,6DAA6D;;oBAE7D,oEAAoE;;oBAEpE,iCAAiC;;;wBA7BjC,2DAA2D;;wBAE3D,gDAAgD;;wBAEhD,2DAA2D;;wBAE3D,8CAA8C;;wBAE9C,gEAAgE;;wBAEhE,4CAA4C;;wBAE5C,0CAA0C;;wBAE1C,wCAAwC;;wBAExC,uDAAuD;;wBAEvD,mDAAmD;;wBAEnD,6DAA6D;;;;;gBAkE7C,gCAAgC;;gBAEhC,0DAA0D;;gBAE1D,0DAA0D;;gBAE1D,8DAA8D;;;gBAI9D,gCAAgC;;gBAEhC,0DAA0D;;gBAE1D,yEAAyE;;gBAEzE,qDAAqD;;oBA7ErE,6DAA6D;;oBAE7D,oEAAoE;;oBAEpE,iCAAiC;;;wBA7BjC,2DAA2D;;wBAE3D,gDAAgD;;wBAEhD,2DAA2D;;wBAE3D,8CAA8C;;wBAE9C,gEAAgE;;wBAEhE,4CAA4C;;wBAE5C,0CAA0C;;wBAE1C,wCAAwC;;wBAExC,uDAAuD;;wBAEvD,mDAAmD;;wBAEnD,6DAA6D;;;;;;;;gBAyFjD,+CAA+C;;gBAE/C,2CAA2C;;gBAE3C,2CAA2C;;gBAE3C,+CAA+C;;;YAGnD,mEAAmE;;YAEnE,uEAAuE;;YAEvE,iEAAiE;;gBAGzD,0CAA0C;;gBAE1C,6CAA6C;;gBAE7C,mDAAmD;;gBAEnD,gDAAgD;;;YAIxD,+DAA+D;;YAE/D,0DAA0D;;gBAGlD,kDAAkD;;gBAElD,gDAAgD;;;;;;gBAQhD,qDAAqD;;gBAErD,6DAA6D;;;YAIrE,kDAAkD;;gBAG1C,uDAAuD;;gBAEvD,6DAA6D;;;;;CAM/E,CAAC"}