From df3ce8449a3bc7fe251078399710631b39d8b7e3 Mon Sep 17 00:00:00 2001
From: Vivian Plasencia <v.pcalana@gmail.com>
Date: Fri, 21 Jun 2024 12:45:39 +0200
Subject: [PATCH 1/6] feat: support groups with multiple credentials using
 logical operators

Now Bandada supports groups with multiple credentials using logical operators.

re #223
---
 .../credentials/credentials.service.test.ts   |  80 ++++-
 .../app/credentials/credentials.service.ts    | 174 +++++++++-
 .../src/app/credentials/dto/add-member.dto.ts |  17 +-
 apps/dashboard/src/api/bandadaAPI.ts          |  13 +-
 .../new-group-stepper/access-mode-step.tsx    | 322 +++++++++++++++++-
 apps/dashboard/src/pages/credentials.tsx      | 206 ++++++++++-
 apps/dashboard/src/pages/group.tsx            | 125 +++++--
 libs/credentials/src/evaluateExpression.ts    | 120 +++++++
 libs/credentials/src/index.test.ts            |  73 ++++
 libs/credentials/src/index.ts                 |   6 +-
 libs/credentials/src/validateCredentials.ts   |  35 +-
 11 files changed, 1093 insertions(+), 78 deletions(-)
 create mode 100644 libs/credentials/src/evaluateExpression.ts

diff --git a/apps/api/src/app/credentials/credentials.service.test.ts b/apps/api/src/app/credentials/credentials.service.test.ts
index 14163aac..46776498 100644
--- a/apps/api/src/app/credentials/credentials.service.test.ts
+++ b/apps/api/src/app/credentials/credentials.service.test.ts
@@ -43,6 +43,7 @@ jest.mock("@bandada/credentials", () => ({
         getJsonRpcProvider: jest.fn()
     })),
     validateCredentials: jest.fn(() => true),
+    validateManyCredentials: jest.fn(() => true),
     providers: [{ name: "twitter" }, { name: "github" }, { name: "blockchain" }]
 }))
 
@@ -155,7 +156,7 @@ describe("CredentialsService", () => {
                 providerName: "github"
             })
 
-            await credentialsService.addMember(_stateId, "code")
+            await credentialsService.addMember([_stateId], ["code"])
 
             const fun = credentialsService.setOAuthState({
                 groupId,
@@ -171,7 +172,7 @@ describe("CredentialsService", () => {
 
     describe("# addMember", () => {
         it("Should throw an error if the OAuth does not exist", async () => {
-            const fun = credentialsService.addMember("123", "code")
+            const fun = credentialsService.addMember(["123"], ["code"])
 
             await expect(fun).rejects.toThrow(`OAuth state does not exist`)
         })
@@ -184,8 +185,8 @@ describe("CredentialsService", () => {
             })
 
             const clientRedirectUri = await credentialsService.addMember(
-                _stateId,
-                "code"
+                [_stateId],
+                ["code"]
             )
 
             expect(clientRedirectUri).toBeUndefined()
@@ -231,15 +232,15 @@ describe("CredentialsService", () => {
             )
 
             const clientRedirectUri1 = await credentialsService.addMember(
-                _stateId1,
-                "code"
+                [_stateId1],
+                ["code"]
             )
 
             expect(clientRedirectUri1).toBeUndefined()
 
             const clientRedirectUri2 = await credentialsService.addMember(
-                _stateId2,
-                "code"
+                [_stateId2],
+                ["code"]
             )
 
             expect(clientRedirectUri2).toBeUndefined()
@@ -265,7 +266,7 @@ describe("CredentialsService", () => {
                 providerName: "github"
             })
 
-            const fun = credentialsService.addMember(_stateId, "code")
+            const fun = credentialsService.addMember([_stateId], ["code"])
 
             await expect(fun).rejects.toThrow(
                 `OAuth account does not match criteria`
@@ -289,7 +290,7 @@ describe("CredentialsService", () => {
                 providerName: "github"
             })
 
-            const fun = credentialsService.addMember(_stateId, "code")
+            const fun = credentialsService.addMember([_stateId], ["code"])
 
             await expect(fun).rejects.toThrow(
                 `OAuth account has already joined the group`
@@ -323,9 +324,9 @@ describe("CredentialsService", () => {
             })
 
             const clientRedirectUri = await credentialsService.addMember(
-                _stateId,
+                [_stateId],
                 undefined,
-                "0x"
+                ["0x"]
             )
 
             expect(clientRedirectUri).toBeUndefined()
@@ -339,9 +340,60 @@ describe("CredentialsService", () => {
             })
 
             const clientRedirectUri = await credentialsService.addMember(
-                _stateId,
+                [_stateId],
                 undefined,
-                "0x1"
+                ["0x1"]
+            )
+
+            expect(clientRedirectUri).toBeUndefined()
+        })
+        it("Should add a member to a group with many credentials", async () => {
+            const { id } = await groupsService.createGroup(
+                {
+                    name: "Group3",
+                    description: "This is a description",
+                    treeDepth: 16,
+                    fingerprintDuration: 3600,
+                    credentials: JSON.stringify({
+                        credentials: [
+                            {
+                                id: "BLOCKCHAIN_TRANSACTIONS",
+                                criteria: {
+                                    minTransactions: 12,
+                                    network: "sepolia"
+                                }
+                            },
+                            {
+                                id: "GITHUB_FOLLOWERS",
+                                criteria: {
+                                    minFollowers: 5
+                                }
+                            }
+                        ],
+                        expression: ["", "and", ""]
+                    })
+                },
+                "admin"
+            )
+
+            groupId = id
+
+            const _stateId1 = await credentialsService.setOAuthState({
+                groupId,
+                memberId: "1",
+                providerName: "blockchain"
+            })
+
+            const _stateId2 = await credentialsService.setOAuthState({
+                groupId,
+                memberId: "1",
+                providerName: "github"
+            })
+
+            const clientRedirectUri = await credentialsService.addMember(
+                [_stateId1, _stateId2],
+                ["code"],
+                ["0x"]
             )
 
             expect(clientRedirectUri).toBeUndefined()
diff --git a/apps/api/src/app/credentials/credentials.service.ts b/apps/api/src/app/credentials/credentials.service.ts
index a068d68f..d6893cfc 100644
--- a/apps/api/src/app/credentials/credentials.service.ts
+++ b/apps/api/src/app/credentials/credentials.service.ts
@@ -1,5 +1,6 @@
 import {
     validateCredentials,
+    validateManyCredentials,
     getProvider,
     BlockchainProvider,
     Web2Provider,
@@ -82,23 +83,176 @@ export class CredentialsService {
      * @returns Redirect URI
      */
     async addMember(
-        oAuthState: string,
-        oAuthCode?: string,
-        address?: string
+        oAuthState: string[],
+        oAuthCode?: string[],
+        address?: string[]
     ): Promise<string> {
-        if (!this.oAuthState.has(oAuthState)) {
+        if (!this.oAuthState.has(oAuthState[0])) {
             throw new BadRequestException(`OAuth state does not exist`)
         }
 
-        const {
+        let {
             groupId,
             memberId,
             providerName,
             redirectUri: clientRedirectUri
-        } = this.oAuthState.get(oAuthState)
+        } = this.oAuthState.get(oAuthState[0])
 
         const group = await this.groupsService.getGroup(groupId)
 
+        if (group.credentials === null) return
+
+        const credentials = JSON.parse(group.credentials)
+
+        if (
+            credentials.credentials !== undefined &&
+            credentials.expression !== undefined
+        ) {
+            // multiple check
+            const contexts = []
+            let accountHash: string
+
+            for (let i = 0; i < credentials.credentials.length; i += 1) {
+                // get the name of the provider of the credential
+                const credentialProvider = credentials.credentials[i].id
+                    .split("_")[0]
+                    .toLowerCase()
+
+                const credentialOAuthState = oAuthState.find(
+                    (s) =>
+                        this.oAuthState.get(s).providerName ===
+                        credentialProvider
+                )
+
+                if (credentialOAuthState === undefined) {
+                    return
+                }
+
+                // get the oAuthState for this credential
+                ;({
+                    groupId,
+                    memberId,
+                    providerName,
+                    redirectUri: clientRedirectUri
+                } = this.oAuthState.get(credentialOAuthState))
+                const provider = getProvider(providerName)
+
+                let context: Web2Context | BlockchainContext
+
+                if (address && credentialProvider === "blockchain") {
+                    const { network } = credentials.credentials[i].criteria
+
+                    const supportedNetwork =
+                        blockchainCredentialSupportedNetworks.find(
+                            (n) =>
+                                n.name.toLowerCase() === network.toLowerCase()
+                        )
+
+                    if (supportedNetwork === undefined)
+                        throw new BadRequestException(
+                            `The network is not supported`
+                        )
+
+                    const networkEnvVariableName =
+                        supportedNetwork.id.toUpperCase()
+
+                    const web3providerRpcURL =
+                        process.env[`${networkEnvVariableName}_RPC_URL`]
+
+                    // eslint-disable-next-line no-await-in-loop
+                    const jsonRpcProvider = await (
+                        provider as BlockchainProvider
+                    ).getJsonRpcProvider(web3providerRpcURL)
+
+                    context = {
+                        address: address[0],
+                        jsonRpcProvider
+                    }
+
+                    // Check if the same account has already joined the group.
+                    accountHash = id(address + groupId)
+                } else {
+                    const clientId =
+                        process.env[`${providerName.toUpperCase()}_CLIENT_ID`]
+                    const clientSecret =
+                        process.env[
+                            `${providerName.toUpperCase()}_CLIENT_SECRET`
+                        ]
+                    const redirectUri =
+                        process.env[
+                            `${providerName.toUpperCase()}_REDIRECT_URI`
+                        ]
+
+                    // Exchange the OAuth code for a valid access token.
+                    // eslint-disable-next-line no-await-in-loop
+                    const accessToken = await (
+                        provider as Web2Provider
+                    ).getAccessToken(
+                        clientId,
+                        clientSecret,
+                        oAuthCode[0],
+                        oAuthState[0],
+                        redirectUri
+                    )
+
+                    // eslint-disable-next-line no-await-in-loop
+                    const profile = await (provider as Web2Provider).getProfile(
+                        accessToken
+                    )
+
+                    context = {
+                        profile,
+                        accessTokens: { [providerName]: accessToken }
+                    }
+
+                    // Check if the same account has already joined the group.
+                    accountHash = id(profile.id + groupId)
+                }
+
+                if (
+                    group.oAuthAccounts.find(
+                        // eslint-disable-next-line @typescript-eslint/no-loop-func
+                        (account) => account.accountHash === accountHash
+                    )
+                ) {
+                    throw new BadRequestException(
+                        "OAuth account has already joined the group"
+                    )
+                }
+
+                contexts.push(context)
+            }
+
+            // Check credentials.
+            if (
+                !(await validateManyCredentials(
+                    credentials.credentials,
+                    contexts,
+                    credentials.expression
+                ))
+            ) {
+                throw new UnauthorizedException(
+                    "OAuth account does not match criteria"
+                )
+            }
+
+            // Save OAuth account to prevent the same account to join groups with
+            // different member ids.
+            const oAuthAccount = new OAuthAccount()
+
+            oAuthAccount.group = group
+            oAuthAccount.accountHash = accountHash
+
+            await this.oAuthAccountRepository.save(oAuthAccount)
+            await this.groupsService.addMember(groupId, memberId)
+
+            for (let i = 0; i < oAuthState.length; i += 1) {
+                this.oAuthState.delete(oAuthState[i])
+            }
+
+            return clientRedirectUri
+        }
+
         const provider = getProvider(providerName)
 
         let accountHash: string
@@ -125,7 +279,7 @@ export class CredentialsService {
             ).getJsonRpcProvider(web3providerRpcURL)
 
             context = {
-                address,
+                address: address[0],
                 jsonRpcProvider
             }
 
@@ -143,8 +297,8 @@ export class CredentialsService {
             const accessToken = await (provider as Web2Provider).getAccessToken(
                 clientId,
                 clientSecret,
-                oAuthCode,
-                oAuthState,
+                oAuthCode[0],
+                oAuthState[0],
                 redirectUri
             )
 
@@ -190,7 +344,7 @@ export class CredentialsService {
         await this.oAuthAccountRepository.save(oAuthAccount)
         await this.groupsService.addMember(groupId, memberId)
 
-        this.oAuthState.delete(oAuthState)
+        this.oAuthState.delete(oAuthState[0])
 
         return clientRedirectUri
     }
diff --git a/apps/api/src/app/credentials/dto/add-member.dto.ts b/apps/api/src/app/credentials/dto/add-member.dto.ts
index f3a4cf8f..d517574f 100644
--- a/apps/api/src/app/credentials/dto/add-member.dto.ts
+++ b/apps/api/src/app/credentials/dto/add-member.dto.ts
@@ -1,14 +1,17 @@
-import { IsString, IsOptional } from "class-validator"
+import { IsArray, ArrayNotEmpty, IsOptional } from "class-validator"
 
 export class AddMemberDto {
-    @IsString()
-    readonly oAuthState: string
+    @IsArray()
+    @ArrayNotEmpty()
+    readonly oAuthState: string[]
 
     @IsOptional()
-    @IsString()
-    readonly oAuthCode: string
+    @IsArray()
+    @ArrayNotEmpty()
+    readonly oAuthCode: string[]
 
     @IsOptional()
-    @IsString()
-    readonly address: string
+    @IsArray()
+    @ArrayNotEmpty()
+    readonly address: string[]
 }
diff --git a/apps/dashboard/src/api/bandadaAPI.ts b/apps/dashboard/src/api/bandadaAPI.ts
index dd069c64..d9f533a9 100644
--- a/apps/dashboard/src/api/bandadaAPI.ts
+++ b/apps/dashboard/src/api/bandadaAPI.ts
@@ -201,18 +201,21 @@ export async function setOAuthState(
  * @param oAuthCode The OAuth code.
  */
 export async function addMemberByCredentials(
-    oAuthState: string,
-    oAuthCode?: string,
-    address?: string
+    oAuthState: string[],
+    oAuthCode?: string[],
+    address?: string[]
 ): Promise<string | null> {
     try {
         return await request(`${API_URL}/credentials`, {
             method: "POST",
-            data: {
+            headers: {
+                "Content-Type": "application/json"
+            },
+            data: JSON.stringify({
                 oAuthState,
                 oAuthCode,
                 address
-            }
+            })
         })
     } catch (error: any) {
         console.error(error)
diff --git a/apps/dashboard/src/components/new-group-stepper/access-mode-step.tsx b/apps/dashboard/src/components/new-group-stepper/access-mode-step.tsx
index 923c0731..55f39420 100644
--- a/apps/dashboard/src/components/new-group-stepper/access-mode-step.tsx
+++ b/apps/dashboard/src/components/new-group-stepper/access-mode-step.tsx
@@ -13,6 +13,7 @@ import {
     NumberInputField,
     NumberInputStepper,
     Select,
+    SimpleGrid,
     Tag,
     TagLabel,
     Text,
@@ -23,9 +24,11 @@ import { BiPencil } from "react-icons/bi"
 import { GoGear } from "react-icons/go"
 import capitalize from "../../utils/capitalize"
 
-const accessModes = ["manual", "credentials"]
+const accessModes = ["manual", "credentials", "multiple_credentials"]
 
-export type AccessMode = "manual" | "credentials"
+export type AccessMode = "manual" | "credentials" | "multiple_credentials"
+
+const logicalOperators = ["and", "or", "not", "xor", "(", ")"]
 
 export type AccessModeStepProps = {
     group: any
@@ -42,6 +45,9 @@ export default function AccessModeStep({
     const [_validator, setValidator] = useState<number>(0)
     const [_credentials, setCredentials] = useState<any>()
 
+    const [_validators, setValidators] = useState<number[]>([]) // selected validators for multiple credentials
+    const [_expression, setExpression] = useState<string[]>([]) // Expression with logical operators for multiple credentials
+
     useEffect(() => {
         setCredentials({
             id: validators[_validator].id,
@@ -52,13 +58,13 @@ export default function AccessModeStep({
     useEffect(() => {
         if (_accessMode === "manual") {
             setCredentials(undefined)
-        } else {
+        } else if (_accessMode === "credentials") {
             setCredentials({
                 id: validators[_validator].id,
                 criteria: {}
             })
         }
-    }, [_accessMode, _validator])
+    }, [_accessMode, _validator, _validators])
 
     return (
         <>
@@ -106,7 +112,11 @@ export default function AccessModeStep({
                                     }
                                 />
 
-                                <Text>{capitalize(accessMode)}</Text>
+                                <Text>
+                                    {capitalize(
+                                        accessMode.replaceAll("_", " ")
+                                    )}
+                                </Text>
                             </HStack>
 
                             {_accessMode === accessMode && (
@@ -293,6 +303,297 @@ export default function AccessModeStep({
                 </>
             )}
 
+            {_accessMode === "multiple_credentials" && (
+                <>
+                    <Text pb="20px">Choose credentials</Text>
+
+                    <SimpleGrid columns={2} spacing={10}>
+                        <VStack>
+                            <Text>Credentials</Text>
+                            <VStack>
+                                {validators.map((validator, i) => (
+                                    <Button
+                                        key={validator.id}
+                                        variant="solid"
+                                        colorScheme="tertiary"
+                                        onClick={() => {
+                                            setValidators([..._validators, i])
+                                            setExpression([
+                                                ..._expression,
+                                                i.toString()
+                                            ])
+
+                                            const tempCredential = {
+                                                ..._credentials
+                                            }
+
+                                            if (
+                                                tempCredential.credentials !==
+                                                undefined
+                                            ) {
+                                                tempCredential.credentials.push(
+                                                    {
+                                                        id: validators[i].id,
+                                                        criteria: {}
+                                                    }
+                                                )
+                                            } else {
+                                                tempCredential.credentials = [
+                                                    {
+                                                        id: validators[i].id,
+                                                        criteria: {}
+                                                    }
+                                                ]
+                                            }
+
+                                            setCredentials(tempCredential)
+                                        }}
+                                        w="200px"
+                                    >
+                                        {capitalize(
+                                            validator.id
+                                                .replaceAll("_", " ")
+                                                .toLowerCase()
+                                        )}
+                                    </Button>
+                                ))}
+                            </VStack>
+                        </VStack>
+                        <VStack>
+                            <Text>Logical Operators</Text>
+                            <VStack>
+                                {logicalOperators.map((lo) => (
+                                    <Button
+                                        key={lo}
+                                        variant="solid"
+                                        colorScheme="tertiary"
+                                        onClick={() => {
+                                            setExpression([..._expression, lo])
+                                        }}
+                                        w="50px"
+                                    >
+                                        {lo.toUpperCase()}
+                                    </Button>
+                                ))}
+                            </VStack>
+                        </VStack>
+                    </SimpleGrid>
+
+                    <VStack align="left">
+                        <Text>Expression</Text>
+                        <Box
+                            p={4}
+                            borderWidth="1px"
+                            borderRadius="lg"
+                            overflow="hidden"
+                        >
+                            {_expression.length > 0
+                                ? _expression
+                                      .map((elem) => {
+                                          const isLogicalOperator =
+                                              logicalOperators.includes(elem)
+                                          if (isLogicalOperator) {
+                                              return elem.toUpperCase()
+                                          }
+                                          return capitalize(
+                                              validators[
+                                                  Number(elem)
+                                              ].id.toLowerCase()
+                                          )
+                                      })
+                                      .join(" ")
+                                : "No expression yet"}
+                        </Box>
+                    </VStack>
+
+                    {/* Display credential citeria */}
+                    <VStack align="left">
+                        {_credentials &&
+                            _credentials.credentials &&
+                            _validators.map((validatorIndex, i) =>
+                                Object.entries(
+                                    validators[validatorIndex].criteriaABI
+                                ).map((parameter: any, j) => (
+                                    <VStack
+                                        align="left"
+                                        pt="20px"
+                                        key={parameter[0]}
+                                    >
+                                        {j === 0 && (
+                                            <Text>
+                                                {`${i + 1}. ${capitalize(
+                                                    validators[
+                                                        validatorIndex
+                                                    ].id
+                                                        .replaceAll("_", " ")
+                                                        .toLowerCase()
+                                                )}`}
+                                            </Text>
+                                        )}
+                                        <Text>
+                                            {capitalize(
+                                                `${parameter[0]}${
+                                                    parameter[1].optional
+                                                        ? ""
+                                                        : "*"
+                                                }`
+                                            )}
+                                        </Text>
+
+                                        {parameter[1].type === "number" && (
+                                            <NumberInput
+                                                size="lg"
+                                                value={
+                                                    _credentials.credentials[i]
+                                                        .criteria[parameter[0]]
+                                                }
+                                                onChange={(value) => {
+                                                    const credentialTemp = {
+                                                        ..._credentials
+                                                    }
+
+                                                    credentialTemp.credentials[
+                                                        i
+                                                    ].criteria = {
+                                                        ..._credentials
+                                                            .credentials[i]
+                                                            .criteria,
+                                                        [parameter[0]]:
+                                                            Number(value)
+                                                    }
+
+                                                    setCredentials(
+                                                        credentialTemp
+                                                    )
+                                                }}
+                                            >
+                                                <NumberInputField />
+                                                <NumberInputStepper>
+                                                    <NumberIncrementStepper />
+                                                    <NumberDecrementStepper />
+                                                </NumberInputStepper>
+                                            </NumberInput>
+                                        )}
+                                        {parameter[0] !== "network" &&
+                                            parameter[1].type === "string" && (
+                                                <Input
+                                                    size="lg"
+                                                    onChange={(event) => {
+                                                        const credentialTemp = {
+                                                            ..._credentials
+                                                        }
+
+                                                        credentialTemp.credentials[
+                                                            i
+                                                        ].criteria = {
+                                                            ..._credentials
+                                                                .credentials[i]
+                                                                .criteria,
+                                                            [parameter[0]]:
+                                                                event.target
+                                                                    .value
+                                                        }
+
+                                                        setCredentials(
+                                                            credentialTemp
+                                                        )
+                                                    }}
+                                                    placeholder={
+                                                        parameter[0] ===
+                                                        "repository"
+                                                            ? "<repo-owner>/<repo-name>"
+                                                            : undefined
+                                                    }
+                                                />
+                                            )}
+                                        {parameter[0] === "network" &&
+                                            parameter[1].type === "string" && (
+                                                <Select
+                                                    size="lg"
+                                                    placeholder="Select network"
+                                                    onChange={(event) => {
+                                                        const credentialTemp = {
+                                                            ..._credentials
+                                                        }
+
+                                                        credentialTemp.credentials[
+                                                            i
+                                                        ].criteria = {
+                                                            ..._credentials
+                                                                .credentials[i]
+                                                                .criteria,
+                                                            [parameter[0]]:
+                                                                event.target
+                                                                    .value
+                                                        }
+
+                                                        setCredentials(
+                                                            credentialTemp
+                                                        )
+                                                    }}
+                                                >
+                                                    {blockchainCredentialSupportedNetworks.map(
+                                                        (network: any) => (
+                                                            <option
+                                                                value={
+                                                                    network.name
+                                                                }
+                                                                key={
+                                                                    network.name
+                                                                }
+                                                            >
+                                                                {network.name}
+                                                            </option>
+                                                        )
+                                                    )}
+                                                </Select>
+                                            )}
+                                        {parameter[1].type === "boolean" && (
+                                            <Checkbox
+                                                isChecked={
+                                                    _credentials.credentials[i]
+                                                        .criteria[parameter[0]]
+                                                }
+                                                onChange={(event) => {
+                                                    const credentialTemp = {
+                                                        ..._credentials
+                                                    }
+
+                                                    credentialTemp.credentials[
+                                                        i
+                                                    ].criteria = {
+                                                        ..._credentials
+                                                            .credentials[i]
+                                                            .criteria,
+                                                        [parameter[0]]:
+                                                            event.target.checked
+                                                    }
+
+                                                    setCredentials(
+                                                        credentialTemp
+                                                    )
+                                                }}
+                                            />
+                                        )}
+                                    </VStack>
+                                ))
+                            )}
+                    </VStack>
+                    <Box pt="20px">
+                        <Text
+                            p="16px"
+                            borderRadius="8px"
+                            bgColor="classicRose.100"
+                            color="classicRose.900"
+                        >
+                            Disclaimer: We will use a bit of your member’s data
+                            to check if they meet the criteria and generate
+                            their credentials to join the group.
+                        </Text>
+                    </Box>
+                </>
+            )}
+
             <HStack justify="right" pt="20px">
                 <Button variant="solid" colorScheme="tertiary" onClick={onBack}>
                     Back
@@ -316,6 +617,17 @@ export default function AccessModeStep({
                     variant="solid"
                     colorScheme="primary"
                     onClick={() => {
+                        if (_accessMode === "multiple_credentials") {
+                            _credentials.expression = _expression.map(
+                                (elem) => {
+                                    if (!logicalOperators.includes(elem)) {
+                                        return ""
+                                    }
+                                    return elem
+                                }
+                            )
+                            setCredentials(_credentials)
+                        }
                         onSubmit({
                             ...group,
                             credentials: _credentials
diff --git a/apps/dashboard/src/pages/credentials.tsx b/apps/dashboard/src/pages/credentials.tsx
index b4b50fd2..b53abb69 100644
--- a/apps/dashboard/src/pages/credentials.tsx
+++ b/apps/dashboard/src/pages/credentials.tsx
@@ -11,9 +11,79 @@ import { useSearchParams } from "react-router-dom"
 import { useConnectModal, useAccountModal } from "@rainbow-me/rainbowkit"
 import { useAccount } from "wagmi"
 import { shortenAddress } from "@bandada/utils"
-import { addMemberByCredentials, setOAuthState } from "../api/bandadaAPI"
+import {
+    addMemberByCredentials,
+    setOAuthState,
+    getGroup
+} from "../api/bandadaAPI"
 import { AuthContext } from "../context/auth-context"
 
+// Local storage key to save information related to groups with multiple credentials
+const LOCAL_STORAGE = "bandada_credentials"
+
+// Function to generate the right link for the credential groups
+function generateUrl(providerName: string, groupId: string, memberId: string) {
+    return `credentials?group=${groupId}&member=${memberId}&provider=${providerName}&type=multiple`
+}
+
+// Related to groups with multiple credentials
+// Function to return the next url that should be evaluated
+// using the providers saved in local storage
+function getUrlNextEmpty(groupId: string, memberId: string) {
+    const bandadaCredentials = localStorage.getItem(LOCAL_STORAGE)
+    if (!bandadaCredentials) return null
+    const providers = JSON.parse(bandadaCredentials)
+
+    for (let i = 0; i < providers.length; i += 1) {
+        if (providers[i].length === 0) {
+            return generateUrl(providers[i], groupId, memberId)
+        }
+    }
+    return null
+}
+
+// Related to groups with multiple credentials
+// Function to evaluate many credentials
+async function validateCredentials() {
+    const bandadaCredentials = localStorage.getItem(LOCAL_STORAGE)
+    if (!bandadaCredentials) return null
+    const providers = JSON.parse(bandadaCredentials)
+
+    const states = []
+    const codes = []
+    const addresses = []
+
+    for (let i = 0; i < Object.keys(providers).length; i += 1) {
+        const state =
+            providers[Object.keys(providers)[i]][0] !== null
+                ? providers[Object.keys(providers)[i]][0]
+                : ""
+        const code =
+            providers[Object.keys(providers)[i]][1] !== null
+                ? providers[Object.keys(providers)[i]][1]
+                : ""
+        const address =
+            providers[Object.keys(providers)[i]][2] !== null
+                ? providers[Object.keys(providers)[i]][2]
+                : ""
+        states.push(state)
+        codes.push(code)
+        addresses.push(address)
+    }
+
+    const clientRedirectUri = await addMemberByCredentials(
+        states,
+        codes,
+        addresses
+    )
+
+    // Remove the key in local storage used to save information
+    // about groups with multiple credentials
+    localStorage.removeItem(LOCAL_STORAGE)
+
+    return clientRedirectUri
+}
+
 export default function CredentialsPage() {
     const [_searchParams] = useSearchParams()
     const [_message, setMessage] = useState<string>(
@@ -33,14 +103,71 @@ export default function CredentialsPage() {
     )
 
     useEffect(() => {
+        const groupType = _searchParams.get("type") || undefined
+        const groupId = _searchParams.get("group")
+        const memberId = _searchParams.get("member")
+        const providerName = _searchParams.get("provider")
         ;(async () => {
             if (_searchParams.has("group") && _searchParams.has("member")) {
-                const groupId = _searchParams.get("group")
-                const memberId = _searchParams.get("member")
-                const providerName = _searchParams.get("provider")
                 const clientRedirectUri =
                     _searchParams.get("redirect_uri") || undefined
 
+                setIsBlockchain(providerName === blockchain.name)
+
+                // If the group has many credentials
+                if (groupType === "multiple" && !providerName) {
+                    if (!groupId || !memberId) return
+
+                    // Get the group info
+                    const group = await getGroup(groupId)
+
+                    let groupCredentials: any
+
+                    if (group?.credentials) {
+                        // get the group credentials
+                        groupCredentials = JSON.parse(group.credentials)
+                    }
+
+                    if (!groupCredentials) return
+
+                    // The temporal data is saved in the browser local storage
+                    const bandadaCredentials =
+                        localStorage.getItem(LOCAL_STORAGE)
+
+                    // Clean the value of the variable that will
+                    // save the data
+                    if (bandadaCredentials) {
+                        localStorage.setItem(LOCAL_STORAGE, "")
+                    }
+
+                    // check if the browser has any data saved, if not, save
+                    // the possible providers
+                    // and start generating the urls
+
+                    const data: any = {}
+
+                    for (
+                        let i = 0;
+                        i < groupCredentials.credentials.length;
+                        i += 1
+                    ) {
+                        // Get the provider to save it to the browser with an empty value.
+                        const provider = groupCredentials.credentials[i].id
+                            .split("_")[0]
+                            .toLowerCase()
+                        data[provider] = []
+                    }
+
+                    localStorage.setItem(LOCAL_STORAGE, JSON.stringify(data))
+
+                    const firstProvider = groupCredentials.credentials[0].id
+                        .split("_")[0]
+                        .toLowerCase()
+
+                    const url = generateUrl(firstProvider, groupId, memberId)
+                    window.location.replace(url)
+                }
+
                 const state = await setOAuthState(
                     groupId as string,
                     memberId as string,
@@ -48,18 +175,48 @@ export default function CredentialsPage() {
                     clientRedirectUri
                 )
 
-                setIsBlockchain(providerName === blockchain.name)
-
+                // If the credential is blockchain
                 if (
                     providerName === blockchain.name &&
                     isLoggedInAdmin() &&
                     state
                 ) {
                     if (state && admin) {
+                        if (groupType) {
+                            const bandadaCredentials =
+                                localStorage.getItem(LOCAL_STORAGE)
+                            if (!bandadaCredentials) return null
+                            const providers = JSON.parse(bandadaCredentials)
+                            providers[providerName] = [
+                                state,
+                                undefined,
+                                admin.address
+                            ]
+                            localStorage.setItem(
+                                LOCAL_STORAGE,
+                                JSON.stringify(providers)
+                            )
+                            if (!groupId || !memberId) return
+                            const url = getUrlNextEmpty(groupId, memberId)
+
+                            if (url === null) {
+                                const clientRedirectUrl =
+                                    await validateCredentials()
+                                if (clientRedirectUrl) {
+                                    window.location.replace(clientRedirectUrl)
+                                } else {
+                                    setMessage("You have joined the group!")
+                                }
+                                return
+                            }
+
+                            window.location.replace(url)
+                        }
+
                         const redirectUrl = await addMemberByCredentials(
-                            state,
+                            [state],
                             undefined,
-                            admin.address
+                            [admin.address]
                         )
 
                         if (redirectUrl) {
@@ -70,6 +227,7 @@ export default function CredentialsPage() {
                     }
                 }
 
+                // If it is a web2 credential. This is the first request for web2 credentials
                 if (
                     (providerName === twitter.name ||
                         providerName === github.name) &&
@@ -94,13 +252,41 @@ export default function CredentialsPage() {
                 }
             }
 
+            // Second request for the web2 credential. The web2 credential is validated
             if (_searchParams.has("code") && _searchParams.has("state")) {
                 const oAuthCode = _searchParams.get("code") as string
                 const oAuthState = _searchParams.get("state") as string
 
+                if (groupType) {
+                    const bandadaCredentials =
+                        localStorage.getItem(LOCAL_STORAGE)
+                    if (!bandadaCredentials) return null
+                    const providers = JSON.parse(bandadaCredentials)
+                    if (providerName === null) return
+                    providers[providerName] = [oAuthState, oAuthCode]
+                    localStorage.setItem(
+                        LOCAL_STORAGE,
+                        JSON.stringify(providers)
+                    )
+                    if (!groupId || !memberId) return
+                    const url = getUrlNextEmpty(groupId, memberId)
+
+                    if (url === null) {
+                        const clientRedirectUrl = await validateCredentials()
+                        if (clientRedirectUrl) {
+                            window.location.replace(clientRedirectUrl)
+                        } else {
+                            setMessage("You have joined the group!")
+                        }
+                        return
+                    }
+
+                    window.location.replace(url)
+                }
+
                 const clientRedirectUri = await addMemberByCredentials(
-                    oAuthState,
-                    oAuthCode
+                    [oAuthState],
+                    [oAuthCode]
                 )
 
                 if (clientRedirectUri) {
diff --git a/apps/dashboard/src/pages/group.tsx b/apps/dashboard/src/pages/group.tsx
index ed96dcea..cb2a58c7 100644
--- a/apps/dashboard/src/pages/group.tsx
+++ b/apps/dashboard/src/pages/group.tsx
@@ -245,19 +245,53 @@ ${memberIds.join("\n")}
     }
     let credentialsId = ""
     let credentialsCriteria = ""
+    const credentialsIds: string[] = []
+    const credentialsCriterias: string[] = []
+    const expression: string[] = []
     if (_group && _group.credentials) {
         const credentialsObj = JSON.parse(_group.credentials)
-        credentialsId = `${credentialsObj.id}`
-
-        if (credentialsObj.criteria) {
-            for (const key in credentialsObj.criteria) {
-                if (
-                    Object.prototype.hasOwnProperty.call(
-                        credentialsObj.criteria,
-                        key
-                    )
-                ) {
-                    credentialsCriteria += `${key}:${credentialsObj.criteria[key]} `
+
+        if (credentialsObj.id) {
+            credentialsId = `${credentialsObj.id}`
+
+            if (credentialsObj.criteria) {
+                for (const key in credentialsObj.criteria) {
+                    if (
+                        Object.prototype.hasOwnProperty.call(
+                            credentialsObj.criteria,
+                            key
+                        )
+                    ) {
+                        credentialsCriteria += `${key}:${credentialsObj.criteria[key]} `
+                    }
+                }
+            }
+        } else {
+            // The group has multiple credentials
+            for (let i = 0; i < credentialsObj.credentials.length; i += 1) {
+                let credentialsCriteriaTemp: string = ""
+                credentialsIds.push(credentialsObj.credentials[i].id)
+                if (credentialsObj.credentials[i].criteria) {
+                    for (const key in credentialsObj.credentials[i].criteria) {
+                        if (
+                            Object.prototype.hasOwnProperty.call(
+                                credentialsObj.credentials[i].criteria,
+                                key
+                            )
+                        ) {
+                            credentialsCriteriaTemp += `${key}:${credentialsObj.credentials[i].criteria[key]} `
+                        }
+                    }
+                }
+                credentialsCriterias.push(credentialsCriteriaTemp)
+            }
+            let pos = 0
+            for (let i = 0; i < credentialsObj.expression.length; i += 1) {
+                if (credentialsObj.expression[i] === "") {
+                    expression.push(credentialsCriterias[pos])
+                    pos += 1
+                } else {
+                    expression.push(credentialsObj.expression[i])
                 }
             }
         }
@@ -388,20 +422,61 @@ ${memberIds.join("\n")}
                             borderRadius="8px"
                         >
                             <Text fontSize="20px">Credentials</Text>
-                            <Input
-                                pr="50px"
-                                placeholder="Credentials ID"
-                                mb="10px"
-                                mt="10px"
-                                value={credentialsId}
-                                isDisabled
-                            />
-                            <Input
-                                pr="50px"
-                                placeholder="Credentials Criteria"
-                                value={credentialsCriteria}
-                                isDisabled
-                            />
+                            {JSON.parse(_group.credentials).credentials ? (
+                                // The group has multiple credentials
+                                <>
+                                    <>
+                                        {credentialsIds.map((id, i) => (
+                                            <VStack key={id}>
+                                                <Input
+                                                    pr="50px"
+                                                    placeholder="Credential IDs"
+                                                    mb="10px"
+                                                    mt="10px"
+                                                    value={id}
+                                                    isDisabled
+                                                />
+                                                <Input
+                                                    pr="50px"
+                                                    placeholder="Credentials Criteria"
+                                                    value={
+                                                        credentialsCriterias[i]
+                                                    }
+                                                    isDisabled
+                                                />
+                                            </VStack>
+                                        ))}
+                                    </>
+                                    <Text fontSize="20px" mt="3">
+                                        Expression
+                                    </Text>
+                                    <Input
+                                        pr="50px"
+                                        placeholder="Expression"
+                                        mb="10px"
+                                        mt="10px"
+                                        value={expression.join(" ")}
+                                        isDisabled
+                                    />
+                                </>
+                            ) : (
+                                <>
+                                    <Input
+                                        pr="50px"
+                                        placeholder="Credentials ID"
+                                        mb="10px"
+                                        mt="10px"
+                                        value={credentialsId}
+                                        isDisabled
+                                    />
+                                    <Input
+                                        pr="50px"
+                                        placeholder="Credentials Criteria"
+                                        value={credentialsCriteria}
+                                        isDisabled
+                                    />
+                                </>
+                            )}
                         </Box>
                     )}
                     {/* {groupType === "off-chain" &&
diff --git a/libs/credentials/src/evaluateExpression.ts b/libs/credentials/src/evaluateExpression.ts
new file mode 100644
index 00000000..676d1f1c
--- /dev/null
+++ b/libs/credentials/src/evaluateExpression.ts
@@ -0,0 +1,120 @@
+// This algorithm is an adaptation of the Shunting Yard algorithm for evaluating logical operators.
+// https://en.wikipedia.org/wiki/Shunting_yard_algorithm
+
+/**
+ * Tokenization function to split the expression into meaningful tokens.
+ * @param expression The expression to tokenize.
+ * @returns A list with the tokens of the expression.
+ */
+export function tokenize(expression: string): string[] {
+    const tokenPattern = /\s*(\(|\)|and|or|not|xor|true|false)\s*/g
+    // Split the expression based on the token pattern and filter out empty tokens
+    return expression.split(tokenPattern).filter((token) => token.trim() !== "")
+}
+
+/**
+ * Function to determine the precedence of operators.
+ * Unary operators have higher precedence.
+ * Binary operators have the same precedence.
+ * @param op Operator to check the precedence.
+ * @returns The precedence of the operator.
+ */
+function precedence(op: string): number {
+    if (op === "not") return 2 // Highest precedence
+    if (op === "and") return 1
+    if (op === "xor") return 1
+    if (op === "or") return 1 // Lowest precedence
+    return 0
+}
+
+/**
+ * Function to apply the operator to one or two boolean values.
+ * @param op Operator to apply.
+ * @param a First boolean value.
+ * @param b Second boolean value.
+ * @returns The boolean value after applying the operator.
+ */
+function applyOp(op: string, a: boolean, b?: boolean): boolean {
+    switch (op) {
+        case "and":
+            return a && b!
+        case "or":
+            return a || b!
+        case "not":
+            return !a
+        case "xor":
+            return a !== b! // XOR returns true if only one of the operands is true
+        default:
+            throw new Error(`Unknown operator: ${op}`)
+    }
+}
+
+/**
+ * Function to evaluate the tokenized expression
+ * @param tokens Tokens of the expression.
+ * The tokens can be boolean values, operators or parenthesis.
+ * They represent a valid expression.
+ * @returns The boolean value after evaluating the expression.
+ */
+export function evaluate(tokens: string[]): boolean {
+    const values: boolean[] = [] // Stack to store boolean values
+    const ops: string[] = [] // Stack to store operators
+
+    for (let i = 0; i < tokens.length; i += 1) {
+        const token = tokens[i]
+
+        if (token === "true") {
+            values.push(true)
+        } else if (token === "false") {
+            values.push(false)
+        } else if (token === "(") {
+            ops.push(token)
+        } else if (token === ")") {
+            // Evaluate the expression inside the parentheses
+            while (ops.length > 0 && ops[ops.length - 1] !== "(") {
+                const op = ops.pop()!
+                if (op === "not") {
+                    const val = values.pop()!
+                    values.push(applyOp(op, val))
+                } else {
+                    const b = values.pop()!
+                    const a = values.pop()!
+                    values.push(applyOp(op, a, b))
+                }
+            }
+            ops.pop() // Remove '(' from stack
+        } else if (["and", "or", "not", "xor"].includes(token)) {
+            // Handle operators and ensure the correct precedence
+            while (
+                ops.length > 0 &&
+                precedence(ops[ops.length - 1]) >= precedence(token)
+            ) {
+                const op = ops.pop()!
+                if (op === "not") {
+                    const val = values.pop()!
+                    values.push(applyOp(op, val))
+                } else {
+                    const b = values.pop()!
+                    const a = values.pop()!
+                    values.push(applyOp(op, a, b))
+                }
+            }
+            ops.push(token)
+        }
+    }
+
+    // Apply remaining operators to remaining values
+    while (ops.length > 0) {
+        const op = ops.pop()!
+        if (op === "not") {
+            const val = values.pop()!
+            values.push(applyOp(op, val))
+        } else {
+            const b = values.pop()!
+            const a = values.pop()!
+            values.push(applyOp(op, a, b))
+        }
+    }
+
+    return values.pop()!
+}
diff --git a/libs/credentials/src/index.test.ts b/libs/credentials/src/index.test.ts
index ad876b2a..a3d2d684 100644
--- a/libs/credentials/src/index.test.ts
+++ b/libs/credentials/src/index.test.ts
@@ -1,3 +1,6 @@
+import { BigNumber } from "ethers"
+import blockchainBalance from "./validators/blockchainBalance"
+import blockchainTransactions from "./validators/blockchainTransactions"
 import addProvider from "./addProvider"
 import addProviders from "./addProviders"
 import addValidator from "./addValidator"
@@ -6,6 +9,10 @@ import getProvider from "./getProvider"
 import getValidator from "./getValidator"
 import providers from "./providers"
 import validators from "./validators"
+import {
+    validateCredentials,
+    validateManyCredentials
+} from "./validateCredentials"
 
 describe("Credentials library", () => {
     describe("# addProvider", () => {
@@ -67,4 +74,70 @@ describe("Credentials library", () => {
             expect(fun).toThrow(`Validator 'EEE' does not exist`)
         })
     })
+
+    describe("# validateCredentials", () => {
+        const jsonRpcProviderMocked = {
+            getBalance: jest.fn(),
+            getTransactionCount: jest.fn()
+        }
+        it("Should return true if an account has a balance greater than or equal to 10", async () => {
+            jsonRpcProviderMocked.getBalance.mockReturnValue(BigNumber.from(12))
+            jsonRpcProviderMocked.getTransactionCount.mockReturnValue(12)
+
+            const result = await validateCredentials(
+                {
+                    id: blockchainBalance.id,
+                    criteria: {
+                        minBalance: "10",
+                        network: "sepolia"
+                    }
+                },
+                {
+                    address: "0x",
+                    jsonRpcProvider: jsonRpcProviderMocked
+                }
+            )
+
+            expect(result).toBeTruthy()
+        })
+        it("Should return true if an account has a balance greater than or equal to 10 and greater than or equal to 10 transactions", async () => {
+            jsonRpcProviderMocked.getBalance.mockReturnValue(BigNumber.from(12))
+
+            const credentials = [
+                {
+                    id: blockchainBalance.id,
+                    criteria: {
+                        minBalance: "10",
+                        network: "sepolia"
+                    }
+                },
+                {
+                    id: blockchainTransactions.id,
+                    criteria: {
+                        minTransactions: 10,
+                        network: "sepolia"
+                    }
+                }
+            ]
+
+            const contexts = [
+                {
+                    address: "0x",
+                    jsonRpcProvider: jsonRpcProviderMocked
+                },
+                {
+                    address: "0x",
+                    jsonRpcProvider: jsonRpcProviderMocked
+                }
+            ]
+            const expression = ["", "and", ""]
+            const result = await validateManyCredentials(
+                credentials,
+                contexts,
+                expression
+            )
+
+            expect(result).toBeTruthy()
+        })
+    })
 })
diff --git a/libs/credentials/src/index.ts b/libs/credentials/src/index.ts
index 0956398b..752e42bf 100644
--- a/libs/credentials/src/index.ts
+++ b/libs/credentials/src/index.ts
@@ -6,7 +6,10 @@ import getProvider from "./getProvider"
 import getValidator from "./getValidator"
 import providers from "./providers"
 import * as testUtils from "./testUtils"
-import validateCredentials from "./validateCredentials"
+import {
+    validateCredentials,
+    validateManyCredentials
+} from "./validateCredentials"
 import validators from "./validators"
 
 export * from "./providers/index"
@@ -14,6 +17,7 @@ export * from "./types"
 export * from "./validators/index"
 export {
     validateCredentials,
+    validateManyCredentials,
     addValidator,
     getProvider,
     getValidator,
diff --git a/libs/credentials/src/validateCredentials.ts b/libs/credentials/src/validateCredentials.ts
index 752b2c2a..950526a6 100644
--- a/libs/credentials/src/validateCredentials.ts
+++ b/libs/credentials/src/validateCredentials.ts
@@ -4,6 +4,8 @@ import getProvider from "./getProvider"
 import getValidator from "./getValidator"
 import { Context, Credentials, Web2Provider } from "./types"
 
+import { evaluate } from "./evaluateExpression"
+
 /**
  * It checks if the user meets the credentials of a group.
  * It also adds utility functions to the credentials context that
@@ -12,7 +14,7 @@ import { Context, Credentials, Web2Provider } from "./types"
  * @param context A set of context variables.
  * @returns True if the user meets the credentials.
  */
-export default async function validateCredentials(
+export async function validateCredentials(
     { id, criteria }: Credentials,
     context: Context
 ): Promise<boolean> {
@@ -40,3 +42,34 @@ export default async function validateCredentials(
 
     throw new Error("Credentials cannot be validated")
 }
+
+/**
+ * It checks if the user meets the credentials of a group
+ * when the group has multiple credentials.
+ * It also adds utility functions to the credentials context that
+ * can be used by validators.
+ * @param credentials The credentials of a group.
+ * @param contexts A list of sets of context variables.
+ * @returns True if the user meets the credentials.
+ */
+export async function validateManyCredentials(
+    credentials: Credentials[],
+    contexts: Context[],
+    expression: string[]
+): Promise<boolean> {
+    let position = 0
+    const expressionTokens: string[] = [...expression]
+    for (let i = 0; i < expression.length; i += 1) {
+        if (expression[i] === "") {
+            // eslint-disable-next-line no-await-in-loop
+            const elem = await validateCredentials(
+                credentials[position],
+                contexts[position]
+            )
+            expressionTokens[i] = elem.toString()
+            position += 1
+        }
+    }
+
+    return evaluate(expressionTokens)
+}

From 0bb6abab8da9b67faa8c43d79f18fbcb53ba908f Mon Sep 17 00:00:00 2001
From: Vivian Plasencia <v.pcalana@gmail.com>
Date: Fri, 21 Jun 2024 13:13:40 +0200
Subject: [PATCH 2/6] docs(credentials): update evaluate function docs

re #223
---
 libs/credentials/src/evaluateExpression.ts | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/libs/credentials/src/evaluateExpression.ts b/libs/credentials/src/evaluateExpression.ts
index 676d1f1c..d7fed910 100644
--- a/libs/credentials/src/evaluateExpression.ts
+++ b/libs/credentials/src/evaluateExpression.ts
@@ -1,6 +1,3 @@
-// This algorithm is an adaptation of the Shunting Yard algorithm for evaluating logical operators.
-// https://en.wikipedia.org/wiki/Shunting_yard_algorithm
-
 /**
  * Tokenization function to split the expression into meaningful tokens.
  * @param expression The expression to tokenize.
@@ -50,7 +47,10 @@ function applyOp(op: string, a: boolean, b?: boolean): boolean {
 }
 
 /**
- * Function to evaluate the tokenized expression
+ * Function to evaluate the tokenized expression.
+ * This algorithm is an adaptation of the
+ * {@link https://en.wikipedia.org/wiki/Shunting_yard_algorithm | Shunting Yard}
+ * algorithm to evaluate expressions with logical operators.
  * @param tokens Tokens of the expression.
  * The tokens can be boolean values, operators or parenthesis.
  * They represent a valid expression.

From 9bbf96a88d2c531ed3912b08199cfb7f15575eb7 Mon Sep 17 00:00:00 2001
From: Vivian Plasencia <v.pcalana@gmail.com>
Date: Tue, 25 Jun 2024 12:52:25 +0200
Subject: [PATCH 3/6] refactor(credentials): fix docker build

---
 libs/credentials/src/validateCredentials.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/libs/credentials/src/validateCredentials.ts b/libs/credentials/src/validateCredentials.ts
index 950526a6..c66936bb 100644
--- a/libs/credentials/src/validateCredentials.ts
+++ b/libs/credentials/src/validateCredentials.ts
@@ -50,6 +50,7 @@ export async function validateCredentials(
  * can be used by validators.
  * @param credentials The credentials of a group.
  * @param contexts A list of sets of context variables.
+ * @param expression Expression with the logical operators.
  * @returns True if the user meets the credentials.
  */
 export async function validateManyCredentials(
@@ -58,7 +59,7 @@ export async function validateManyCredentials(
     expression: string[]
 ): Promise<boolean> {
     let position = 0
-    const expressionTokens: string[] = [...expression]
+    const expressionTokens: string[] = expression.slice()
     for (let i = 0; i < expression.length; i += 1) {
         if (expression[i] === "") {
             // eslint-disable-next-line no-await-in-loop

From eacef6249606992219805fabf776eacfcac0c74d Mon Sep 17 00:00:00 2001
From: Vivian Plasencia <v.pcalana@gmail.com>
Date: Wed, 26 Jun 2024 13:26:45 +0200
Subject: [PATCH 4/6] docs: add some code comments

---
 apps/api/src/app/credentials/credentials.service.ts | 8 +++++---
 apps/dashboard/src/pages/credentials.tsx            | 4 ++--
 libs/credentials/src/index.test.ts                  | 1 +
 3 files changed, 8 insertions(+), 5 deletions(-)

diff --git a/apps/api/src/app/credentials/credentials.service.ts b/apps/api/src/app/credentials/credentials.service.ts
index d6893cfc..268cfd53 100644
--- a/apps/api/src/app/credentials/credentials.service.ts
+++ b/apps/api/src/app/credentials/credentials.service.ts
@@ -108,16 +108,18 @@ export class CredentialsService {
             credentials.credentials !== undefined &&
             credentials.expression !== undefined
         ) {
-            // multiple check
+            // The group has multiple credentials
+
             const contexts = []
             let accountHash: string
 
             for (let i = 0; i < credentials.credentials.length; i += 1) {
-                // get the name of the provider of the credential
+                // Get the name of the provider of the credential
                 const credentialProvider = credentials.credentials[i].id
                     .split("_")[0]
                     .toLowerCase()
 
+                // Find the OAuthState for this credential provider
                 const credentialOAuthState = oAuthState.find(
                     (s) =>
                         this.oAuthState.get(s).providerName ===
@@ -128,7 +130,7 @@ export class CredentialsService {
                     return
                 }
 
-                // get the oAuthState for this credential
+                // Get the oAuthState data for this credential
                 ;({
                     groupId,
                     memberId,
diff --git a/apps/dashboard/src/pages/credentials.tsx b/apps/dashboard/src/pages/credentials.tsx
index b53abb69..ad79ebfb 100644
--- a/apps/dashboard/src/pages/credentials.tsx
+++ b/apps/dashboard/src/pages/credentials.tsx
@@ -124,7 +124,7 @@ export default function CredentialsPage() {
                     let groupCredentials: any
 
                     if (group?.credentials) {
-                        // get the group credentials
+                        // Get the group credentials
                         groupCredentials = JSON.parse(group.credentials)
                     }
 
@@ -140,7 +140,7 @@ export default function CredentialsPage() {
                         localStorage.setItem(LOCAL_STORAGE, "")
                     }
 
-                    // check if the browser has any data saved, if not, save
+                    // Check if the browser has any data saved, if not, save
                     // the possible providers
                     // and start generating the urls
 
diff --git a/libs/credentials/src/index.test.ts b/libs/credentials/src/index.test.ts
index a3d2d684..41b670f2 100644
--- a/libs/credentials/src/index.test.ts
+++ b/libs/credentials/src/index.test.ts
@@ -102,6 +102,7 @@ describe("Credentials library", () => {
         })
         it("Should return true if an account has a balance greater than or equal to 10 and greater than or equal to 10 transactions", async () => {
             jsonRpcProviderMocked.getBalance.mockReturnValue(BigNumber.from(12))
+            jsonRpcProviderMocked.getTransactionCount.mockReturnValue(12)
 
             const credentials = [
                 {

From 16dcfa393d42c9482d4b105d7b705822a38ce48a Mon Sep 17 00:00:00 2001
From: Vivian Plasencia <v.pcalana@gmail.com>
Date: Wed, 26 Jun 2024 15:00:28 +0200
Subject: [PATCH 5/6] refactor: update variable name

---
 libs/credentials/src/validateCredentials.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libs/credentials/src/validateCredentials.ts b/libs/credentials/src/validateCredentials.ts
index c66936bb..3cbd72ca 100644
--- a/libs/credentials/src/validateCredentials.ts
+++ b/libs/credentials/src/validateCredentials.ts
@@ -63,11 +63,11 @@ export async function validateManyCredentials(
     for (let i = 0; i < expression.length; i += 1) {
         if (expression[i] === "") {
             // eslint-disable-next-line no-await-in-loop
-            const elem = await validateCredentials(
+            const isValidCredential = await validateCredentials(
                 credentials[position],
                 contexts[position]
             )
-            expressionTokens[i] = elem.toString()
+            expressionTokens[i] = isValidCredential.toString()
             position += 1
         }
     }

From 74e7874bbb9c565fcee6095d6dc9159755bcb9b9 Mon Sep 17 00:00:00 2001
From: Vivian Plasencia <v.pcalana@gmail.com>
Date: Thu, 27 Jun 2024 20:44:01 +0200
Subject: [PATCH 6/6] test(credentials): add more tests for different logical
 expressions

---
 libs/credentials/src/index.test.ts | 146 ++++++++++++++++++++++++++++-
 1 file changed, 143 insertions(+), 3 deletions(-)

diff --git a/libs/credentials/src/index.test.ts b/libs/credentials/src/index.test.ts
index 41b670f2..eef550f8 100644
--- a/libs/credentials/src/index.test.ts
+++ b/libs/credentials/src/index.test.ts
@@ -1,6 +1,7 @@
 import { BigNumber } from "ethers"
 import blockchainBalance from "./validators/blockchainBalance"
 import blockchainTransactions from "./validators/blockchainTransactions"
+import githubPersonalStars from "./validators/githubPersonalStars"
 import addProvider from "./addProvider"
 import addProviders from "./addProviders"
 import addValidator from "./addValidator"
@@ -13,6 +14,8 @@ import {
     validateCredentials,
     validateManyCredentials
 } from "./validateCredentials"
+import { testUtils } from "."
+import { evaluate, tokenize } from "./evaluateExpression"
 
 describe("Credentials library", () => {
     describe("# addProvider", () => {
@@ -81,8 +84,9 @@ describe("Credentials library", () => {
             getTransactionCount: jest.fn()
         }
         it("Should return true if an account has a balance greater than or equal to 10", async () => {
-            jsonRpcProviderMocked.getBalance.mockReturnValue(BigNumber.from(12))
-            jsonRpcProviderMocked.getTransactionCount.mockReturnValue(12)
+            jsonRpcProviderMocked.getBalance.mockReturnValue(
+                BigNumber.from("12000000000000000000")
+            )
 
             const result = await validateCredentials(
                 {
@@ -101,7 +105,9 @@ describe("Credentials library", () => {
             expect(result).toBeTruthy()
         })
         it("Should return true if an account has a balance greater than or equal to 10 and greater than or equal to 10 transactions", async () => {
-            jsonRpcProviderMocked.getBalance.mockReturnValue(BigNumber.from(12))
+            jsonRpcProviderMocked.getBalance.mockReturnValue(
+                BigNumber.from("12000000000000000000")
+            )
             jsonRpcProviderMocked.getTransactionCount.mockReturnValue(12)
 
             const credentials = [
@@ -140,5 +146,139 @@ describe("Credentials library", () => {
 
             expect(result).toBeTruthy()
         })
+        it("Should validate many credentials with parentheses in the expression", async () => {
+            // This will meet the criteria
+            jsonRpcProviderMocked.getBalance.mockReturnValue(
+                BigNumber.from("12000000000000000000")
+            )
+            // This will not meet the criteria
+            jsonRpcProviderMocked.getTransactionCount.mockReturnValue(8)
+            // This will meet the criteria
+            testUtils.mockAPIOnce(
+                Array.from(Array(20).keys()).map(() => ({
+                    stargazers_count: 10
+                }))
+            )
+
+            const credentials = [
+                {
+                    id: blockchainBalance.id,
+                    criteria: {
+                        minBalance: "10",
+                        network: "sepolia"
+                    }
+                },
+                {
+                    id: blockchainTransactions.id,
+                    criteria: {
+                        minTransactions: 10,
+                        network: "sepolia"
+                    }
+                },
+                {
+                    id: githubPersonalStars.id,
+                    criteria: {
+                        minStars: 100
+                    }
+                }
+            ]
+
+            const contexts = [
+                {
+                    address: "0x",
+                    jsonRpcProvider: jsonRpcProviderMocked
+                },
+                {
+                    address: "0x",
+                    jsonRpcProvider: jsonRpcProviderMocked
+                },
+                {
+                    profile: {},
+                    accessTokens: { github: "token" }
+                }
+            ]
+            const expression = ["", "and", "(", "", "or", "", ")"]
+            const result = await validateManyCredentials(
+                credentials,
+                contexts,
+                expression
+            )
+
+            expect(result).toBeTruthy()
+        })
+    })
+    describe("# evaluateExpression", () => {
+        describe("# tokenize", () => {
+            it("Should sucessfully tokenize a logical expression", () => {
+                const expression = "true and false or ( true and true )"
+
+                const tokens = tokenize(expression)
+
+                const result = [
+                    "true",
+                    "and",
+                    "false",
+                    "or",
+                    "(",
+                    "true",
+                    "and",
+                    "true",
+                    ")"
+                ]
+
+                expect(tokens).toStrictEqual(result)
+            })
+        })
+        describe("# evaluate", () => {
+            it("Should sucessfully evaluate a logical expression with the and operator", () => {
+                const expression = ["true", "and", "false"]
+                const result = evaluate(expression)
+                expect(result).toBeFalsy()
+            })
+            it("Should sucessfully evaluate a logical expression with the or operator", () => {
+                const expression = ["true", "or", "false"]
+                const result = evaluate(expression)
+                expect(result).toBeTruthy()
+            })
+            it("Should sucessfully evaluate a logical expression with the not operator", () => {
+                const expression = ["not", "false"]
+                const result = evaluate(expression)
+                expect(result).toBeTruthy()
+            })
+            it("Should sucessfully evaluate a logical expression with the xor operator", () => {
+                const expression = ["false", "xor", "true"]
+                const result = evaluate(expression)
+                expect(result).toBeTruthy()
+            })
+            it("Should sucessfully evaluate a logical expression with the and or not and xor operators", () => {
+                const expression = [
+                    "true",
+                    "and",
+                    "false",
+                    "or",
+                    "not",
+                    "false",
+                    "xor",
+                    "true"
+                ]
+                const result = evaluate(expression)
+                expect(result).toBeFalsy()
+            })
+            it("Should sucessfully evaluate a logical expression with parentheses", () => {
+                const expression = [
+                    "true",
+                    "and",
+                    "false",
+                    "or",
+                    "(",
+                    "true",
+                    "and",
+                    "true",
+                    ")"
+                ]
+                const result = evaluate(expression)
+                expect(result).toBeTruthy()
+            })
+        })
     })
 })