@charterlabs/rhinestone-sdk 0.1.1 → 0.1.2

package/README.md

@@ -1,214 +1,107 @@
-# Rhinestone SDK
+# @charterlabs/rhinestone-sdk
 
-End-to-end chain abstraction and modularity toolkit
+A production-ready fork of the Rhinestone SDK with enhanced WebAuthn support for Charter Labs.
 
-## Usage
+## 🚀 Enhanced Features
 
-### Installation
+### Superior WebAuthn Implementation
+- **Multi-credential support** - Register multiple WebAuthn devices per account
+- **Threshold signatures** - M-of-N security model for enterprise use
+- **User verification control** - Configurable UV requirements per credential
+- **WebAuthn standard compliance** - Proper credential ID handling
+- **Production-ready** - Handles real-world multi-device scenarios
 
-```bash
-npm install viem @rhinestone/sdk
-```
+### Key Improvements Over Upstream
+- ✅ **Multi-device support** vs single credential limitation
+- ✅ **WebAuthn standard compliance** vs non-standard hashing
+- ✅ **Security flexibility** vs fixed UV policies
+- ✅ **Enterprise features** vs demo/MVP approach
 
-```bash
-pnpm install viem @rhinestone/sdk
-```
+## Installation
 
 ```bash
-yarn add viem @rhinestone/sdk
+npm install @charterlabs/rhinestone-sdk viem
+# or
+bun add @charterlabs/rhinestone-sdk viem
 ```
 
-```bash
-bun install viem @rhinestone/sdk
-```
-
-## Quickstart
-
-You'll need a Rhinestone API key, as well as an existing account with some testnet ETH on the source chain.
-
-### Creating a Wallet
+## Quick Start
 
-Let's create a smart account with a single owner:
-
-```ts
-import { createRhinestoneAccount } from '@rhinestone/sdk'
+```typescript
+import { createRhinestoneAccount } from '@charterlabs/rhinestone-sdk'
 import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
-import { baseSepolia, arbitrumSepolia, optimismSepolia } from 'viem/chains'
-import {
-  Chain,
-  createPublicClient,
-  createWalletClient,
-  encodeFunctionData,
-  erc20Abi,
-  Hex,
-  http,
-  parseEther,
-} from 'viem'
-
-const fundingPrivateKey = process.env.FUNDING_PRIVATE_KEY
-if (!fundingPrivateKey) {
-  throw new Error('FUNDING_PRIVATE_KEY is not set')
-}
-
-const rhinestoneApiKey = process.env.RHINESTONE_API_KEY
-if (!rhinestoneApiKey) {
-  throw new Error('RHINESTONE_API_KEY is not set')
-}
-
-const sourceChain = baseSepolia
-const targetChain = arbitrumSepolia
-
-// You can use an existing PK here
-const privateKey = generatePrivateKey()
-console.info(`Owner private key: ${privateKey}`)
-const account = privateKeyToAccount(privateKey)
 
+// Create account with WebAuthn support
 const rhinestoneAccount = await createRhinestoneAccount({
   owners: {
-    type: 'ecdsa',
-    accounts: [account],
-  }
-  rhinestoneApiKey,
+    type: 'passkey',
+    account: webAuthnAccount, // Your WebAuthn account
+    credentialIds: ['0x...', '0x...'] // Multiple credential IDs
+  },
+  rhinestoneApiKey: 'your-api-key'
 })
-const address = await rhinestoneAccount.getAddress()
-console.info(`Smart account address: ${address}`)
 ```
 
-### Funding the Account
-
-We will send some ETH from the funding account to the created smart account. The Orchestrator will use some of that ETH to deploy the account on the target chain, as well as to convert it to USDC for a transfer transaction.
-
-```ts
-const publicClient = createPublicClient({
-  chain: sourceChain,
-  transport: http(),
-});
-const fundingAccount = privateKeyToAccount(fundingPrivateKey as Hex);
-const fundingClient = createWalletClient({
-  account: fundingAccount,
-  chain: sourceChain,
-  transport: http(),
-});
-
-const txHash = await fundingClient.sendTransaction({
-  to: address,
-  value: parseEther('0.001'),
-});
-await publicClient.waitForTransactionReceipt({ hash: txHash });
-```
+## WebAuthn Features
 
-### Sending a Cross-chain Transaction
-
-Finally, let's make a cross-chain token transfer:
-
-```ts
-const usdcTarget = '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d';
-const usdcAmount = 1n;
-
-const transaction = await rhinestoneAccount.sendTransaction({
-  sourceChain,
-  targetChain,
-  calls: [
-    {
-      to: usdcTarget,
-      value: 0n,
-      data: encodeFunctionData({
-        abi: erc20Abi,
-        functionName: 'transfer',
-        args: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', usdcAmount],
-      }),
-    },
-  ],
-  tokenRequests: [
-    {
-      address: usdcTarget,
-      amount: usdcAmount,
-    },
-  ],
-});
-console.info('Transaction', transaction);
-
-const transactionResult = await rhinestoneAccount.waitForExecution(transaction);
-console.info('Result', transactionResult);
+### Multi-Credential Support
+```typescript
+// Register multiple devices
+const config = {
+  owners: {
+    type: 'passkey',
+    account: webAuthnAccount,
+    credentialIds: [
+      '0x1234...', // Phone
+      '0x5678...', // Laptop
+      '0x9abc...'  // Security key
+    ]
+  }
+}
 ```
 
-After running that, you will get a smart account deployed on both Base Sepolia and Arbitrum Sepolia, and make a cross-chain USDC transfer.
-
-### Using Smart Sessions
-
-First, define a session you want to use:
-
-```ts
-const session: Session = {
+### Threshold Signatures
+```typescript
+// Require 2-of-3 signatures
+const config = {
   owners: {
-    type: 'ecdsa',
-    accounts: [sessionOwner],
-  },
-  actions: [
-    {
-      target: wethAddress,
-      selector: toFunctionSelector(
-        getAbiItem({
-          abi: wethAbi,
-          name: 'deposit',
-        }),
-      ),
-    },
-    {
-      target: wethAddress,
-      selector: toFunctionSelector(
-        getAbiItem({
-          abi: wethAbi,
-          name: 'transfer',
-        }),
-      ),
-      policies: [
-        {
-          type: 'universal-action',
-          rules: [
-            {
-              condition: 'equal',
-              calldataOffset: 0n,
-              referenceValue: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
-            },
-          ],
-        },
-      ],
-    },
-  ],
+    type: 'multi-factor',
+    validators: [phoneValidator, laptopValidator, securityKeyValidator],
+    threshold: 2
+  }
 }
 ```
 
-During account initialization, provide the session you've just created. Make sure to also provide a bundler configuration.
-
-```ts
-const rhinestoneAccount = await createRhinestoneAccount({
-  // …
-  sessions: [session],
-  bundler: {
-    // …
-  },
+### User Verification Control
+```typescript
+// Configure UV requirements per credential
+const validator = getWebAuthnValidator({
+  pubKey: publicKey,
+  authenticatorId: 'device-id',
+  requireUV: true // Require user verification
 })
 ```
 
-When making a transaction, specify the `signers` object to sign it with the session key:
+## Development
 
-```ts
-const transactionResult = await rhinestoneAccount.sendTransaction({
-  // …
-  signers: {
-    type: 'session',
-    session: session,
-  },
-})
-```
+```bash
+# Install dependencies
+bun install
 
-## Migrating from Orchestrator SDK
+# Build
+bun run build
 
-To migrate from the [Orchestrator SDK](https://github.com/rhinestonewtf/orchestrator-sdk), replace all imports of `@rhinestone/orchestrator-sdk` with `@rhinestone/sdk/orchestrator`.
+# Test
+bun run test
 
-Let us know if you encounter any issues!
+# Create changeset
+bun run changeset
+
+# Version and publish
+bun run changeset:version
+bun run changeset:release
+```
 
-## Contributing
+## License
 
-For feature or change requests, feel free to open a PR, start a discussion or get in touch with us.
+MIT - Charter Labs

package/dist/src/accounts/error.d.ts

@@ -0,0 +1,69 @@
+import type { AccountType } from '../types';
+declare class AccountError extends Error {
+    private readonly _message;
+    private readonly _context;
+    private readonly _errorType;
+    private readonly _traceId;
+    constructor(params?: {
+        message?: string;
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+    get message(): string;
+    get context(): any;
+    get errorType(): string;
+    get traceId(): string;
+}
+declare class Eip7702AccountMustHaveEoaError extends AccountError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class ExistingEip7702AccountsNotSupportedError extends AccountError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class FactoryArgsNotAvailableError extends AccountError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class SmartSessionsNotEnabledError extends AccountError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class SigningNotSupportedForAccountError extends AccountError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class SignMessageNotSupportedByAccountError extends AccountError {
+    constructor(params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare class Eip7702NotSupportedForAccountError extends AccountError {
+    constructor(account: AccountType, params?: {
+        context?: any;
+        errorType?: string;
+        traceId?: string;
+    });
+}
+declare function isAccountError(error: Error): error is AccountError;
+export { isAccountError, AccountError, Eip7702AccountMustHaveEoaError, ExistingEip7702AccountsNotSupportedError, FactoryArgsNotAvailableError, SmartSessionsNotEnabledError, SigningNotSupportedForAccountError, SignMessageNotSupportedByAccountError, Eip7702NotSupportedForAccountError, };
+//# sourceMappingURL=error.d.ts.map

package/dist/src/accounts/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../../accounts/error.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAE3C,cAAM,YAAa,SAAQ,KAAK;IAC9B,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;IACjC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAK;IAC9B,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAQ;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAQ;gBAErB,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,MAAM,CAAA;QAChB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;IAQD,IAAI,OAAO,WAEV;IAED,IAAI,OAAO,QAEV;IAED,IAAI,SAAS,WAEZ;IAED,IAAI,OAAO,WAEV;CACF;AAED,cAAM,8BAA+B,SAAQ,YAAY;gBAC3C,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,cAAM,wCAAyC,SAAQ,YAAY;gBACrD,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,cAAM,4BAA6B,SAAQ,YAAY;gBACzC,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,cAAM,4BAA6B,SAAQ,YAAY;gBACzC,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,cAAM,kCAAmC,SAAQ,YAAY;gBAC/C,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,cAAM,qCAAsC,SAAQ,YAAY;gBAClD,MAAM,CAAC,EAAE;QACnB,OAAO,CAAC,EAAE,GAAG,CAAA;QACb,SAAS,CAAC,EAAE,MAAM,CAAA;QAClB,OAAO,CAAC,EAAE,MAAM,CAAA;KACjB;CAMF;AAED,cAAM,kCAAmC,SAAQ,YAAY;gBAEzD,OAAO,EAAE,WAAW,EACpB,MAAM,CAAC,EAAE;QAAE,OAAO,CAAC,EAAE,GAAG,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAA;KAAE;CAQnE;AAED,iBAAS,cAAc,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,IAAI,YAAY,CAE3D;AAeD,OAAO,EACL,cAAc,EACd,YAAY,EACZ,8BAA8B,EAC9B,wCAAwC,EACxC,4BAA4B,EAC5B,4BAA4B,EAC5B,kCAAkC,EAClC,qCAAqC,EACrC,kCAAkC,GACnC,CAAA"}

package/dist/src/accounts/error.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Eip7702NotSupportedForAccountError = exports.SignMessageNotSupportedByAccountError = exports.SigningNotSupportedForAccountError = exports.SmartSessionsNotEnabledError = exports.FactoryArgsNotAvailableError = exports.ExistingEip7702AccountsNotSupportedError = exports.Eip7702AccountMustHaveEoaError = exports.AccountError = void 0;
+exports.isAccountError = isAccountError;
+class AccountError extends Error {
+    _message;
+    _context;
+    _errorType;
+    _traceId;
+    constructor(params) {
+        super();
+        this._message = params?.message || 'AccountError';
+        this._context = params?.context || {};
+        this._errorType = params?.errorType || 'Unknown';
+        this._traceId = params?.traceId || '';
+    }
+    get message() {
+        return this._message;
+    }
+    get context() {
+        return this._context;
+    }
+    get errorType() {
+        return this._errorType;
+    }
+    get traceId() {
+        return this._traceId;
+    }
+}
+exports.AccountError = AccountError;
+class Eip7702AccountMustHaveEoaError extends AccountError {
+    constructor(params) {
+        super({
+            message: 'EIP-7702 accounts must have an EOA account',
+            ...params,
+        });
+    }
+}
+exports.Eip7702AccountMustHaveEoaError = Eip7702AccountMustHaveEoaError;
+class ExistingEip7702AccountsNotSupportedError extends AccountError {
+    constructor(params) {
+        super({
+            message: 'Existing EIP-7702 accounts are not yet supported',
+            ...params,
+        });
+    }
+}
+exports.ExistingEip7702AccountsNotSupportedError = ExistingEip7702AccountsNotSupportedError;
+class FactoryArgsNotAvailableError extends AccountError {
+    constructor(params) {
+        super({
+            message: 'Factory args not available',
+            ...params,
+        });
+    }
+}
+exports.FactoryArgsNotAvailableError = FactoryArgsNotAvailableError;
+class SmartSessionsNotEnabledError extends AccountError {
+    constructor(params) {
+        super({
+            message: 'Smart sessions are not enabled for this account',
+            ...params,
+        });
+    }
+}
+exports.SmartSessionsNotEnabledError = SmartSessionsNotEnabledError;
+class SigningNotSupportedForAccountError extends AccountError {
+    constructor(params) {
+        super({
+            message: 'Signing not supported for the account',
+            ...params,
+        });
+    }
+}
+exports.SigningNotSupportedForAccountError = SigningNotSupportedForAccountError;
+class SignMessageNotSupportedByAccountError extends AccountError {
+    constructor(params) {
+        super({
+            message: 'Sign message not supported by account',
+            ...params,
+        });
+    }
+}
+exports.SignMessageNotSupportedByAccountError = SignMessageNotSupportedByAccountError;
+class Eip7702NotSupportedForAccountError extends AccountError {
+    constructor(account, params) {
+        const accountName = getAccountName(account);
+        super({
+            message: `EIP-7702 is not supported for ${accountName} accounts`,
+            ...params,
+        });
+    }
+}
+exports.Eip7702NotSupportedForAccountError = Eip7702NotSupportedForAccountError;
+function isAccountError(error) {
+    return error instanceof AccountError;
+}
+function getAccountName(account) {
+    switch (account) {
+        case 'safe':
+            return 'Safe';
+        case 'kernel':
+            return 'Kernel';
+        case 'nexus':
+            return 'Nexus';
+        case 'startale':
+            return 'Startale';
+    }
+}

package/dist/{accounts → src/accounts}/index.d.ts

@@ -1,34 +1,27 @@
 import { type Chain, type Hex, type PublicClient } from 'viem';
-import { Module } from '../modules/common';
-import { EnableSessionData } from '../modules/validators/smart-sessions';
-import type { AccountProviderConfig, Call, OwnerSet, RhinestoneAccountConfig, Session } from '../types';
-import { ValidatorConfig } from './utils';
-declare function getDeployArgs(config: RhinestoneAccountConfig): {
+import type { Module } from '../modules/common';
+import type { EnableSessionData } from '../modules/validators/smart-sessions';
+import type { AccountProviderConfig, Call, OwnerSet, RhinestoneAccountConfig, Session, SignerSet } from '../types';
+import { AccountError, Eip7702AccountMustHaveEoaError, Eip7702NotSupportedForAccountError, ExistingEip7702AccountsNotSupportedError, FactoryArgsNotAvailableError, isAccountError, SigningNotSupportedForAccountError, SignMessageNotSupportedByAccountError, SmartSessionsNotEnabledError } from './error';
+import { type ValidatorConfig } from './utils';
+declare function getInitCode(config: RhinestoneAccountConfig): {
     factory: `0x${string}`;
     factoryData: `0x${string}`;
-    salt: `0x${string}`;
-    implementation: `0x${string}`;
-    initializationCallData: null;
-} | {
-    factory: `0x${string}`;
-    factoryData: `0x${string}`;
-    salt: `0x${string}`;
-    implementation: `0x${string}`;
-    initializationCallData: `0x${string}`;
-};
+} | undefined;
+declare function signEip7702InitData(config: RhinestoneAccountConfig): Promise<`0x${string}`>;
+declare function getEip7702InitCall(config: RhinestoneAccountConfig, signature: Hex): Promise<{
+    initData: `0x${string}`;
+    contract: `0x${string}`;
+}>;
 declare function getModuleInstallationCalls(config: RhinestoneAccountConfig, module: Module): Call[];
 declare function getModuleUninstallationCalls(config: RhinestoneAccountConfig, module: Module): Call[];
 declare function getAddress(config: RhinestoneAccountConfig): `0x${string}`;
-declare function getPackedSignature(config: RhinestoneAccountConfig, owners: OwnerSet, chain: Chain, validator: ValidatorConfig, hash: Hex, transformSignature?: (signature: Hex) => Hex): Promise<`0x${string}`>;
+declare function getPackedSignature(config: RhinestoneAccountConfig, signers: SignerSet | undefined, chain: Chain, validator: ValidatorConfig, hash: Hex, transformSignature?: (signature: Hex) => Hex): Promise<`0x${string}`>;
 declare function isDeployed(chain: Chain, config: RhinestoneAccountConfig): Promise<boolean>;
 declare function deploy(config: RhinestoneAccountConfig, chain: Chain, session?: Session): Promise<void>;
-declare function deploySource(chain: Chain, config: RhinestoneAccountConfig): Promise<void>;
-declare function deployTarget(chain: Chain, config: RhinestoneAccountConfig, asUserOp: boolean): Promise<void>;
-declare function getBundleInitCode(config: RhinestoneAccountConfig): `0x${string}` | undefined;
 declare function getSmartAccount(config: RhinestoneAccountConfig, client: PublicClient, chain: Chain): Promise<import("viem/account-abstraction").SmartAccount<import("viem/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">>>;
 declare function getSmartSessionSmartAccount(config: RhinestoneAccountConfig, client: PublicClient, chain: Chain, session: Session, enableData: EnableSessionData | null): Promise<import("viem/account-abstraction").SmartAccount<import("viem/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">>>;
 declare function getGuardianSmartAccount(config: RhinestoneAccountConfig, client: PublicClient, chain: Chain, guardians: OwnerSet): Promise<import("viem/account-abstraction").SmartAccount<import("viem/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">>>;
-declare function sign(validators: OwnerSet, chain: Chain, hash: Hex): Promise<`0x${string}`>;
 declare function getAccountProvider(config: RhinestoneAccountConfig): AccountProviderConfig;
-export { getModuleInstallationCalls, getModuleUninstallationCalls, getDeployArgs, getBundleInitCode, getAddress, getAccountProvider, isDeployed, deploy, deploySource, deployTarget, getSmartAccount, getSmartSessionSmartAccount, getGuardianSmartAccount, getPackedSignature, sign, };
+export { getModuleInstallationCalls, getModuleUninstallationCalls, getAddress, getAccountProvider, getInitCode, signEip7702InitData, getEip7702InitCall, isDeployed, deploy, getSmartAccount, getSmartSessionSmartAccount, getGuardianSmartAccount, getPackedSignature, isAccountError, AccountError, Eip7702AccountMustHaveEoaError, ExistingEip7702AccountsNotSupportedError, FactoryArgsNotAvailableError, SmartSessionsNotEnabledError, SigningNotSupportedForAccountError, SignMessageNotSupportedByAccountError, Eip7702NotSupportedForAccountError, };
 //# sourceMappingURL=index.d.ts.map

package/dist/src/accounts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../accounts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,KAAK,EAKV,KAAK,GAAG,EACR,KAAK,YAAY,EAKlB,MAAM,MAAM,CAAA;AAQb,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAA;AAS/C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAA;AAC7E,OAAO,KAAK,EACV,qBAAqB,EACrB,IAAI,EACJ,QAAQ,EAER,uBAAuB,EACvB,OAAO,EACP,SAAS,EACV,MAAM,UAAU,CAAA;AACjB,OAAO,EACL,YAAY,EACZ,8BAA8B,EAC9B,kCAAkC,EAClC,wCAAwC,EACxC,4BAA4B,EAC5B,cAAc,EACd,kCAAkC,EAClC,qCAAqC,EACrC,4BAA4B,EAC7B,MAAM,SAAS,CAAA;AAuChB,OAAO,EAAmB,KAAK,eAAe,EAAE,MAAM,SAAS,CAAA;AAoB/D,iBAAS,WAAW,CAAC,MAAM,EAAE,uBAAuB;;;cAanD;AAED,iBAAe,mBAAmB,CAAC,MAAM,EAAE,uBAAuB,0BAgBjE;AAED,iBAAe,kBAAkB,CAC/B,MAAM,EAAE,uBAAuB,EAC/B,SAAS,EAAE,GAAG;;;GAaf;AAED,iBAAS,0BAA0B,CACjC,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,MAAM,GACb,IAAI,EAAE,CA2BR;AAED,iBAAS,4BAA4B,CACnC,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,MAAM,GACb,IAAI,EAAE,CA6BR;AAED,iBAAS,UAAU,CAAC,MAAM,EAAE,uBAAuB,iBAsBlD;AAGD,iBAAe,kBAAkB,CAC/B,MAAM,EAAE,uBAAuB,EAC/B,OAAO,EAAE,SAAS,GAAG,SAAS,EAC9B,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,eAAe,EAC1B,IAAI,EAAE,GAAG,EACT,kBAAkB,GAAE,CAAC,SAAS,EAAE,GAAG,KAAK,GAA8B,0BAoCvE;AAED,iBAAe,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,oBAiBtE;AAED,iBAAe,MAAM,CACnB,MAAM,EAAE,uBAAuB,EAC/B,KAAK,EAAE,KAAK,EACZ,OAAO,CAAC,EAAE,OAAO,iBAMlB;AAwBD,iBAAe,eAAe,CAC5B,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,KAAK,sJA6Cb;AAED,iBAAe,2BAA2B,CACxC,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,iBAAiB,GAAG,IAAI,sJAyDrC;AAED,iBAAe,uBAAuB,CACpC,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,KAAK,EACZ,SAAS,EAAE,QAAQ,sJAqDpB;AAwHD,iBAAS,kBAAkB,CACzB,MAAM,EAAE,uBAAuB,GAC9B,qBAAqB,CAOvB;AA6CD,OAAO,EACL,0BAA0B,EAC1B,4BAA4B,EAC5B,UAAU,EACV,kBAAkB,EAClB,WAAW,EACX,mBAAmB,EACnB,kBAAkB,EAClB,UAAU,EACV,MAAM,EACN,eAAe,EACf,2BAA2B,EAC3B,uBAAuB,EACvB,kBAAkB,EAElB,cAAc,EACd,YAAY,EACZ,8BAA8B,EAC9B,wCAAwC,EACxC,4BAA4B,EAC5B,4BAA4B,EAC5B,kCAAkC,EAClC,qCAAqC,EACrC,kCAAkC,GACnC,CAAA"}