@aboutcircles/sdk 0.1.0

package/dist/avatars/OrganisationAvatar.d.ts

@@ -0,0 +1,187 @@
+import type { Address, AvatarRow, ContractRunner, TokenBalanceRow } from '@aboutcircles/sdk-types';
+import type { TransactionReceipt } from 'viem';
+import type { Core } from '@aboutcircles/sdk-core';
+import { CommonAvatar, type PathfindingOptions } from './CommonAvatar';
+/**
+ * OrganisationAvatar class implementation
+ * Provides a simplified, user-friendly wrapper around Circles protocol for organisation avatars
+ *
+ * This class represents an organisation avatar in the Circles ecosystem.
+ * Unlike human avatars, organisations cannot mint personal CRC tokens and do not require invitations.
+ * They can manage trust relationships, make transfers, and interact with group tokens.
+ */
+export declare class OrganisationAvatar extends CommonAvatar {
+    constructor(address: Address, core: Core, contractRunner?: ContractRunner, avatarInfo?: AvatarRow);
+    readonly balances: {
+        getTotal: () => Promise<bigint>;
+        getTokenBalances: () => Promise<TokenBalanceRow[]>;
+        getTotalSupply: () => Promise<bigint>;
+        /**
+         * Get the maximum amount that can be replenished (converted to unwrapped personal CRC)
+         * This calculates how much of your wrapped tokens and other tokens can be converted
+         * into your own unwrapped ERC1155 personal CRC tokens using pathfinding
+         *
+         * @param options Optional pathfinding options
+         * @returns Maximum replenishable amount in atto-circles
+         *
+         * @example
+         * ```typescript
+         * const maxReplenishable = await avatar.balances.getMaxReplenishable();
+         * console.log('Can replenish:', CirclesConverter.attoCirclesToCircles(maxReplenishable), 'CRC');
+         * ```
+         */
+        getMaxReplenishable: (options?: PathfindingOptions) => Promise<bigint>;
+        /**
+         * Replenish unwrapped personal CRC tokens by converting wrapped/other tokens
+         *
+         * This method uses pathfinding to find the best way to convert your available tokens
+         * (including wrapped tokens) into unwrapped ERC1155 personal CRC tokens.
+         *
+         * Useful when you have wrapped tokens or other people's tokens and want to
+         * convert them to your own personal unwrapped tokens for transfers.
+         *
+         * @param options Optional pathfinding options
+         * @returns Transaction receipt
+         *
+         * @example
+         * ```typescript
+         * // Convert all available wrapped/other tokens to unwrapped personal CRC
+         * const receipt = await avatar.balances.replenish();
+         * console.log('Replenished personal tokens, tx hash:', receipt.hash);
+         * ```
+         */
+        replenish: (options?: PathfindingOptions) => Promise<TransactionReceipt>;
+    };
+    readonly groupToken: {
+        /**
+         * Mint group tokens by transferring collateral to the group's mint handler
+         * Uses pathfinding to transfer tokens along the trust network, including wrapped tokens
+         *
+         * @param group The group address to mint tokens from
+         * @param amount Amount of tokens to transfer to the mint handler (in atto-circles)
+         * @returns Transaction receipt
+         *
+         * @example
+         * ```typescript
+         * // Mint group tokens by sending 100 CRC to the group's mint handler
+         * const receipt = await avatar.groupToken.mint('0xGroupAddress...', BigInt(100e18));
+         * ```
+         */
+        mint: (group: Address, amount: bigint) => Promise<TransactionReceipt>;
+        /**
+         * Get the maximum amount that can be minted for a group
+         * This calculates the maximum transferable amount to the group's mint handler
+         * including wrapped token balances
+         *
+         * @param group The group address
+         * @returns Maximum mintable amount in atto-circles
+         *
+         * @example
+         * ```typescript
+         * const maxMintable = await avatar.groupToken.getMaxMintableAmount('0xGroupAddress...');
+         * console.log('Can mint up to:', maxMintable.toString(), 'atto-circles');
+         * ```
+         */
+        getMaxMintableAmount: (group: Address) => Promise<bigint>;
+        /**
+         * Automatically redeem collateral tokens from a Base Group's treasury
+         *
+         * Performs automatic redemption by determining trusted collaterals and using pathfinder for optimal flow.
+         * Only supports Base Group types. The function uses pathfinder to determine the optimal redemption path
+         * and validates that sufficient liquidity exists before attempting redemption.
+         *
+         * Note: Organizations don't have personal tokens. This method uses the tokens held by the organization
+         * (which are other avatars' tokens or other group tokens) to redeem from the specified group.
+         *
+         * @param group The address of the Base Group from which to redeem collateral tokens
+         * @param amount The amount of group tokens to redeem for collateral (must be > 0 and <= max redeemable)
+         * @returns A Promise resolving to the transaction receipt upon successful automatic redemption
+         *
+         * @example
+         * ```typescript
+         * // Redeem 100 group tokens for collateral
+         * const receipt = await orgAvatar.groupToken.redeem('0xGroupAddress...', BigInt(100e18));
+         * ```
+         */
+        redeem: (group: Address, amount: bigint) => Promise<TransactionReceipt>;
+        properties: {
+            /**
+             * Get the owner of a specific group
+             * @param group The group address
+             * @returns The owner address of the group
+             */
+            owner: (group: Address) => Promise<Address>;
+            /**
+             * Get the mint handler address of a specific group
+             * @param group The group address
+             * @returns The mint handler address
+             */
+            mintHandler: (group: Address) => Promise<Address>;
+            /**
+             * Get the treasury (redemption handler) address of a specific group
+             * @param group The group address
+             * @returns The treasury address where redemptions are handled
+             */
+            treasury: (group: Address) => Promise<Address>;
+            /**
+             * Get the service address of a specific group
+             * @param group The group address
+             * @returns The service address
+             */
+            service: (group: Address) => Promise<Address>;
+            /**
+             * Get the fee collection address of a specific group
+             * @param group The group address
+             * @returns The fee collection address
+             */
+            feeCollection: (group: Address) => Promise<Address>;
+            /**
+             * Get all membership conditions for a specific group
+             * @param group The group address
+             * @returns Array of membership condition addresses
+             */
+            getMembershipConditions: (group: Address) => Promise<Address[]>;
+        };
+    };
+    readonly group: {
+        properties: {
+            /**
+             * Get the owner of a specific group
+             * @param group The group address
+             * @returns The owner address of the group
+             */
+            owner: (group: Address) => Promise<Address>;
+            /**
+             * Get the mint handler address of a specific group
+             * @param group The group address
+             * @returns The mint handler address
+             */
+            mintHandler: (group: Address) => Promise<Address>;
+            /**
+             * Get the treasury (redemption handler) address of a specific group
+             * @param group The group address
+             * @returns The treasury address where redemptions are handled
+             */
+            treasury: (group: Address) => Promise<Address>;
+            /**
+             * Get the service address of a specific group
+             * @param group The group address
+             * @returns The service address
+             */
+            service: (group: Address) => Promise<Address>;
+            /**
+             * Get the fee collection address of a specific group
+             * @param group The group address
+             * @returns The fee collection address
+             */
+            feeCollection: (group: Address) => Promise<Address>;
+            /**
+             * Get all membership conditions for a specific group
+             * @param group The group address
+             * @returns Array of membership condition addresses
+             */
+            getMembershipConditions: (group: Address) => Promise<Address[]>;
+        };
+    };
+}
+//# sourceMappingURL=OrganisationAvatar.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"OrganisationAvatar.d.ts","sourceRoot":"","sources":["../../src/avatars/OrganisationAvatar.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,cAAc,EACd,eAAe,EAEhB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,MAAM,CAAC;AAC/C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AAInD,OAAO,EAAE,YAAY,EAAE,KAAK,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAEvE;;;;;;;GAOG;AACH,qBAAa,kBAAmB,SAAQ,YAAY;gBAEhD,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,IAAI,EACV,cAAc,CAAC,EAAE,cAAc,EAC/B,UAAU,CAAC,EAAE,SAAS;IASxB,SAAgB,QAAQ;wBACF,OAAO,CAAC,MAAM,CAAC;gCAIP,OAAO,CAAC,eAAe,EAAE,CAAC;8BAI5B,OAAO,CAAC,MAAM,CAAC;QAIzC;;;;;;;;;;;;;WAaG;wCACmC,kBAAkB,KAAG,OAAO,CAAC,MAAM,CAAC;QAgB1E;;;;;;;;;;;;;;;;;;WAkBG;8BACyB,kBAAkB,KAAG,OAAO,CAAC,kBAAkB,CAAC;MAkB5E;IAUF,SAAgB,UAAU;QACxB;;;;;;;;;;;;;WAaG;sBAEM,OAAO,UACN,MAAM,KACb,OAAO,CAAC,kBAAkB,CAAC;QAqB9B;;;;;;;;;;;;;WAaG;sCACiC,OAAO,KAAG,OAAO,CAAC,MAAM,CAAC;QAiB7D;;;;;;;;;;;;;;;;;;;WAmBG;wBAEM,OAAO,UACN,MAAM,KACb,OAAO,CAAC,kBAAkB,CAAC;;YAyF5B;;;;eAIG;2BACkB,OAAO,KAAG,OAAO,CAAC,OAAO,CAAC;YAQ/C;;;;eAIG;iCACwB,OAAO,KAAG,OAAO,CAAC,OAAO,CAAC;YAQrD;;;;eAIG;8BACqB,OAAO,KAAG,OAAO,CAAC,OAAO,CAAC;YAQlD;;;;eAIG;6BACoB,OAAO,KAAG,OAAO,CAAC,OAAO,CAAC;YAQjD;;;;eAIG;mCAC0B,OAAO,KAAG,OAAO,CAAC,OAAO,CAAC;YAQvD;;;;eAIG;6CACoC,OAAO,KAAG,OAAO,CAAC,OAAO,EAAE,CAAC;;MASrE;IAGF,SAAgB,KAAK;;YAlFjB;;;;eAIG;2BACkB,OAAO,KAAG,OAAO,CAAC,OAAO,CAAC;YAQ/C;;;;eAIG;iCACwB,OAAO,KAAG,OAAO,CAAC,OAAO,CAAC;YAQrD;;;;eAIG;8BACqB,OAAO,KAAG,OAAO,CAAC,OAAO,CAAC;YAQlD;;;;eAIG;6BACoB,OAAO,KAAG,OAAO,CAAC,OAAO,CAAC;YAQjD;;;;eAIG;mCAC0B,OAAO,KAAG,OAAO,CAAC,OAAO,CAAC;YAQvD;;;;eAIG;6CACoC,OAAO,KAAG,OAAO,CAAC,OAAO,EAAE,CAAC;;MAcrE;CASH"}

package/dist/avatars/OrganisationAvatar.js

@@ -0,0 +1,310 @@
+import { ValidationError } from '@aboutcircles/sdk-utils';
+import { SdkError } from '../errors';
+import { BaseGroupContract } from '@aboutcircles/sdk-core';
+import { CommonAvatar } from './CommonAvatar';
+/**
+ * OrganisationAvatar class implementation
+ * Provides a simplified, user-friendly wrapper around Circles protocol for organisation avatars
+ *
+ * This class represents an organisation avatar in the Circles ecosystem.
+ * Unlike human avatars, organisations cannot mint personal CRC tokens and do not require invitations.
+ * They can manage trust relationships, make transfers, and interact with group tokens.
+ */
+export class OrganisationAvatar extends CommonAvatar {
+    constructor(address, core, contractRunner, avatarInfo) {
+        super(address, core, contractRunner, avatarInfo);
+    }
+    // ============================================================================
+    // Override Balance Methods with Organisation-Specific Features
+    // ============================================================================
+    balances = {
+        getTotal: async () => {
+            return await this.rpc.balance.getTotalBalance(this.address);
+        },
+        getTokenBalances: async () => {
+            return await this.rpc.balance.getTokenBalances(this.address);
+        },
+        getTotalSupply: async () => {
+            throw SdkError.unsupportedOperation('getTotalSupply', 'This method is not yet implemented');
+        },
+        /**
+         * Get the maximum amount that can be replenished (converted to unwrapped personal CRC)
+         * This calculates how much of your wrapped tokens and other tokens can be converted
+         * into your own unwrapped ERC1155 personal CRC tokens using pathfinding
+         *
+         * @param options Optional pathfinding options
+         * @returns Maximum replenishable amount in atto-circles
+         *
+         * @example
+         * ```typescript
+         * const maxReplenishable = await avatar.balances.getMaxReplenishable();
+         * console.log('Can replenish:', CirclesConverter.attoCirclesToCircles(maxReplenishable), 'CRC');
+         * ```
+         */
+        getMaxReplenishable: async (options) => {
+            const addr = this.address.toLowerCase();
+            // Find maximum flow from avatar to itself, targeting personal tokens as destination
+            // This effectively asks: "How much can I convert to my own personal tokens?"
+            const maxFlow = await this.rpc.pathfinder.findMaxFlow({
+                from: addr,
+                to: addr,
+                toTokens: [addr], // Destination token is sender's own personal CRC
+                useWrappedBalances: true, // Include wrapped tokens
+                ...options,
+            });
+            return maxFlow;
+        },
+        /**
+         * Replenish unwrapped personal CRC tokens by converting wrapped/other tokens
+         *
+         * This method uses pathfinding to find the best way to convert your available tokens
+         * (including wrapped tokens) into unwrapped ERC1155 personal CRC tokens.
+         *
+         * Useful when you have wrapped tokens or other people's tokens and want to
+         * convert them to your own personal unwrapped tokens for transfers.
+         *
+         * @param options Optional pathfinding options
+         * @returns Transaction receipt
+         *
+         * @example
+         * ```typescript
+         * // Convert all available wrapped/other tokens to unwrapped personal CRC
+         * const receipt = await avatar.balances.replenish();
+         * console.log('Replenished personal tokens, tx hash:', receipt.hash);
+         * ```
+         */
+        replenish: async (options) => {
+            // Construct replenish transactions using TransferBuilder
+            const transactions = await this.transferBuilder.constructReplenish(this.address, options);
+            // If no transactions needed, return early
+            if (transactions.length === 0) {
+                throw SdkError.configError('No tokens available to replenish', { message: 'You may not have any wrapped tokens or convertible tokens' });
+            }
+            // Execute the constructed transactions
+            return await this.runner.sendTransaction(transactions);
+        },
+    };
+    // ============================================================================
+    // Transfer methods are inherited from CommonAvatar
+    // ============================================================================
+    // ============================================================================
+    // Group Token Methods
+    // ============================================================================
+    groupToken = {
+        /**
+         * Mint group tokens by transferring collateral to the group's mint handler
+         * Uses pathfinding to transfer tokens along the trust network, including wrapped tokens
+         *
+         * @param group The group address to mint tokens from
+         * @param amount Amount of tokens to transfer to the mint handler (in atto-circles)
+         * @returns Transaction receipt
+         *
+         * @example
+         * ```typescript
+         * // Mint group tokens by sending 100 CRC to the group's mint handler
+         * const receipt = await avatar.groupToken.mint('0xGroupAddress...', BigInt(100e18));
+         * ```
+         */
+        mint: async (group, amount) => {
+            // Create BaseGroupContract instance to get mint handler
+            const groupContract = new BaseGroupContract({
+                address: group,
+                rpcUrl: this.core.rpcUrl,
+            });
+            const mintHandler = await groupContract.BASE_MINT_HANDLER();
+            // Use transferBuilder to construct transfer to mint handler with pathfinding
+            // Include wrapped tokens in pathfinding
+            const transactions = await this.transferBuilder.constructAdvancedTransfer(this.address, mintHandler, amount, { useWrappedBalances: true });
+            return await this.runner.sendTransaction(transactions);
+        },
+        /**
+         * Get the maximum amount that can be minted for a group
+         * This calculates the maximum transferable amount to the group's mint handler
+         * including wrapped token balances
+         *
+         * @param group The group address
+         * @returns Maximum mintable amount in atto-circles
+         *
+         * @example
+         * ```typescript
+         * const maxMintable = await avatar.groupToken.getMaxMintableAmount('0xGroupAddress...');
+         * console.log('Can mint up to:', maxMintable.toString(), 'atto-circles');
+         * ```
+         */
+        getMaxMintableAmount: async (group) => {
+            // Create BaseGroupContract instance to get mint handler
+            const groupContract = new BaseGroupContract({
+                address: group,
+                rpcUrl: this.core.rpcUrl,
+            });
+            const mintHandler = await groupContract.BASE_MINT_HANDLER();
+            // Find max flow to mint handler including wrapped tokens
+            return await this.rpc.pathfinder.findMaxFlow({
+                from: this.address.toLowerCase(),
+                to: mintHandler.toLowerCase(),
+                useWrappedBalances: true,
+            });
+        },
+        /**
+         * Automatically redeem collateral tokens from a Base Group's treasury
+         *
+         * Performs automatic redemption by determining trusted collaterals and using pathfinder for optimal flow.
+         * Only supports Base Group types. The function uses pathfinder to determine the optimal redemption path
+         * and validates that sufficient liquidity exists before attempting redemption.
+         *
+         * Note: Organizations don't have personal tokens. This method uses the tokens held by the organization
+         * (which are other avatars' tokens or other group tokens) to redeem from the specified group.
+         *
+         * @param group The address of the Base Group from which to redeem collateral tokens
+         * @param amount The amount of group tokens to redeem for collateral (must be > 0 and <= max redeemable)
+         * @returns A Promise resolving to the transaction receipt upon successful automatic redemption
+         *
+         * @example
+         * ```typescript
+         * // Redeem 100 group tokens for collateral
+         * const receipt = await orgAvatar.groupToken.redeem('0xGroupAddress...', BigInt(100e18));
+         * ```
+         */
+        redeem: async (group, amount) => {
+            group = group.toLowerCase();
+            // Get group information to validate it's a Base Group
+            const groupInfo = await this.rpc.token.getTokenInfo(group);
+            if (!groupInfo) {
+                throw SdkError.configError(`Group not found: ${group}`, { group });
+            }
+            // Validate it's a Base Group (supports CrcV2_RegisterGroup event type)
+            if (groupInfo.tokenType !== 'CrcV2_RegisterGroup') {
+                throw SdkError.unsupportedOperation('redeem', 'Only Base Groups support this method');
+            }
+            // Address of the redeemer (this organization)
+            const currentAvatar = this.address.toLowerCase();
+            // Create BaseGroupContract instance to get treasury
+            const groupContract = new BaseGroupContract({
+                address: group,
+                rpcUrl: this.core.rpcUrl,
+            });
+            const treasuryAddress = (await groupContract.BASE_TREASURY()).toLowerCase();
+            // Get list of all tokens in the treasury
+            const treasuryBalances = await this.rpc.balance.getTokenBalances(treasuryAddress);
+            const treasuryTokens = treasuryBalances
+                .filter((balance) => balance.isErc1155)
+                .map((balance) => balance.tokenAddress.toLowerCase());
+            // Get trust relationships to determine expected collateral tokens
+            const trustRelationships = await this.rpc.trust.getAggregatedTrustRelations(currentAvatar);
+            // Filter for tokens that:
+            // 1. Are mutually trusted or trusted by current avatar
+            // 2. Exist in the treasury
+            const expectedToTokens = trustRelationships
+                .filter((trustObject) => {
+                if ((trustObject.relation === 'mutuallyTrusts' || trustObject.relation === 'trusts') &&
+                    treasuryTokens.includes(trustObject.objectAvatar.toLowerCase())) {
+                    return true;
+                }
+                return false;
+            })
+                .map((trustObject) => trustObject.objectAvatar.toLowerCase());
+            // Check if enough tokens as amount - validate max redeemable
+            // Note: Organizations don't have personal tokens, so we use whatever tokens they hold
+            const maxRedeemableAmount = await this.rpc.pathfinder.findMaxFlow({
+                from: currentAvatar,
+                to: currentAvatar,
+                useWrappedBalances: false,
+                fromTokens: [group],
+                toTokens: expectedToTokens,
+            });
+            if (BigInt(maxRedeemableAmount) < amount) {
+                throw ValidationError.invalidAmount(amount, `Specified amount ${amount} exceeds max tokens flow ${maxRedeemableAmount}`);
+            }
+            // Construct the redemption transfer using TransferBuilder
+            const transactions = await this.transferBuilder.constructAdvancedTransfer(currentAvatar, currentAvatar, // Redeem to self
+            amount, {
+                useWrappedBalances: false,
+                fromTokens: [group], // Redeem from group tokens
+                toTokens: expectedToTokens, // Receive trusted collateral tokens
+            });
+            if (!transactions || transactions.length === 0) {
+                throw SdkError.operationFailed('groupToken.redeem', 'No transactions generated');
+            }
+            return await this.runner.sendTransaction(transactions);
+        },
+        properties: {
+            /**
+             * Get the owner of a specific group
+             * @param group The group address
+             * @returns The owner address of the group
+             */
+            owner: async (group) => {
+                const groupContract = new BaseGroupContract({
+                    address: group,
+                    rpcUrl: this.core.rpcUrl,
+                });
+                return await groupContract.owner();
+            },
+            /**
+             * Get the mint handler address of a specific group
+             * @param group The group address
+             * @returns The mint handler address
+             */
+            mintHandler: async (group) => {
+                const groupContract = new BaseGroupContract({
+                    address: group,
+                    rpcUrl: this.core.rpcUrl,
+                });
+                return await groupContract.BASE_MINT_HANDLER();
+            },
+            /**
+             * Get the treasury (redemption handler) address of a specific group
+             * @param group The group address
+             * @returns The treasury address where redemptions are handled
+             */
+            treasury: async (group) => {
+                const groupContract = new BaseGroupContract({
+                    address: group,
+                    rpcUrl: this.core.rpcUrl,
+                });
+                return await groupContract.BASE_TREASURY();
+            },
+            /**
+             * Get the service address of a specific group
+             * @param group The group address
+             * @returns The service address
+             */
+            service: async (group) => {
+                const groupContract = new BaseGroupContract({
+                    address: group,
+                    rpcUrl: this.core.rpcUrl,
+                });
+                return await groupContract.service();
+            },
+            /**
+             * Get the fee collection address of a specific group
+             * @param group The group address
+             * @returns The fee collection address
+             */
+            feeCollection: async (group) => {
+                const groupContract = new BaseGroupContract({
+                    address: group,
+                    rpcUrl: this.core.rpcUrl,
+                });
+                return await groupContract.feeCollection();
+            },
+            /**
+             * Get all membership conditions for a specific group
+             * @param group The group address
+             * @returns Array of membership condition addresses
+             */
+            getMembershipConditions: async (group) => {
+                const groupContract = new BaseGroupContract({
+                    address: group,
+                    rpcUrl: this.core.rpcUrl,
+                });
+                const conditions = await groupContract.getMembershipConditions();
+                return Array.from(conditions);
+            },
+        },
+    };
+    // Group methods (alias for groupToken)
+    group = {
+        properties: this.groupToken.properties,
+    };
+}

package/dist/avatars/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Avatar classes for interacting with Circles protocol
+ */
+export { CommonAvatar } from './CommonAvatar';
+export { HumanAvatar } from './HumanAvatar';
+export { OrganisationAvatar } from './OrganisationAvatar';
+export { BaseGroupAvatar } from './BaseGroupAvatar';
+export type { PathfindingOptions } from './CommonAvatar';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/avatars/index.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAC5C,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,YAAY,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/avatars/index.js

@@ -0,0 +1,7 @@
+/**
+ * Avatar classes for interacting with Circles protocol
+ */
+export { CommonAvatar } from './CommonAvatar';
+export { HumanAvatar } from './HumanAvatar';
+export { OrganisationAvatar } from './OrganisationAvatar';
+export { BaseGroupAvatar } from './BaseGroupAvatar';