@aboutcircles/sdk 0.1.0

package/dist/Sdk.js

@@ -0,0 +1,501 @@
+import { circlesConfig, Core, CirclesType, BaseGroupContract } from '@aboutcircles/sdk-core';
+import { Profiles } from '@aboutcircles/sdk-profiles';
+import { CirclesRpc, PagedQuery } from '@aboutcircles/sdk-rpc';
+import { cidV0ToHex } from '@aboutcircles/sdk-utils';
+import { HumanAvatar, OrganisationAvatar, BaseGroupAvatar } from './avatars';
+import { SdkError } from './errors';
+import { decodeEventLog } from 'viem';
+import { baseGroupFactoryAbi } from '@aboutcircles/sdk-abis';
+/**
+ * Simplified Circles SDK
+ * Provides a user-friendly API for non-crypto users with low entrance barrier
+ *
+ * @example
+ * ```typescript
+ * const sdk = new Sdk();
+ *
+ * // Register as a human
+ * const avatar = await sdk.register.asHuman('0xInviterAddress', {
+ *   name: 'Alice',
+ *   description: 'Developer'
+ * });
+ *
+ * // Get an avatar
+ * const avatar = await sdk.getAvatar('0xAvatarAddress');
+ *
+ * // Transfer tokens
+ * await avatar.transfer.direct('0xRecipient', 100);
+ *
+ * // Mint personal tokens
+ * await avatar.personalToken.mint();
+ * ```
+ */
+// @todo build common avatar inst
+// @todo implement methods to get the safe of some owner
+export class Sdk {
+    circlesConfig;
+    contractRunner;
+    senderAddress;
+    core;
+    rpc;
+    profilesClient;
+    data = {
+        getAvatar: async (address) => {
+            return await this.rpc.avatar.getAvatarInfo(address);
+        },
+        getTrustRelations: async (address) => {
+            return await this.rpc.trust.getAggregatedTrustRelations(address);
+        },
+        getBalances: async (address) => {
+            return await this.rpc.balance.getTokenBalances(address);
+        },
+    };
+    /**
+     * Create a new Sdk instance
+     *
+     * @param config Circles configuration (defaults to Gnosis Chain mainnet)
+     * @param contractRunner Optional contract runner for executing transactions
+     * @throws Error if contractRunner is provided but doesn't support sendTransaction or has no address
+     */
+    constructor(config = circlesConfig[100], contractRunner) {
+        this.circlesConfig = config;
+        this.contractRunner = contractRunner;
+        this.core = new Core(config);
+        this.rpc = new CirclesRpc(config.circlesRpcUrl);
+        this.profilesClient = new Profiles(config.profileServiceUrl);
+        // Validate and extract sender address from contract runner
+        if (contractRunner) {
+            if (!contractRunner.sendTransaction) {
+                throw SdkError.configError('Contract runner must support sendTransaction method');
+            }
+            const address = contractRunner.address;
+            if (!address) {
+                throw SdkError.configError('Cannot determine sender address from contract runner');
+            }
+            this.senderAddress = address;
+        }
+    }
+    /**
+     * Get an avatar by address
+     * Automatically detects the avatar type and returns the appropriate avatar instance
+     * @returns HumanAvatar, OrganisationAvatar, or BaseGroupAvatar depending on type
+     */
+    async getAvatar(avatarAddress) {
+        try {
+            const avatarInfo = await this.rpc.avatar.getAvatarInfo(avatarAddress);
+            // Detect avatar type and return appropriate avatar class
+            const avatarType = avatarInfo?.type;
+            if (avatarType === 'CrcV2_RegisterGroup') {
+                return new BaseGroupAvatar(avatarAddress, this.core, this.contractRunner, avatarInfo);
+            }
+            if (avatarType === 'CrcV2_RegisterOrganization') {
+                return new OrganisationAvatar(avatarAddress, this.core, this.contractRunner, avatarInfo);
+            }
+            // Default to HumanAvatar for human type
+            return new HumanAvatar(avatarAddress, this.core, this.contractRunner, avatarInfo);
+        }
+        catch (error) {
+            throw SdkError.avatarNotFound(avatarAddress);
+        }
+    }
+    /**
+     * Registration methods for creating new Circles identities
+     */
+    register = {
+        /**
+         * Register as a human in the Circles ecosystem
+         *
+         * This function:
+         * 1. Checks for pending invitations from inviters in the InvitationEscrow
+         * 2. If invitations exist, redeems one to claim escrowed tokens
+         * 3. Otherwise, checks if the specified inviter has enough unwrapped CRC
+         * 4. Creates and uploads profile data to IPFS
+         * 5. Registers the human with the profile CID
+         * 6. Returns a HumanAvatar instance for the registered account
+         *
+         * Requirements:
+         * - Contract runner must be configured to execute transactions
+         * - Either: pending invitations from inviters, OR inviter has 96+ CRC unwrapped
+         *
+         * @param inviter Address of the inviting avatar (fallback if no invitations found)
+         * @param profile Profile data with name, description, etc.
+         * @returns HumanAvatar instance for the newly registered human
+         *
+         * @example
+         * ```typescript
+         * const avatar = await sdk.register.asHuman('0xInviter', {
+         *   name: 'Alice',
+         *   description: 'Developer'
+         * });
+         * ```
+         */
+        asHuman: async (inviter, profile) => {
+            if (!this.contractRunner || !this.senderAddress) {
+                throw SdkError.missingContractRunner('Human registration');
+            }
+            const contractRunner = this.contractRunner;
+            const senderAddress = this.senderAddress;
+            // List of transactions to execute
+            const transactions = [];
+            // Step 1: Check for pending invitations in the InvitationEscrow
+            const inviters = await this.core.invitationEscrow.getInviters(senderAddress);
+            if (inviters.length > 0) {
+                // Redeem the invitation from the first available inviter
+                const redeemTx = this.core.invitationEscrow.redeemInvitation(inviters[0]);
+                transactions.push(redeemTx);
+            }
+            else {
+                // No invitations found, check if inviter has enough unwrapped CRC
+                // Minimum required: 96 CRC (after demurrage it becomes valid amount)
+                const minRequiredCRC = BigInt(96e18); // 96 CRC in atto-circles
+                // Get the token ID for the inviter's personal token
+                const tokenId = await this.core.hubV2.toTokenId(inviter);
+                // Check balance at the Inviter address
+                const balance = await this.core.hubV2.balanceOf(inviter, tokenId);
+                if (balance < minRequiredCRC) {
+                    throw SdkError.insufficientBalance('96 CRC', `${Number(balance) / 1e18} CRC`, 'unwrapped CRC');
+                }
+            }
+            // Step 2: Create and upload profile to IPFS
+            let profileCid;
+            if (typeof profile === 'string') {
+                // Profile is already a CID
+                profileCid = profile;
+            }
+            else {
+                // Create profile and upload to IPFS
+                profileCid = await this.profilesClient.create(profile);
+            }
+            // Convert CID to metadata digest hex (format expected by registerHuman)
+            const metadataDigest = cidV0ToHex(profileCid);
+            // Step 3: Call registerHuman with profile data
+            const registerTx = this.core.hubV2.registerHuman(inviter, metadataDigest);
+            transactions.push(registerTx);
+            // Step 4: Execute all transactions
+            await contractRunner.sendTransaction(transactions);
+            // Step 5: Return a HumanAvatar instance for the newly registered account
+            const avatarInfo = await this.rpc.avatar.getAvatarInfo(senderAddress);
+            return new HumanAvatar(senderAddress, this.core, contractRunner, avatarInfo // @todo remove any
+            );
+        },
+        /**
+         * Register as an organization
+         * Organizations can participate in Circles without minting personal tokens
+         * and do not require invitations to register
+         *
+         * @param profile Profile data for the organization or CID string
+         * @returns OrganisationAvatar instance for the newly registered organization
+         *
+         * @example
+         * ```typescript
+         * const orgAvatar = await sdk.register.asOrganization({
+         *   name: 'My Organization',
+         *   description: 'A Circles organization'
+         * });
+         * ```
+         */
+        asOrganization: async (profile) => {
+            if (!this.contractRunner || !this.senderAddress) {
+                throw SdkError.missingContractRunner('Organization registration');
+            }
+            const contractRunner = this.contractRunner;
+            const senderAddress = this.senderAddress;
+            // Step 1: Create and upload profile to IPFS, and extract name
+            let profileCid;
+            let profileData;
+            if (typeof profile === 'string') {
+                // Profile is already a CID - fetch it to get the name
+                profileCid = profile;
+                const fetchedProfile = await this.profilesClient.get(profileCid);
+                if (!fetchedProfile) {
+                    throw SdkError.profileOperationFailed('fetch', `Profile not found with CID: ${profileCid}`);
+                }
+                profileData = fetchedProfile;
+            }
+            else {
+                // Create profile and upload to IPFS
+                profileData = profile;
+                profileCid = await this.profilesClient.create(profile);
+            }
+            // Validate that profile has a name
+            if (!profileData.name) {
+                throw SdkError.invalidProfile('Profile must have a name field for organization registration');
+            }
+            // Convert CID to metadata digest hex (format expected by registerOrganization)
+            const metadataDigest = cidV0ToHex(profileCid);
+            // Step 2: Call registerOrganization with name and profile data
+            const registerTx = this.core.hubV2.registerOrganization(profileData.name, metadataDigest);
+            // Step 3: Execute the transaction
+            await contractRunner.sendTransaction([registerTx]);
+            // Step 4: Return an OrganisationAvatar instance for the newly registered account
+            const avatarInfo = await this.rpc.avatar.getAvatarInfo(senderAddress);
+            return new OrganisationAvatar(senderAddress, this.core, contractRunner, avatarInfo // @todo remove any
+            );
+        },
+        /**
+         * Register a base group
+         * Creates a new base group using the BaseGroupFactory and registers it in the Circles ecosystem
+         *
+         * @param owner The address that will own the newly created BaseGroup
+         * @param service The address of the service for the new BaseGroup
+         * @param feeCollection The address of the fee collection for the new BaseGroup
+         * @param initialConditions An array of initial condition addresses
+         * @param name The group name (must be 19 characters or fewer)
+         * @param symbol The group symbol (e.g., 'MYG')
+         * @param profile Profile data (name, description, images, etc.) or CID string
+         * @returns BaseGroupAvatar instance for the newly registered group
+         *
+         * @example
+         * ```typescript
+         * const groupAvatar = await sdk.register.asGroup(
+         *   '0xOwnerAddress',
+         *   '0xServiceAddress',
+         *   '0xFeeCollectionAddress',
+         *   [], // initial conditions
+         *   'My Group', // name
+         *   'MYG', // symbol
+         *   {
+         *     name: 'My Group',
+         *     description: 'A Circles base group'
+         *   }
+         * );
+         * ```
+         */
+        asGroup: async (owner, service, feeCollection, initialConditions, name, symbol, profile) => {
+            if (!this.contractRunner || !this.senderAddress) {
+                throw SdkError.missingContractRunner('Group registration');
+            }
+            const contractRunner = this.contractRunner;
+            const senderAddress = this.senderAddress;
+            // Validate name and symbol
+            if (!name) {
+                throw SdkError.invalidProfile('Name is required for group registration');
+            }
+            if (!symbol) {
+                throw SdkError.invalidProfile('Symbol is required for group registration');
+            }
+            // Validate name length (must be 19 characters or fewer)
+            if (name.length > 19) {
+                throw SdkError.invalidProfile('Group name must be 19 characters or fewer', {
+                    name,
+                    length: name.length
+                });
+            }
+            // Step 1: Create and upload profile to IPFS
+            let profileCid;
+            if (typeof profile === 'string') {
+                // Profile is already a CID
+                profileCid = profile;
+            }
+            else {
+                // Create profile and upload to IPFS
+                profileCid = await this.profilesClient.create(profile);
+            }
+            // Convert CID to metadata digest hex (format expected by createBaseGroup)
+            const metadataDigest = cidV0ToHex(profileCid);
+            // Step 2: Create the base group using the factory
+            const createGroupTx = this.core.baseGroupFactory.createBaseGroup(owner, service, feeCollection, initialConditions, name, symbol, metadataDigest);
+            // Step 3: Execute the transaction
+            const receipt = await contractRunner.sendTransaction([createGroupTx]);
+            // Step 4: Decode the BaseGroupCreated event to extract the group address
+            let groupAddress;
+            for (const log of receipt.logs) {
+                try {
+                    const decoded = decodeEventLog({
+                        abi: baseGroupFactoryAbi,
+                        data: log.data,
+                        topics: log.topics,
+                    });
+                    if (decoded.eventName === 'BaseGroupCreated') {
+                        groupAddress = decoded.args.group;
+                        break;
+                    }
+                }
+                catch {
+                    // Not the event we're looking for, continue
+                    continue;
+                }
+            }
+            if (!groupAddress) {
+                throw SdkError.transactionDataExtractionFailed('group address', 'BaseGroupCreated event not found in transaction receipt');
+            }
+            // Step 5: Return a BaseGroupAvatar instance for the newly created group
+            const avatarInfo = await this.rpc.avatar.getAvatarInfo(groupAddress);
+            return new BaseGroupAvatar(groupAddress, this.core, contractRunner, avatarInfo // @todo remove any
+            );
+        },
+    };
+    /**
+     * Profile management methods
+     */
+    profiles = {
+        /**
+         * Create and pin a profile to IPFS
+         * @param profile Profile data or CID string
+         * @returns CID of the pinned profile
+         */
+        create: async (profile) => {
+            return await this.profilesClient.create(profile);
+        },
+        /**
+         * Get a profile by CID
+         * @param cid Content identifier
+         * @returns Profile data or undefined if not found
+         */
+        get: async (cid) => {
+            return await this.profilesClient.get(cid);
+        },
+    };
+    /**
+     * Token utilities
+     */
+    tokens = {
+        /**
+         * Get an inflationary wrapper for a token
+         * @param address Avatar address
+         * @returns The ERC20 inflationary wrapper address, or zero address if not deployed
+         */
+        getInflationaryWrapper: async (address) => {
+            return await this.core.liftERC20.erc20Circles(CirclesType.Inflation, address);
+        },
+        /**
+         * Get a demurraged wrapper for a token
+         * @param address Avatar address
+         * @returns The ERC20 demurraged wrapper address, or zero address if not deployed
+         */
+        getDemurragedWrapper: async (address) => {
+            return await this.core.liftERC20.erc20Circles(CirclesType.Demurrage, address);
+        },
+        /**
+         * Get token holders for a specific token address with pagination
+         * @param tokenAddress The token address to query holders for
+         * @param limit Maximum number of results per page (default: 100)
+         * @param sortOrder Sort order for results (default: 'DESC' - highest balance first)
+         * @returns PagedQuery instance for token holders
+         *
+         * @example
+         * ```typescript
+         * const holdersQuery = sdk.tokens.getHolders('0x42cedde51198d1773590311e2a340dc06b24cb37', 10);
+         *
+         * while (await holdersQuery.queryNextPage()) {
+         *   const page = holdersQuery.currentPage!;
+         *   console.log(`Found ${page.size} holders`);
+         *   page.results.forEach(holder => {
+         *     console.log(`${holder.account}: ${holder.demurragedTotalBalance}`);
+         *   });
+         * }
+         * ```
+         */
+        getHolders: (tokenAddress, limit = 100, sortOrder = 'DESC') => {
+            return this.rpc.token.getTokenHolders(tokenAddress, limit, sortOrder);
+        },
+    };
+    /**
+     * Group utilities
+     */
+    groups = {
+        /**
+         * Get the type of a group
+         * @param avatar Group avatar address
+         * @returns Group type or undefined if not a group
+         */
+        getType: async (avatar) => {
+            throw SdkError.unsupportedOperation('groups.getType', 'not yet implemented');
+        },
+        /**
+         * Get all members of a specific group using cursor-based pagination
+         *
+         * Returns a PagedQuery instance for iterating through members of the specified group,
+         * including membership details such as expiry time and when the membership was created.
+         *
+         * @param groupAddress The address of the group to query members for
+         * @param limit Number of members per page (default: 100)
+         * @param sortOrder Sort order for results (default: 'DESC')
+         * @returns PagedQuery instance for iterating through group members
+         *
+         * @example
+         * ```typescript
+         * const query = sdk.groups.getMembers('0xGroupAddress...');
+         *
+         * // Get first page
+         * await query.queryNextPage();
+         * console.log(`${query.currentPage.size} members in the group`);
+         *
+         * // Iterate through all members
+         * while (await query.queryNextPage()) {
+         *   query.currentPage.results.forEach(membership => {
+         *     console.log(`Member: ${membership.member}`);
+         *     console.log(`Expiry: ${new Date(membership.expiryTime * 1000).toLocaleDateString()}`);
+         *   });
+         * }
+         * ```
+         */
+        getMembers: (groupAddress, limit = 100, sortOrder = 'DESC') => {
+            return this.rpc.group.getGroupMembers(groupAddress, limit, sortOrder);
+        },
+        /**
+         * Get collateral tokens in a group's treasury
+         *
+         * This convenience method fetches the treasury address of a group and returns
+         * all token balances held in the treasury.
+         *
+         * @param groupAddress The address of the group
+         * @returns Array of token balances in the treasury
+         *
+         * @example
+         * ```typescript
+         * // Get collateral tokens in a group treasury
+         * const collateral = await sdk.groups.getCollateral('0xGroupAddress...');
+         *
+         * collateral.forEach(balance => {
+         *   console.log(`Token: ${balance.tokenAddress}`);
+         *   console.log(`Balance: ${balance.circles} CRC`);
+         * });
+         * ```
+         */
+        getCollateral: async (groupAddress) => {
+            // Get the treasury address for this group
+            const groupContract = new BaseGroupContract({
+                address: groupAddress,
+                rpcUrl: this.core.rpcUrl,
+            });
+            const treasuryAddress = await groupContract.BASE_TREASURY();
+            // Get all token balances in the treasury
+            // @todo filter out the erc20 tokens
+            return await this.rpc.balance.getTokenBalances(treasuryAddress);
+        },
+        /**
+         * Get all holders of a group token using cursor-based pagination
+         *
+         * Returns all avatars that hold the specified group token, ordered by balance (highest first),
+         * including balance amounts and ownership fractions.
+         *
+         * @param groupAddress The address of the group token
+         * @param limit Maximum number of holders to return (default: 100)
+         * @returns PagedQuery instance for iterating through group token holders
+         *
+         * @example
+         * ```typescript
+         * // Get all holders of a group token
+         * const query = sdk.groups.getHolders('0xGroupAddress...');
+         *
+         * // Get first page (ordered by balance DESC)
+         * await query.queryNextPage();
+         * console.log(`${query.currentPage.size} holders of this group token`);
+         *
+         * // Iterate through all holders
+         * while (await query.queryNextPage()) {
+         *   query.currentPage.results.forEach(holder => {
+         *     const balanceInCrc = Number(holder.totalBalance) / 1e18;
+         *     console.log(`Holder: ${holder.holder}`);
+         *     console.log(`Balance: ${balanceInCrc.toFixed(2)} CRC`);
+         *     console.log(`Ownership: ${(holder.fractionOwnership * 100).toFixed(2)}%`);
+         *   });
+         * }
+         * ```
+         */
+        getHolders: (groupAddress, limit = 100) => {
+            return this.rpc.group.getGroupHolders(groupAddress, limit);
+        }
+    };
+}

package/dist/avatars/BaseGroupAvatar.d.ts

@@ -0,0 +1,97 @@
+import type { Address, ContractRunner, Profile, AvatarRow, TokenBalanceRow, AggregatedTrustRelation } from '@aboutcircles/sdk-types';
+import type { TransactionReceipt } from 'viem';
+import type { Core } from '@aboutcircles/sdk-core';
+import { CommonAvatar } from './CommonAvatar';
+/**
+ * BaseGroupAvatar class implementation
+ * Provides a simplified wrapper around Circles protocol for base group avatars
+ *
+ * This class represents a base group avatar in the Circles ecosystem and provides
+ * methods for managing trust relationships, group properties, and metadata.
+ */
+export declare class BaseGroupAvatar extends CommonAvatar {
+    private readonly baseGroup;
+    constructor(address: Address, core: Core, contractRunner?: ContractRunner, avatarInfo?: AvatarRow);
+    readonly balances: {
+        getTotal: () => Promise<bigint>;
+        getTokenBalances: () => Promise<TokenBalanceRow[]>;
+        /**
+         * Get total supply of this group's token
+         */
+        getTotalSupply: () => Promise<bigint>;
+    };
+    readonly trust: {
+        add: (avatar: Address | Address[], expiry?: bigint) => Promise<TransactionReceipt>;
+        remove: (avatar: Address | Address[]) => Promise<TransactionReceipt>;
+        isTrusting: (otherAvatar: Address) => Promise<boolean>;
+        isTrustedBy: (otherAvatar: Address) => Promise<boolean>;
+        getAll: () => Promise<AggregatedTrustRelation[]>;
+        /**
+         * Trust a batch of members with membership condition checks
+         *
+         * This is a group-specific method that validates members against membership conditions
+         * before establishing trust.
+         *
+         * @param members Array of member addresses
+         * @param expiry Trust expiry timestamp. Defaults to 0
+         * @returns Transaction response
+         *
+         * @example
+         * ```typescript
+         * // Trust multiple members with condition checks
+         * await groupAvatar.trust.addBatchWithConditions(
+         *   ['0x123...', '0x456...', '0x789...'],
+         *   BigInt(Date.now() / 1000 + 31536000) // 1 year expiry
+         * );
+         * ```
+         */
+        addBatchWithConditions: (members: Address[], expiry?: bigint) => Promise<TransactionReceipt>;
+    };
+    readonly profile: {
+        get: () => Promise<Profile | undefined>;
+        update: (profile: Profile) => Promise<string>;
+        updateMetadata: (cid: string) => Promise<TransactionReceipt>;
+        registerShortName: (nonce: number) => Promise<TransactionReceipt>;
+    };
+    readonly properties: {
+        /**
+         * Get the owner of this group
+         */
+        owner: () => Promise<Address>;
+        /**
+         * Get the mint handler address
+         */
+        mintHandler: () => Promise<Address>;
+        /**
+         * Get the service address
+         */
+        service: () => Promise<Address>;
+        /**
+         * Get the fee collection address
+         */
+        feeCollection: () => Promise<Address>;
+        /**
+         * Get all membership conditions
+         */
+        getMembershipConditions: () => Promise<Address[]>;
+    };
+    readonly setProperties: {
+        /**
+         * Set a new owner for this group
+         */
+        owner: (newOwner: Address) => Promise<TransactionReceipt>;
+        /**
+         * Set a new service address
+         */
+        service: (newService: Address) => Promise<TransactionReceipt>;
+        /**
+         * Set a new fee collection address
+         */
+        feeCollection: (newFeeCollection: Address) => Promise<TransactionReceipt>;
+        /**
+         * Enable or disable a membership condition
+         */
+        membershipCondition: (condition: Address, enabled: boolean) => Promise<TransactionReceipt>;
+    };
+}
+//# sourceMappingURL=BaseGroupAvatar.d.ts.map

package/dist/avatars/BaseGroupAvatar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BaseGroupAvatar.d.ts","sourceRoot":"","sources":["../../src/avatars/BaseGroupAvatar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,cAAc,EACd,OAAO,EACP,SAAS,EACT,eAAe,EACf,uBAAuB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,MAAM,CAAC;AAC/C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAInD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAE9C;;;;;;GAMG;AACH,qBAAa,eAAgB,SAAQ,YAAY;IAC/C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoB;gBAG5C,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,IAAI,EACV,cAAc,CAAC,EAAE,cAAc,EAC/B,UAAU,CAAC,EAAE,SAAS;IAexB,SAAgB,QAAQ;wBACF,OAAO,CAAC,MAAM,CAAC;gCAIP,OAAO,CAAC,eAAe,EAAE,CAAC;QAItD;;WAEG;8BACuB,OAAO,CAAC,MAAM,CAAC;MAIzC;IAQF,SAAyB,KAAK;sBAElB,OAAO,GAAG,OAAO,EAAE,WAClB,MAAM,KACd,OAAO,CAAC,kBAAkB,CAAC;yBAeP,OAAO,GAAG,OAAO,EAAE,KAAG,OAAO,CAAC,kBAAkB,CAAC;kCAiBxC,OAAO,KAAG,OAAO,CAAC,OAAO,CAAC;mCAIzB,OAAO,KAAG,OAAO,CAAC,OAAO,CAAC;sBAIzC,OAAO,CAAC,uBAAuB,EAAE,CAAC;QAIpD;;;;;;;;;;;;;;;;;;WAkBG;0CAEQ,OAAO,EAAE,WACT,MAAM,KACd,OAAO,CAAC,kBAAkB,CAAC;MAK9B;IAQF,SAAyB,OAAO;mBACf,OAAO,CAAC,OAAO,GAAG,SAAS,CAAC;0BAyBnB,OAAO,KAAG,OAAO,CAAC,MAAM,CAAC;8BAqBrB,MAAM,KAAG,OAAO,CAAC,kBAAkB,CAAC;mCAM/B,MAAM,KAAG,OAAO,CAAC,kBAAkB,CAAC;MAIrE;IAMF,SAAgB,UAAU;QACxB;;WAEG;qBACc,OAAO,CAAC,OAAO,CAAC;QAIjC;;WAEG;2BACoB,OAAO,CAAC,OAAO,CAAC;QAIvC;;WAEG;uBACgB,OAAO,CAAC,OAAO,CAAC;QAInC;;WAEG;6BACsB,OAAO,CAAC,OAAO,CAAC;QAIzC;;WAEG;uCACgC,OAAO,CAAC,OAAO,EAAE,CAAC;MAIrD;IAMF,SAAgB,aAAa;QAC3B;;WAEG;0BACqB,OAAO,KAAG,OAAO,CAAC,kBAAkB,CAAC;QAK7D;;WAEG;8BACyB,OAAO,KAAG,OAAO,CAAC,kBAAkB,CAAC;QAKjE;;WAEG;0CACqC,OAAO,KAAG,OAAO,CAAC,kBAAkB,CAAC;QAK7E;;WAEG;yCAEU,OAAO,WACT,OAAO,KACf,OAAO,CAAC,kBAAkB,CAAC;MAI9B;CACH"}