@towns-labs/web3 2.0.1

package/dist/space-dapp/SpaceDapp.js

@@ -0,0 +1,1260 @@
+import { EntitlementModuleType, isPermission, isUpdateChannelStatusParams, Permission, } from '../types/ContractTypes';
+import { computeDelegatorsForProvider } from '../delegate-registry/DelegateRegistry';
+import { ethers } from 'ethers';
+import { LOCALHOST_CHAIN_ID } from '../utils/Web3Constants';
+import { EVERYONE_ADDRESS, stringifyChannelMetadataJSON, NoEntitledWalletError, ETH_ADDRESS, } from '../utils/ut';
+import { SpaceRegistrar } from '../space-registrar/SpaceRegistrar';
+import { evaluateOperationsForEntitledWallet, ruleDataToOperations, findEthereumProviders, } from '../space/entitlements/entitlement';
+import { createEntitlementStruct, createLegacyEntitlementStruct, convertRuleDataV1ToV2, } from '../space/entitlements/ConvertersEntitlements';
+import { RiverAirdropDapp } from '../airdrop/RiverAirdropDapp';
+import { WalletLink, INVALID_ADDRESS } from '../wallet-link/WalletLink';
+import { UNKNOWN_ERROR } from '../BaseContractShim';
+import { PricingModules } from '../pricing-modules/PricingModules';
+import { dlogger, isTestEnv } from '@towns-labs/utils';
+import { PlatformRequirements } from '../platform-requirements/PlatformRequirements';
+import { EntitlementCache } from '../cache/EntitlementCache';
+import { SimpleCache } from '../cache/SimpleCache';
+import { ITippingShim } from '../space/ITippingShim';
+import { SpaceOwner } from '../space-owner/SpaceOwner';
+import { TownsToken } from '../towns-token/TownsToken';
+import { wrapTransaction } from '../space-dapp/wrapTransaction';
+import { BaseRegistry } from '../base-registry/BaseRegistry';
+import { Keyable } from '../cache/Keyable';
+const logger = dlogger('csb:SpaceDapp:debug');
+class EntitlementDataCacheResult {
+    value;
+    cacheHit;
+    isPositive;
+    constructor(value) {
+        this.value = value;
+        this.cacheHit = false;
+        this.isPositive = true;
+    }
+}
+class EntitledWalletCacheResult {
+    value;
+    cacheHit;
+    isPositive;
+    constructor(value) {
+        this.value = value;
+        this.cacheHit = false;
+        this.isPositive = value !== undefined;
+    }
+}
+class BooleanCacheResult {
+    value;
+    cacheHit;
+    isPositive;
+    constructor(value) {
+        this.value = value;
+        this.cacheHit = false;
+        this.isPositive = value;
+    }
+}
+function ensureHexPrefix(value) {
+    return value.startsWith('0x') ? value : `0x${value}`;
+}
+const EmptyXchainConfig = {
+    supportedRpcUrls: {},
+    etherNativeNetworkIds: [],
+    ethereumNetworkIds: [],
+};
+export class SpaceDapp {
+    isLegacySpaceCache;
+    config;
+    baseRegistry;
+    provider;
+    spaceRegistrar;
+    pricingModules;
+    walletLink;
+    platformRequirements;
+    airdrop;
+    spaceOwner;
+    townsToken;
+    entitlementCache;
+    entitledWalletCache;
+    entitlementEvaluationCache;
+    bannedTokenIdsCache;
+    ownerOfTokenCache;
+    isBannedTokenCache;
+    constructor(config, provider, createStorageFn) {
+        this.isLegacySpaceCache = new Map();
+        this.config = config;
+        this.provider = provider;
+        this.baseRegistry = new BaseRegistry(config, provider);
+        this.spaceRegistrar = new SpaceRegistrar(config, provider, createStorageFn);
+        this.walletLink = new WalletLink(config, provider);
+        this.pricingModules = new PricingModules(config, provider);
+        this.platformRequirements = new PlatformRequirements(config.addresses.spaceFactory, provider);
+        this.spaceOwner = new SpaceOwner(config.addresses.spaceOwner, provider, createStorageFn);
+        if (config.addresses.utils.towns) {
+            this.townsToken = new TownsToken(config.addresses.utils.towns, provider, createStorageFn);
+        }
+        this.airdrop = new RiverAirdropDapp(config, provider);
+        // For RPC providers that pool for events, we need to set the polling interval to a lower value
+        // so that we don't miss events that may be emitted in between polling intervals. The Ethers
+        // default is 4000ms, which is based on the assumption of 12s mainnet blocktimes.
+        if ('pollingInterval' in provider && typeof provider.pollingInterval === 'number') {
+            provider.pollingInterval = 250;
+        }
+        const isLocalDev = isTestEnv() || config.chainId === LOCALHOST_CHAIN_ID;
+        const entitlementCacheOpts = {
+            positiveCacheTTLSeconds: isLocalDev ? 5 : 15 * 60,
+            negativeCacheTTLSeconds: 2,
+            createStorageFn,
+        };
+        const bannedCacheOpts = {
+            ttlSeconds: isLocalDev ? 5 : 15 * 60,
+            createStorageFn,
+        };
+        // The caching of positive entitlements is shorter on both the node and client.
+        this.entitlementCache = new EntitlementCache({
+            positiveCacheTTLSeconds: isLocalDev ? 5 : 15,
+            negativeCacheTTLSeconds: 2,
+            createStorageFn,
+        });
+        this.entitledWalletCache = new EntitlementCache({
+            ...entitlementCacheOpts,
+        });
+        this.entitlementEvaluationCache = new EntitlementCache({
+            ...entitlementCacheOpts,
+        });
+        this.bannedTokenIdsCache = new SimpleCache({
+            ...bannedCacheOpts,
+        });
+        this.ownerOfTokenCache = new SimpleCache({
+            ...bannedCacheOpts,
+        });
+        this.isBannedTokenCache = new SimpleCache({
+            ...bannedCacheOpts,
+        });
+    }
+    async isLegacySpace(spaceId) {
+        const cachedValue = this.isLegacySpaceCache.get(spaceId);
+        if (cachedValue !== undefined) {
+            return cachedValue;
+        }
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        // Legacy spaces do not have RuleEntitlementV2
+        const maybeShim = await space.findEntitlementByType(EntitlementModuleType.RuleEntitlementV2);
+        const isLegacy = maybeShim === null;
+        this.isLegacySpaceCache.set(spaceId, isLegacy);
+        return isLegacy;
+    }
+    async addRoleToChannel(spaceId, channelNetworkId, roleId, signer, txnOpts) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const channelId = ensureHexPrefix(channelNetworkId);
+        return wrapTransaction(() => space.Channels.write(signer).addRoleToChannel(channelId, roleId), txnOpts);
+    }
+    async banWalletAddress(spaceId, walletAddress, signer, txnOpts) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const token = await space.ERC721AQueryable.read
+            .tokensOfOwner(walletAddress)
+            .then((tokens) => tokens.at(0));
+        if (!token) {
+            throw new Error(`Wallet address "${walletAddress}" is not a member of space "${spaceId}".`);
+        }
+        // Call ban
+        const tx = await wrapTransaction(() => space.Banning.write(signer).ban(token), txnOpts);
+        await this.updateCacheAfterBanOrUnBan(spaceId, token);
+        return tx;
+    }
+    async unbanWalletAddress(spaceId, walletAddress, signer, txnOpts) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const token = await space.ERC721AQueryable.read
+            .tokensOfOwner(walletAddress)
+            .then((tokens) => tokens.at(0));
+        if (!token) {
+            throw new Error(`Wallet address "${walletAddress}" is not a member of space "${spaceId}".`);
+        }
+        // Call unban
+        const tx = await wrapTransaction(() => space.Banning.write(signer).unban(token), txnOpts);
+        await this.updateCacheAfterBanOrUnBan(spaceId, token);
+        return tx;
+    }
+    async updateCacheAfterBanOrUnBan(spaceId, tokenId) {
+        await Promise.all([
+            this.bannedTokenIdsCache.remove(Keyable.bannedTokenIds(spaceId)),
+            this.ownerOfTokenCache.remove(Keyable.ownerOfToken(spaceId, tokenId)),
+            this.isBannedTokenCache.remove(Keyable.isTokenBanned(spaceId, tokenId)),
+        ]);
+    }
+    async walletAddressIsBanned(spaceId, walletAddress, opts) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const tokenId = await space.ERC721AQueryable.read
+            .tokensOfOwner(walletAddress)
+            .then((tokens) => tokens.at(0));
+        if (!tokenId) {
+            return false;
+        }
+        const isBanned = await this.isBannedTokenCache.executeUsingCache(Keyable.isTokenBanned(spaceId, tokenId), async () => space.Banning.read.isBanned(tokenId), opts);
+        return isBanned;
+    }
+    async bannedWalletAddresses(spaceId) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        // 1. Get banned token IDs
+        const bannedTokenIds = await this.bannedTokenIdsCache.executeUsingCache(Keyable.bannedTokenIds(spaceId), async () => {
+            const currentSpace = this.getSpace(spaceId);
+            if (!currentSpace) {
+                throw new Error(`Space with spaceId "${spaceId}" is not found inside cache fetch.`);
+            }
+            return currentSpace.Banning.read.banned();
+        });
+        // 2. Get owner for each banned token ID using cache and multicall for efficiency
+        const ownerMap = new Map(); // tokenId.toString() -> ownerAddress
+        const tokenIdsToFetch = [];
+        // Check cache first - parallel lookups for remote storage efficiency
+        const cacheResults = await Promise.all(bannedTokenIds.map(async (tokenId) => {
+            const cacheKey = Keyable.ownerOfToken(spaceId, tokenId);
+            const cachedOwner = await this.ownerOfTokenCache.get(cacheKey);
+            return { tokenId, cachedOwner };
+        }));
+        for (const { tokenId, cachedOwner } of cacheResults) {
+            if (cachedOwner) {
+                ownerMap.set(tokenId.toString(), cachedOwner);
+            }
+            else {
+                tokenIdsToFetch.push(tokenId);
+            }
+        }
+        // Fetch non-cached owners
+        if (tokenIdsToFetch.length > 0 && space) {
+            const calls = tokenIdsToFetch.map((tokenId) => space.ERC721A.interface.encodeFunctionData('ownerOf', [tokenId]));
+            try {
+                const results = await space.Multicall.read.callStatic.multicall(calls);
+                const cacheWritePromises = [];
+                for (const [index, resultData] of results.entries()) {
+                    const tokenId = tokenIdsToFetch[index];
+                    // Attempt to decode each result
+                    try {
+                        if (resultData && resultData !== '0x') {
+                            const ownerAddress = space.ERC721A.interface.decodeFunctionResult('ownerOf', resultData)[0];
+                            if (ethers.utils.isAddress(ownerAddress)) {
+                                ownerMap.set(tokenId.toString(), ownerAddress);
+                                // Collect cache write promises for parallel execution
+                                cacheWritePromises.push(this.ownerOfTokenCache.add(Keyable.ownerOfToken(spaceId, tokenId), ownerAddress));
+                            }
+                            else {
+                                logger.log(`bannedWalletAddresses: Multicall: Decoded ownerOf result is not a valid address for token ${tokenId.toString()} in space ${spaceId}: ${ownerAddress}`);
+                            }
+                        }
+                        else {
+                            logger.log(`bannedWalletAddresses: Multicall: ownerOf call returned empty data for token ${tokenId.toString()} in space ${spaceId}`);
+                        }
+                    }
+                    catch (decodeError) {
+                        logger.error(`bannedWalletAddresses: Multicall: Failed to decode ownerOf result for token ${tokenId.toString()} in space ${spaceId}`, decodeError instanceof Error
+                            ? decodeError.message
+                            : String(decodeError));
+                    }
+                }
+                // Write all cache entries in parallel
+                await Promise.all(cacheWritePromises);
+            }
+            catch (multiCallError) {
+                logger.error(`Multicall execution failed for space ${spaceId}. This likely means one of the ownerOf calls reverted.`, multiCallError instanceof Error
+                    ? multiCallError.message
+                    : String(multiCallError));
+            }
+        }
+        // Return the unique owner addresses combined from cache and multicall
+        return Array.from(new Set(ownerMap.values()));
+    }
+    async createLegacySpace(params, signer, txnOpts) {
+        const spaceInfo = {
+            name: params.spaceName,
+            uri: params.uri,
+            membership: params.membership,
+            channel: {
+                metadata: params.channelName || '',
+            },
+            shortDescription: params.shortDescription ?? '',
+            longDescription: params.longDescription ?? '',
+        };
+        return wrapTransaction(() => this.spaceRegistrar.LegacySpaceArchitect.write(signer).createSpace(spaceInfo), txnOpts);
+    }
+    async createSpace(params, signer, txnOpts) {
+        return wrapTransaction(() => {
+            const createSpaceFunction = this.spaceRegistrar.CreateSpace.write(signer)['createSpace((string,string,string,string,((string,string,uint256,uint256,uint64,address,address,uint256,address),(bool,address[],bytes,bool),string[]),(string)))'];
+            return createSpaceFunction({
+                name: params.spaceName,
+                uri: params.uri,
+                shortDescription: params.shortDescription || '',
+                longDescription: params.longDescription || '',
+                membership: params.membership,
+                channel: {
+                    metadata: params.channelName || '',
+                },
+            });
+        }, txnOpts);
+    }
+    async createChannel(spaceId, channelName, channelDescription, channelNetworkId, roleIds, signer, txnOpts) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const channelId = ensureHexPrefix(channelNetworkId);
+        return wrapTransaction(() => space.Channels.write(signer).createChannel(channelId, stringifyChannelMetadataJSON({
+            name: channelName,
+            description: channelDescription,
+        }), roleIds), txnOpts);
+    }
+    async createChannelWithPermissionOverrides(spaceId, channelName, channelDescription, channelNetworkId, roles, signer, txnOpts) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const channelId = ensureHexPrefix(channelNetworkId);
+        return wrapTransaction(() => space.Channels.write(signer).createChannelWithOverridePermissions(channelId, stringifyChannelMetadataJSON({
+            name: channelName,
+            description: channelDescription,
+        }), roles), txnOpts);
+    }
+    async legacyCreateRole(spaceId, roleName, permissions, users, ruleData, signer, txnOpts) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const entitlements = await createLegacyEntitlementStruct(space, users, ruleData);
+        return wrapTransaction(() => space.Roles.write(signer).createRole(roleName, permissions, entitlements), txnOpts);
+    }
+    async createRole(spaceId, roleName, permissions, users, ruleData, signer, txnOpts) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const entitlements = await createEntitlementStruct(space, users, ruleData);
+        return wrapTransaction(() => space.Roles.write(signer).createRole(roleName, permissions, entitlements), txnOpts);
+    }
+    async deleteRole(spaceId, roleId, signer, txnOpts) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        return wrapTransaction(() => space.Roles.write(signer).removeRole(roleId), txnOpts);
+    }
+    async getChannels(spaceId) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        return space.getChannels();
+    }
+    async getChannelDetails(spaceId, channelNetworkId) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const channelId = ensureHexPrefix(channelNetworkId);
+        return space.getChannel(channelId);
+    }
+    async getPermissionsByRoleId(spaceId, roleId) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        return space.getPermissionsByRoleId(roleId);
+    }
+    async getRole(spaceId, roleId) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        return space.getRole(roleId);
+    }
+    async getRoles(spaceId) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const roles = await space.Roles.read.getRoles();
+        return roles.map((role) => ({
+            roleId: role.id.toNumber(),
+            name: role.name,
+        }));
+    }
+    async getSpaceInfo(spaceId) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            return undefined;
+        }
+        const [owner, disabled, spaceInfo] = await Promise.all([
+            space.Ownable.getOwner(),
+            space.Pausable.read.paused(),
+            this.spaceOwner.getSpaceInfo(space.Address),
+        ]);
+        return {
+            address: space.Address,
+            networkId: space.SpaceId,
+            name: spaceInfo.name ?? '',
+            owner,
+            disabled,
+            uri: spaceInfo.uri ?? '',
+            tokenId: ethers.BigNumber.from(spaceInfo.tokenId).toString(),
+            createdAt: ethers.BigNumber.from(spaceInfo.createdAt).toString(),
+            shortDescription: spaceInfo.shortDescription ?? '',
+            longDescription: spaceInfo.longDescription ?? '',
+        };
+    }
+    async decodeEntitlementData(space, entitlementData) {
+        const entitlements = entitlementData.map((x) => ({
+            entitlementType: x.entitlementType,
+            ruleEntitlement: undefined,
+            userEntitlement: undefined,
+        }));
+        const [userEntitlementShim, ruleEntitlementShim, ruleEntitlementV2Shim] = (await Promise.all([
+            space.findEntitlementByType(EntitlementModuleType.UserEntitlement),
+            space.findEntitlementByType(EntitlementModuleType.RuleEntitlement),
+            space.findEntitlementByType(EntitlementModuleType.RuleEntitlementV2),
+        ]));
+        for (let i = 0; i < entitlementData.length; i++) {
+            const entitlement = entitlementData[i];
+            if (entitlement.entitlementType ===
+                EntitlementModuleType.RuleEntitlement) {
+                if (ruleEntitlementShim)
+                    entitlements[i].entitlementType = EntitlementModuleType.RuleEntitlement;
+                const decodedData = ruleEntitlementShim?.decodeGetRuleData(entitlement.entitlementData);
+                if (decodedData) {
+                    entitlements[i].ruleEntitlement = {
+                        kind: 'v1',
+                        rules: decodedData,
+                    };
+                }
+            }
+            else if (entitlement.entitlementType ===
+                EntitlementModuleType.RuleEntitlementV2) {
+                entitlements[i].entitlementType = EntitlementModuleType.RuleEntitlementV2;
+                const decodedData = ruleEntitlementV2Shim?.decodeGetRuleData(entitlement.entitlementData);
+                if (decodedData) {
+                    entitlements[i].ruleEntitlement = {
+                        kind: 'v2',
+                        rules: decodedData,
+                    };
+                }
+            }
+            else if (entitlement.entitlementType ===
+                EntitlementModuleType.UserEntitlement) {
+                entitlements[i].entitlementType = EntitlementModuleType.UserEntitlement;
+                const decodedData = userEntitlementShim?.decodeGetAddresses(entitlement.entitlementData);
+                if (decodedData) {
+                    entitlements[i].userEntitlement = decodedData;
+                }
+            }
+            else {
+                throw new Error('Unknown entitlement type');
+            }
+        }
+        return entitlements;
+    }
+    async getEntitlementsForPermission(spaceId, permission) {
+        const { value } = await this.entitlementCache.executeUsingCache(Keyable.spaceEntitlement(spaceId, permission), async () => {
+            const entitlementData = await this.getEntitlementsForPermissionUncached(spaceId, permission);
+            return new EntitlementDataCacheResult(entitlementData);
+        });
+        return value;
+    }
+    async getEntitlementsForPermissionUncached(spaceId, permission) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const entitlementData = await space.EntitlementDataQueryable.read.getEntitlementDataByPermission(permission);
+        return await this.decodeEntitlementData(space, entitlementData);
+    }
+    async getChannelEntitlementsForPermission(spaceId, channelId, permission) {
+        const { value } = await this.entitlementCache.executeUsingCache(Keyable.channelEntitlement(spaceId, channelId, permission), async () => {
+            const entitlementData = await this.getChannelEntitlementsForPermissionUncached(spaceId, channelId, permission);
+            return new EntitlementDataCacheResult(entitlementData);
+        });
+        return value;
+    }
+    async getChannelEntitlementsForPermissionUncached(spaceId, channelId, permission) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const entitlementData = await space.EntitlementDataQueryable.read.getChannelEntitlementDataByPermission(channelId, permission);
+        return await this.decodeEntitlementData(space, entitlementData);
+    }
+    async getLinkedWallets(wallet) {
+        let linkedWallets = await this.walletLink.getLinkedWallets(wallet);
+        // If there are no linked wallets, consider that the wallet may be linked to another root key.
+        if (linkedWallets.length === 0) {
+            const possibleRoot = await this.walletLink.getRootKeyForWallet(wallet);
+            if (possibleRoot !== INVALID_ADDRESS) {
+                linkedWallets = await this.walletLink.getLinkedWallets(possibleRoot);
+                return [possibleRoot, ...linkedWallets];
+            }
+        }
+        return [wallet, ...linkedWallets];
+    }
+    async getMainnetDelegationsForLinkedWallets(linkedWallets, config) {
+        const delegatorSet = new Set();
+        const ethProviders = await findEthereumProviders(config);
+        for (const provider of ethProviders) {
+            const delegators = await computeDelegatorsForProvider(provider, linkedWallets);
+            for (const delegator of delegators) {
+                delegatorSet.add(delegator);
+            }
+        }
+        return delegatorSet;
+    }
+    async getLinkedWalletsWithDelegations(wallet, config) {
+        const linkedWallets = await this.getLinkedWallets(wallet);
+        const allWallets = new Set(linkedWallets);
+        const delegators = await this.getMainnetDelegationsForLinkedWallets(linkedWallets, config);
+        return [...new Set([...allWallets, ...delegators])];
+    }
+    async evaluateEntitledWallet(space, rootKey, allWallets, entitlements, xchainConfig) {
+        const { isExpired } = await space.getMembershipStatus(allWallets);
+        // otherwise you're trying to do something with an expired membership
+        if (isExpired) {
+            return;
+        }
+        const isEveryOneSpace = entitlements.some((e) => e.userEntitlement?.includes(EVERYONE_ADDRESS));
+        if (isEveryOneSpace) {
+            return rootKey;
+        }
+        // Evaluate all user entitlements first, as they do not require external calls.
+        for (const entitlement of entitlements) {
+            for (const user of allWallets) {
+                if (entitlement.userEntitlement?.includes(user)) {
+                    return user;
+                }
+            }
+        }
+        // Accumulate all RuleDataV1 entitlements and convert to V2s.
+        const ruleEntitlements = entitlements
+            .filter((x) => x.entitlementType === EntitlementModuleType.RuleEntitlement &&
+            x.ruleEntitlement?.kind == 'v1')
+            .map((x) => convertRuleDataV1ToV2(x.ruleEntitlement.rules));
+        // Add all RuleDataV2 entitlements.
+        ruleEntitlements.push(...entitlements
+            .filter((x) => x.entitlementType === EntitlementModuleType.RuleEntitlementV2 &&
+            x.ruleEntitlement?.kind == 'v2')
+            .map((x) => x.ruleEntitlement.rules));
+        return await Promise.any(ruleEntitlements.map(async (ruleData) => {
+            if (!ruleData) {
+                throw new Error('Rule data not found');
+            }
+            const operations = ruleDataToOperations(ruleData);
+            const result = await evaluateOperationsForEntitledWallet(operations, allWallets, xchainConfig);
+            if (result !== ethers.constants.AddressZero) {
+                return result;
+            }
+            // This is not a true error, but is used here so that the Promise.any will not
+            // resolve with an unentitled wallet.
+            throw new NoEntitledWalletError();
+        })).catch(NoEntitledWalletError.throwIfRuntimeErrors);
+    }
+    /**
+     * Checks if user has a wallet entitled to join a space based on the minter role rule entitlements
+     */
+    async getEntitledWalletForJoiningSpace(spaceId, rootKey, xchainConfig, skipCache = false) {
+        const key = Keyable.spaceEntitlementEvaluation(spaceId, rootKey, Permission.JoinSpace);
+        const { value } = await this.entitledWalletCache.executeUsingCache(key, async () => {
+            const entitledWallet = await this.getEntitledWalletForJoiningSpaceUncached(spaceId, rootKey, xchainConfig);
+            return new EntitledWalletCacheResult(entitledWallet);
+        }, { skipCache });
+        return value;
+    }
+    async getEntitledWalletForJoiningSpaceUncached(spaceId, rootKey, xchainConfig) {
+        const allWallets = await this.getLinkedWalletsWithDelegations(rootKey, xchainConfig);
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const owner = await space.Ownable.getOwner();
+        // Space owner is entitled to all channels
+        if (allWallets.includes(owner)) {
+            return owner;
+        }
+        const promises = allWallets.map(async (wallet) => this.walletAddressIsBanned(spaceId, wallet).then((r) => r === true ? true : Promise.reject(new Error('Wallet is not banned'))));
+        try {
+            // If any promise resolves (meaning a wallet IS banned), this succeeds.
+            await Promise.any(promises);
+            return;
+        }
+        catch (error) {
+            // all promises rejected, meaning no wallets are banned
+        }
+        const entitlements = await this.getEntitlementsForPermission(spaceId, Permission.JoinSpace);
+        return await this.evaluateEntitledWallet(space, rootKey, allWallets, entitlements, xchainConfig);
+    }
+    async isEntitledToSpace(spaceId, userId, permission, skipCache = false) {
+        const key = Keyable.spaceEntitlementEvaluation(spaceId, userId, permission);
+        const { value } = await this.entitlementEvaluationCache.executeUsingCache(key, async () => {
+            const isEntitled = await this.isEntitledToSpaceUncached(spaceId, userId, permission);
+            return new BooleanCacheResult(isEntitled);
+        }, { skipCache });
+        return value;
+    }
+    async isAppInstalled(spaceId, botAppAddress) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            return false;
+        }
+        return space.AppAccount.read.isAppInstalled(botAppAddress);
+    }
+    async isAppEntitled(spaceId, botId, botAppAddress, permission) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            return false;
+        }
+        const permissionBytes = ethers.utils.formatBytes32String(permission);
+        return space.AppAccount.read.isAppEntitled(botAppAddress, botId, permissionBytes);
+    }
+    async isEntitledToSpaceUncached(spaceId, user, permission) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            return false;
+        }
+        if (permission === Permission.JoinSpace) {
+            throw new Error('use getEntitledWalletForJoiningSpace instead of isEntitledToSpace');
+        }
+        return space.Entitlements.read.isEntitledToSpace(user, permission);
+    }
+    async isEntitledToChannel(spaceId, channelNetworkId, userId, permission, xchainConfig = EmptyXchainConfig, skipCache = false) {
+        const key = Keyable.channelEntitlementEvaluation(spaceId, channelNetworkId, userId, permission);
+        const { value } = await this.entitlementEvaluationCache.executeUsingCache(key, async () => {
+            const isEntitled = await this.isEntitledToChannelUncached(spaceId, channelNetworkId, userId, permission, xchainConfig);
+            return new BooleanCacheResult(isEntitled);
+        }, { skipCache });
+        return value;
+    }
+    async isEntitledToChannelUncached(spaceId, channelNetworkId, user, permission, xchainConfig) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            return false;
+        }
+        const channelId = ensureHexPrefix(channelNetworkId);
+        const linkedWallets = await this.getLinkedWalletsWithDelegations(user, xchainConfig);
+        const owner = await space.Ownable.getOwner();
+        // Space owner is entitled to all channels
+        if (linkedWallets.includes(owner)) {
+            return true;
+        }
+        const promises = linkedWallets.map(async (wallet) => this.walletAddressIsBanned(spaceId, wallet).then((r) => r === true ? true : Promise.reject(new Error('Wallet is not banned'))));
+        try {
+            // If any promise resolves (meaning a wallet IS banned), this succeeds.
+            await Promise.any(promises);
+            return false;
+        }
+        catch (error) {
+            // all promises rejected, meaning no wallets are banned
+        }
+        const entitlements = await this.getChannelEntitlementsForPermission(spaceId, channelId, permission);
+        const entitledWallet = await this.evaluateEntitledWallet(space, user, linkedWallets, entitlements, xchainConfig);
+        return entitledWallet !== undefined;
+    }
+    parseSpaceFactoryError(error) {
+        if (!this.spaceRegistrar.SpaceArchitect) {
+            throw new Error('SpaceArchitect is not deployed properly.');
+        }
+        const decodedErr = this.spaceRegistrar.SpaceArchitect.parseError(error);
+        logger.error(decodedErr);
+        return decodedErr;
+    }
+    parseSpaceOwnerError(error) {
+        if (!this.spaceOwner) {
+            throw new Error('SpaceOwner is not deployed properly.');
+        }
+        const decodedErr = this.spaceOwner.parseError(error);
+        logger.error(decodedErr);
+        return decodedErr;
+    }
+    parseSpaceError(spaceId, error) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const decodedErr = space.parseError(error);
+        logger.error(decodedErr);
+        return decodedErr;
+    }
+    /**
+     * Attempts to parse an error against all contracts
+     * If you're error is not showing any data with this call, make sure the contract is listed either in parseSpaceError or nonSpaceContracts
+     * @param args
+     * @returns
+     */
+    parseAllContractErrors(args) {
+        let err;
+        if (args.spaceId) {
+            err = this.parseSpaceError(args.spaceId, args.error);
+        }
+        if (err && err?.name !== UNKNOWN_ERROR) {
+            return err;
+        }
+        err = this.spaceRegistrar.SpaceArchitect.parseError(args.error);
+        if (err?.name !== UNKNOWN_ERROR) {
+            return err;
+        }
+        const nonSpaceContracts = [this.airdrop.riverPoints, this.pricingModules, this.walletLink];
+        for (const contract of nonSpaceContracts) {
+            if (!contract) {
+                continue;
+            }
+            err = contract.parseError(args.error);
+            if (err?.name !== UNKNOWN_ERROR) {
+                return err;
+            }
+        }
+        return err;
+    }
+    async parseSpaceLogs(spaceId, logs) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        return logs.map((spaceLog) => {
+            try {
+                return space.parseLog(spaceLog);
+            }
+            catch (err) {
+                logger.error(err);
+                return;
+            }
+        });
+    }
+    async updateChannel(params, signer, txnOpts) {
+        const space = this.getSpace(params.spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${params.spaceId}" is not found.`);
+        }
+        const encodedCallData = await this.encodedUpdateChannelData(space, params);
+        return wrapTransaction(() => space.Multicall.write(signer).multicall(encodedCallData), txnOpts);
+    }
+    async encodedUpdateChannelData(space, params) {
+        const channelId = ensureHexPrefix(params.channelId);
+        if (isUpdateChannelStatusParams(params)) {
+            // When enabling or disabling channels, passing names and roles is not required.
+            // To ensure the contract accepts this exception, the metadata argument should be left empty.
+            return [
+                space.Channels.interface.encodeFunctionData('updateChannel', [channelId, '', true]),
+            ];
+        }
+        // data for the multicall
+        const encodedCallData = [];
+        // update the channel metadata
+        encodedCallData.push(space.Channels.interface.encodeFunctionData('updateChannel', [
+            channelId,
+            stringifyChannelMetadataJSON({
+                name: params.channelName,
+                description: params.channelDescription,
+            }),
+            params.disabled ?? false, // default to false
+        ]));
+        // update any channel role changes
+        const encodedUpdateChannelRoles = await this.encodeUpdateChannelRoles(space, params.channelId, params.roleIds);
+        for (const callData of encodedUpdateChannelRoles) {
+            encodedCallData.push(callData);
+        }
+        return encodedCallData;
+    }
+    async removeChannel(params, signer, txnOpts) {
+        const space = this.getSpace(params.spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${params.spaceId}" is not found.`);
+        }
+        return wrapTransaction(() => space.Channels.write(signer).removeChannel(params.channelId), txnOpts);
+    }
+    async legacyUpdateRole(params, signer, txnOpts) {
+        const space = this.getSpace(params.spaceNetworkId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${params.spaceNetworkId}" is not found.`);
+        }
+        const updatedEntitlemets = await this.createLegacyUpdatedEntitlements(space, params);
+        return wrapTransaction(() => space.Roles.write(signer).updateRole(params.roleId, params.roleName, params.permissions, updatedEntitlemets), txnOpts);
+    }
+    async updateRole(params, signer, txnOpts) {
+        const space = this.getSpace(params.spaceNetworkId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${params.spaceNetworkId}" is not found.`);
+        }
+        const updatedEntitlemets = await this.createUpdatedEntitlements(space, params);
+        return wrapTransaction(() => space.Roles.write(signer).updateRole(params.roleId, params.roleName, params.permissions, updatedEntitlemets), txnOpts);
+    }
+    async getChannelPermissionOverrides(spaceId, roleId, channelNetworkId) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const channelId = ensureHexPrefix(channelNetworkId);
+        return (await space.Roles.read.getChannelPermissionOverrides(roleId, channelId)).filter(isPermission);
+    }
+    async setChannelPermissionOverrides(params, signer, txnOpts) {
+        const space = this.getSpace(params.spaceNetworkId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${params.spaceNetworkId}" is not found.`);
+        }
+        const channelId = ensureHexPrefix(params.channelId);
+        return wrapTransaction(() => space.Roles.write(signer).setChannelPermissionOverrides(params.roleId, channelId, params.permissions), txnOpts);
+    }
+    async clearChannelPermissionOverrides(params, signer, txnOpts) {
+        const space = this.getSpace(params.spaceNetworkId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${params.spaceNetworkId}" is not found.`);
+        }
+        const channelId = ensureHexPrefix(params.channelId);
+        return wrapTransaction(() => space.Roles.write(signer).clearChannelPermissionOverrides(params.roleId, channelId), txnOpts);
+    }
+    async setSpaceAccess(spaceId, disabled, signer, txnOpts) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        if (disabled) {
+            return wrapTransaction(() => space.Pausable.write(signer).pause(), txnOpts);
+        }
+        else {
+            return wrapTransaction(() => space.Pausable.write(signer).unpause(), txnOpts);
+        }
+    }
+    /**
+     *
+     * @param spaceId
+     * @param priceInWei
+     * @param signer
+     */
+    async setMembershipPrice(spaceId, priceInWei, signer, txnOpts) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        return wrapTransaction(() => space.Membership.write(signer).setMembershipPrice(priceInWei), txnOpts);
+    }
+    async setMembershipPricingModule(spaceId, pricingModule, signer, txnOpts) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        return wrapTransaction(() => space.Membership.write(signer).setMembershipPricingModule(pricingModule), txnOpts);
+    }
+    async setMembershipLimit(spaceId, limit, signer, txnOpts) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        return wrapTransaction(() => space.Membership.write(signer).setMembershipLimit(limit), txnOpts);
+    }
+    async setMembershipFreeAllocation(spaceId, freeAllocation, signer, txnOpts) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        return wrapTransaction(() => space.Membership.write(signer).setMembershipFreeAllocation(freeAllocation), txnOpts);
+    }
+    async setChannelAccess(spaceId, channelNetworkId, disabled, signer, txnOpts) {
+        const channelId = ensureHexPrefix(channelNetworkId);
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        return wrapTransaction(() => space.Channels.write(signer).updateChannel(channelId, '', disabled), txnOpts);
+    }
+    async getSpaceMembershipTokenAddress(spaceId) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        return space.Membership.address;
+    }
+    async getJoinSpacePriceDetails(spaceId) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        // membershipPrice is either the maximum of either the price set during space creation, or the PlatformRequirements membership fee
+        // it will always be a value regardless of whether the space has free allocations
+        const membershipPriceEncoded = space.Membership.interface.encodeFunctionData('getMembershipPrice');
+        // totalSupply = number of memberships minted
+        const totalSupplyEncoded = space.ERC721A.interface.encodeFunctionData('totalSupply');
+        // free allocation is set at space creation and is unchanging - it neither increases nor decreases
+        // if totalSupply < freeAllocation, the contracts won't charge for minting a membership nft,
+        // else it will charge the membershipPrice
+        const freeAllocationEncoded = space.Membership.interface.encodeFunctionData('getMembershipFreeAllocation');
+        const protocolFeeEncoded = space.Membership.interface.encodeFunctionData('getProtocolFee');
+        const [membershipPriceResult, totalSupplyResult, freeAllocationResult, protocolFeeResult] = await space.Multicall.read.callStatic.multicall([
+            membershipPriceEncoded,
+            totalSupplyEncoded,
+            freeAllocationEncoded,
+            protocolFeeEncoded,
+        ]);
+        try {
+            const membershipPrice = space.Membership.interface.decodeFunctionResult('getMembershipPrice', membershipPriceResult)[0];
+            const totalSupply = space.ERC721A.interface.decodeFunctionResult('totalSupply', totalSupplyResult)[0];
+            const freeAllocation = space.Membership.interface.decodeFunctionResult('getMembershipFreeAllocation', freeAllocationResult)[0];
+            const protocolFee = space.Membership.interface.decodeFunctionResult('getProtocolFee', protocolFeeResult)[0];
+            // remainingFreeSupply = freeAllocation - totalSupply (if positive)
+            const remainingFreeSupply = totalSupply.lt(freeAllocation)
+                ? freeAllocation.sub(totalSupply)
+                : ethers.BigNumber.from(0);
+            return {
+                price: remainingFreeSupply.gt(0) ? ethers.BigNumber.from(0) : membershipPrice,
+                remainingFreeSupply,
+                protocolFee,
+            };
+        }
+        catch (error) {
+            logger.error('getJoinSpacePriceDetails: Error decoding membership price', error);
+            throw error;
+        }
+    }
+    async getMembershipFreeAllocation(spaceId) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        return space.Membership.read.getMembershipFreeAllocation();
+    }
+    async joinSpace(spaceId, recipient, signer, txnOpts) {
+        const joinSpaceStart = Date.now();
+        logger.log('joinSpace result before wrap', spaceId);
+        const getSpaceStart = Date.now();
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const [spaceCurrency, { price }] = await Promise.all([
+            space.Membership.read.getMembershipCurrency(),
+            this.getJoinSpacePriceDetails(spaceId),
+        ]);
+        const blockNumber = await space.provider?.getBlockNumber();
+        const startIssuedListener = space.Membership.listenForMembershipToken({
+            receiver: recipient,
+            startingBlock: blockNumber,
+        });
+        logger.log('joinSpace before blockNumber', Date.now() - getSpaceStart, blockNumber);
+        const getPriceStart = Date.now();
+        logger.log('joinSpace getMembershipPrice', Date.now() - getPriceStart);
+        const wrapStart = Date.now();
+        const issuedListener = startIssuedListener();
+        const result = await wrapTransaction(async () => {
+            // Set gas limit instead of using estimateGas
+            // As the estimateGas is not reliable for this contract
+            return await space.Membership.write(signer)['joinSpace(address)'](recipient, {
+                gasLimit: 1_500_000,
+                value: spaceCurrency.toLowerCase() === ETH_ADDRESS.toLowerCase() ? price : 0,
+            });
+        }, txnOpts);
+        const blockNumberAfterTx = await space.provider?.getBlockNumber();
+        logger.log('joinSpace wrap', Date.now() - wrapStart, blockNumberAfterTx);
+        const issued = await issuedListener;
+        const blockNumberAfter = await space.provider?.getBlockNumber();
+        logger.log('joinSpace after blockNumber', Date.now() - joinSpaceStart, blockNumberAfter, result, issued);
+        return issued;
+    }
+    async hasSpaceMembership(spaceId, addresses) {
+        const membershipStatus = await this.getMembershipStatus(spaceId, addresses);
+        return membershipStatus.isMember && !membershipStatus.isExpired;
+    }
+    async getMembershipStatus(spaceId, addresses) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        return space.getMembershipStatus(addresses);
+    }
+    async getMembershipSupply(spaceId) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const totalSupply = await space.ERC721A.read.totalSupply();
+        return { totalSupply: totalSupply.toNumber() };
+    }
+    async getMembershipInfo(spaceId) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const [joinSpacePriceDetails, limit, currency, feeRecipient, duration, totalSupply, pricingModule,] = await Promise.all([
+            this.getJoinSpacePriceDetails(spaceId),
+            space.Membership.read.getMembershipLimit(),
+            space.Membership.read.getMembershipCurrency(),
+            space.Ownable.getOwner(),
+            space.Membership.read.getMembershipDuration(),
+            space.ERC721A.read.totalSupply(),
+            space.Membership.read.getMembershipPricingModule(),
+        ]);
+        const { price, remainingFreeSupply } = joinSpacePriceDetails;
+        return {
+            price, // keep as BigNumber (wei)
+            maxSupply: limit.toNumber(),
+            currency: currency,
+            feeRecipient: feeRecipient,
+            duration: duration.toNumber(),
+            totalSupply: totalSupply.toNumber(),
+            pricingModule: pricingModule,
+            remainingFreeSupply: remainingFreeSupply.toNumber(),
+        };
+    }
+    getWalletLink() {
+        return this.walletLink;
+    }
+    getSpace(spaceId) {
+        return this.spaceRegistrar.getSpace(spaceId);
+    }
+    listPricingModules() {
+        return this.pricingModules.listPricingModules();
+    }
+    async encodeUpdateChannelRoles(space, channelNetworkId, _updatedRoleIds) {
+        const channelId = ensureHexPrefix(channelNetworkId);
+        const encodedCallData = [];
+        const [channelInfo] = await Promise.all([
+            space.Channels.read.getChannel(channelId),
+            space.getEntitlementShims(),
+        ]);
+        const currentRoleIds = new Set(channelInfo.roleIds.map((r) => r.toNumber()));
+        const updatedRoleIds = new Set(_updatedRoleIds);
+        const rolesToRemove = [];
+        const rolesToAdd = [];
+        for (const r of updatedRoleIds) {
+            // if the current role IDs does not have the updated role ID, then that role should be added.
+            if (!currentRoleIds.has(r)) {
+                rolesToAdd.push(r);
+            }
+        }
+        for (const r of currentRoleIds) {
+            // if the updated role IDs no longer have the current role ID, then that role should be removed.
+            if (!updatedRoleIds.has(r)) {
+                rolesToRemove.push(r);
+            }
+        }
+        // encode the call data for each role to remove
+        const encodedRemoveRoles = this.encodeRemoveRolesFromChannel(space, channelId, rolesToRemove);
+        for (const callData of encodedRemoveRoles) {
+            encodedCallData.push(callData);
+        }
+        // encode the call data for each role to add
+        const encodedAddRoles = this.encodeAddRolesToChannel(space, channelId, rolesToAdd);
+        for (const callData of encodedAddRoles) {
+            encodedCallData.push(callData);
+        }
+        return encodedCallData;
+    }
+    encodeAddRolesToChannel(space, channelNetworkId, roleIds) {
+        const channelId = ensureHexPrefix(channelNetworkId);
+        const encodedCallData = [];
+        for (const roleId of roleIds) {
+            const encodedBytes = space.Channels.interface.encodeFunctionData('addRoleToChannel', [
+                channelId,
+                roleId,
+            ]);
+            encodedCallData.push(encodedBytes);
+        }
+        return encodedCallData;
+    }
+    encodeRemoveRolesFromChannel(space, channelNetworkId, roleIds) {
+        const channelId = ensureHexPrefix(channelNetworkId);
+        const encodedCallData = [];
+        for (const roleId of roleIds) {
+            const encodedBytes = space.Channels.interface.encodeFunctionData('removeRoleFromChannel', [channelId, roleId]);
+            encodedCallData.push(encodedBytes);
+        }
+        return encodedCallData;
+    }
+    async createLegacyUpdatedEntitlements(space, params) {
+        return createLegacyEntitlementStruct(space, params.users, params.ruleData);
+    }
+    async createUpdatedEntitlements(space, params) {
+        return createEntitlementStruct(space, params.users, params.ruleData);
+    }
+    async refreshMetadata(spaceId, signer, txnOpts) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        return wrapTransaction(() => space.Membership.metadata.write(signer).refreshMetadata(), txnOpts);
+    }
+    /**
+     * Get the space address from the receipt and sender address
+     * @param receipt - The receipt from the transaction
+     * @param senderAddress - The address of the sender. Required for the case of a receipt containing multiple events of the same type.
+     * @returns The space address or undefined if the receipt is not successful
+     */
+    getSpaceAddress(receipt, senderAddress) {
+        if (receipt.status !== 1) {
+            return undefined;
+        }
+        for (const receiptLog of receipt.logs) {
+            const spaceAddress = this.spaceRegistrar.SpaceArchitect.getSpaceAddressFromLog(receiptLog, senderAddress);
+            if (spaceAddress) {
+                return spaceAddress;
+            }
+        }
+        return undefined;
+    }
+    getTipEvent(spaceId, receipt, senderAddress) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        return space.Tipping.getTipEvent(receipt, senderAddress);
+    }
+    withdrawSpaceFunds(spaceId, recipient, signer) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        return space.Treasury.write(signer).withdraw(ETH_ADDRESS, recipient);
+    }
+    /**
+     * Get the token id for the owner
+     * Returns the first token id matched from the linked wallets of the owner
+     * @param spaceId - The space id
+     * @param owner - The owner
+     * @returns The token id
+     */
+    async getTokenIdOfOwner(spaceId, owner, config = EmptyXchainConfig) {
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const linkedWallets = await this.getLinkedWalletsWithDelegations(owner, config);
+        const tokenIds = await space.getTokenIdsOfOwner(linkedWallets);
+        return tokenIds[0];
+    }
+    /**
+     * Send a tip using the new sendTip interface
+     * @param args.tipParams - The tip parameters (SendTipParams)
+     * @param args.signer - The signer to use for the tip
+     * @param args.txnOpts - Optional transaction options
+     * @param args.overrideExecution - Optional execution override
+     * @returns The transaction
+     */
+    async sendTip(args) {
+        const { tipParams, signer, txnOpts, overrideExecution } = args;
+        let recipientType;
+        let encodedData;
+        let tippingContract;
+        switch (tipParams.type) {
+            case 'member': {
+                // TipRecipientType.Member = 0
+                recipientType = 0;
+                const { spaceId, receiver, tokenId, currency, amount, messageId, channelId } = tipParams;
+                const space = this.getSpace(spaceId);
+                if (!space) {
+                    throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+                }
+                tippingContract = space.Tipping;
+                const metadataData = ethers.utils.defaultAbiCoder.encode(['bytes32', 'bytes32', 'uint256'], [ensureHexPrefix(messageId), ensureHexPrefix(channelId), tokenId]);
+                // Encode struct MembershipTipParams
+                encodedData = ethers.utils.defaultAbiCoder.encode([
+                    'tuple(address receiver, uint256 tokenId, address currency, uint256 amount, tuple(bytes32 messageId, bytes32 channelId, bytes data) metadata)',
+                ], [
+                    [
+                        receiver,
+                        tokenId,
+                        currency,
+                        amount,
+                        [ensureHexPrefix(messageId), ensureHexPrefix(channelId), metadataData],
+                    ],
+                ]);
+                break;
+            }
+            case 'bot': {
+                // TipRecipientType.Bot = 1
+                recipientType = 1;
+                const { spaceId, receiver, appId, currency, amount, messageId, channelId } = tipParams;
+                if (spaceId) {
+                    const space = this.getSpace(spaceId);
+                    if (!space) {
+                        throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+                    }
+                    tippingContract = space.Tipping;
+                }
+                else {
+                    if (!this.config.addresses.accountModules) {
+                        throw new Error('AccountModules address is not configured');
+                    }
+                    tippingContract = new ITippingShim(this.config.addresses.accountModules, this.provider);
+                }
+                const metadataData = ethers.utils.defaultAbiCoder.encode(['bytes32', 'bytes32'], [ensureHexPrefix(messageId), ensureHexPrefix(channelId)]);
+                // Encode struct BotTipParams
+                encodedData = ethers.utils.defaultAbiCoder.encode([
+                    'tuple(address receiver, address currency, bytes32 appId, uint256 amount, tuple(bytes32 messageId, bytes32 channelId, bytes data) metadata)',
+                ], [
+                    [
+                        receiver,
+                        currency,
+                        ensureHexPrefix(appId),
+                        amount,
+                        [ensureHexPrefix(messageId), ensureHexPrefix(channelId), metadataData],
+                    ],
+                ]);
+                break;
+            }
+            // DM tips (type: 'any') - calls the AccountModules contract directly
+            case 'any': {
+                // TipRecipientType.Any = 2
+                recipientType = 2;
+                const { receiver, currency, amount, messageId, channelId, sender: senderOverride, } = tipParams;
+                const sender = senderOverride ?? (await signer.getAddress());
+                if (!this.config.addresses.accountModules) {
+                    throw new Error('AccountModules address is not configured');
+                }
+                tippingContract = new ITippingShim(this.config.addresses.accountModules, this.provider);
+                // Encode messageId and channelId into bytes data
+                const data = ethers.utils.defaultAbiCoder.encode(['bytes32', 'bytes32'], [ensureHexPrefix(messageId), ensureHexPrefix(channelId)]);
+                // Encode struct AnyTipParams
+                encodedData = ethers.utils.defaultAbiCoder.encode([
+                    'tuple(address currency, address sender, address receiver, uint256 amount, bytes data)',
+                ], [[currency, sender, receiver, amount, data]]);
+                break;
+            }
+        }
+        return tippingContract.executeCall({
+            signer,
+            functionName: 'sendTip',
+            args: [recipientType, encodedData],
+            value: tipParams.currency.toLowerCase() === ETH_ADDRESS.toLowerCase()
+                ? tipParams.amount
+                : undefined,
+            overrideExecution,
+            transactionOpts: txnOpts,
+        });
+    }
+    /**
+     * Delegate staking within a space to an operator
+     * @param args
+     * @param args.spaceId - The space id
+     * @param args.operatorAddress - The operator address
+     * @returns The transaction
+     */
+    async addSpaceDelegation(args) {
+        const { spaceId, operatorAddress, signer, transactionOpts, overrideExecution } = args;
+        const space = this.getSpace(spaceId);
+        if (!space) {
+            throw new Error(`Space with spaceId "${spaceId}" is not found.`);
+        }
+        const spaceAddress = space.Address;
+        return this.baseRegistry.spaceDelegation.executeCall({
+            signer,
+            functionName: 'addSpaceDelegation',
+            args: [spaceAddress, operatorAddress],
+            overrideExecution,
+            transactionOpts,
+        });
+    }
+}
+//# sourceMappingURL=SpaceDapp.js.map