diff --git a/index.ts b/index.ts
index c2f9288aad104e23d9276c81a64e0936bff5be8f..25dda546d1aed9f4c3ac6b910f2eaae6fb7437de 100644
--- a/index.ts
+++ b/index.ts
@@ -42,7 +42,7 @@ program.command('main')
     while (true) {
       const role: Role = await getRole(tezos)
 
-      console.log(`Vous êtes connecté en tant que ${chalk.bgBlue(role)}\n`)
+      console.log(`\nVous êtes connecté en tant que ${chalk.bgBlue(role)}\n`)
 
       const questions = [
         {
@@ -65,7 +65,7 @@ program.command('main')
         case 'ADHERENT':
           // VOTER POUR UNE PROPOSITION
           // CLOTURER ET RESOUDRE LES PROPOSITIONS DONT IL EST LE CREATEUR
-          questions[0].choices = ['Faire une proposition', 'Voir les propositions', 'Créer un token']
+          questions[0].choices = ['Faire une proposition', 'Voter pour une proposition', 'Voir les propositions', 'Créer un token']
 
           if (await handleHasToken(tezos)) { questions[0].choices.push('Bruler des tokens') }
 
diff --git a/src/features/association/createAssociation.ts b/src/features/association/createAssociation.ts
index 6891f7765431fed582dafc48fecc7aa98bc25c9d..3af3c0c358f9a89435bdc3581352d4108298c26a 100644
--- a/src/features/association/createAssociation.ts
+++ b/src/features/association/createAssociation.ts
@@ -4,9 +4,9 @@ import { handleCreateAssociation } from '../../handlers/association/associationH
 
 async function createAssociation (tezos: TezosToolkit): Promise<void> {
   await handleCreateAssociation(tezos).then(() => {
-    console.log(chalk.bgGreenBright('\nVotre association a été créée !!\n'))
+    console.log(chalk.bgGreenBright('\nVotre association a été créée !!'))
   }).catch((error) => {
-    console.log(chalk.bgRed(`\n${error.message}\n`))
+    console.log(chalk.bgRed(`\n${error.message}`))
   })
 }
 
diff --git a/src/features/association/joinAssociation.ts b/src/features/association/joinAssociation.ts
index 7deff69db297da29273df93744b329ba2d44dbaf..5222356e876ef14cf7ad8e3aaf80638399db9205 100644
--- a/src/features/association/joinAssociation.ts
+++ b/src/features/association/joinAssociation.ts
@@ -7,12 +7,12 @@ async function joinAssociation (tezos: TezosToolkit): Promise<void> {
     const associationsByName: string[] = response
 
     await handleJoinAssociation(associationsByName, tezos).then(() => {
-      console.log(chalk.bgGreenBright("\nVous avez rejoint l'association !!\n"))
+      console.log(chalk.bgGreenBright("\nVous avez rejoint l'association !!"))
     }).catch((error) => {
-      console.log(chalk.bgRed(`\n${error.message}\n`))
+      console.log(chalk.bgRed(`\n${error.message}`))
     })
   }).catch((error) => {
-    console.log(chalk.bgRed(`\n${error.message}\n`))
+    console.log(chalk.bgRed(`\n${error.message}`))
   })
 }
 
diff --git a/src/features/association/showAssociationDetails.ts b/src/features/association/showAssociationDetails.ts
index cabe9ee948cf3c1d38153e265b7adb244a0fb2b0..dc5398797dcc916d57dba83461a0279a8418a7cd 100644
--- a/src/features/association/showAssociationDetails.ts
+++ b/src/features/association/showAssociationDetails.ts
@@ -5,15 +5,18 @@ import { handleGetAssociationDetails, handleGetAssociations } from '../../handle
 async function showAssociationDetails (tezos: TezosToolkit): Promise<void> {
   await handleGetAssociations(tezos).then(async (response) => {
     const associationsByName = response
+
+    if (response.length === 0) throw new Error('Aucune association existante')
+
     await handleGetAssociationDetails(associationsByName, tezos).then((details) => {
       const associationDetails = details
-      console.log(`Nom de l'association: ${chalk.yellow(associationDetails.name)}`)
-      console.log(`Description de l'association: ${chalk.yellow(associationDetails.description)}`)
+      console.log(`${chalk.cyan('Nom:')} ${chalk.yellow(associationDetails.name)}`)
+      console.log(`${chalk.cyan('Description:')} ${chalk.yellow(associationDetails.description)}`)
     }).catch((error) => {
-      console.log(chalk.bgRed(`\n${error.message}\n`))
+      console.log(chalk.bgRed(`\n${error.message}`))
     })
   }).catch((error) => {
-    console.log(chalk.bgRed(`\n${error.message}\n`))
+    console.log(chalk.bgRed(`\n${error.message}`))
   })
 }
 
diff --git a/src/features/association/showAssociations.ts b/src/features/association/showAssociations.ts
index 04f4985df83011698d409cdd0336511c8784ebdb..74e24adeefad0dad1a15317ffedc6f8b0ae0ef89 100644
--- a/src/features/association/showAssociations.ts
+++ b/src/features/association/showAssociations.ts
@@ -5,9 +5,12 @@ import { handleGetAssociations } from '../../handlers/association/associationHan
 async function showAssociations (tezos: TezosToolkit): Promise<void> {
   await handleGetAssociations(tezos).then((response) => {
     const associationsByName = response
+
+    if (response.length === 0) throw new Error('Aucune association existante')
+
     associationsByName.forEach(name => { console.log(chalk.yellow(name)) })
   }).catch((error) => {
-    console.log(chalk.bgRed(`\n${error.message}\n`))
+    console.log(chalk.bgRed(`\n${error.message}`))
   })
 }
 
diff --git a/src/features/balance/showBalance.ts b/src/features/balance/showBalance.ts
index ebd9de1b6e8ac0799c7c2a14583303ae68c7ae3f..91057fe7e087dcb7d712cce01163fa07574daf5f 100644
--- a/src/features/balance/showBalance.ts
+++ b/src/features/balance/showBalance.ts
@@ -4,9 +4,9 @@ import { handleGetBalance } from '../../handlers/balance/balanceHandlers.js'
 
 async function showBalance (tezos: TezosToolkit): Promise<void> {
   await handleGetBalance(tezos).then((response) => {
-    console.log(`\nSolde du portefeuille: ${response} ꜩ\n`)
+    console.log(`\nSolde du portefeuille: ${response} ꜩ`)
   }).catch((error) => {
-    console.log(chalk.bgRed(`\n${error.message}\n`))
+    console.log(chalk.bgRed(`\n${error.message}`))
   })
 }
 
diff --git a/src/features/proposal/closeProposal.ts b/src/features/proposal/closeProposal.ts
index 3307d31d6628ff1d20ad40a382fb7935c0b67376..4a0743f95938e96f576940311e1a45fff9cb880e 100644
--- a/src/features/proposal/closeProposal.ts
+++ b/src/features/proposal/closeProposal.ts
@@ -9,12 +9,12 @@ async function closeProposal (tezos: TezosToolkit): Promise<void> {
     if (response.length === 0) throw new Error("Aucune proposition n'est ouverte")
 
     await handleCloseProposal(proposalsByTitle, tezos).then(() => {
-      console.log(chalk.bgGreenBright('\nVous avez clôturé la proposition !!\n'))
+      console.log(chalk.bgGreenBright('\nVous avez clôturé la proposition !!'))
     }).catch((error) => {
-      console.log(chalk.bgRed(`\n${error.message}\n`))
+      console.log(chalk.bgRed(`\n${error.message}`))
     })
   }).catch((error) => {
-    console.log(chalk.bgRed(`\n${error.message}\n`))
+    console.log(chalk.bgRed(`\n${error.message}`))
   })
 }
 
diff --git a/src/features/proposal/createProposal.ts b/src/features/proposal/createProposal.ts
index 9a8dc2c7c3a07d9f8ce42575f1fdafd52993677c..0056904fe478ab9b6dbad915623454e83e5150da 100644
--- a/src/features/proposal/createProposal.ts
+++ b/src/features/proposal/createProposal.ts
@@ -4,9 +4,9 @@ import { handleCreateProposal } from '../../handlers/proposal/proposalHandlers.j
 
 async function createProposal (tezos: TezosToolkit): Promise<void> {
   await handleCreateProposal(tezos).then(() => {
-    console.log(chalk.bgGreenBright('\nVous avez soumis une proposition !!\n'))
+    console.log(chalk.bgGreenBright('\nVous avez soumis une proposition !!'))
   }).catch((error) => {
-    console.log(chalk.bgRed(`\n${error.message}\n`))
+    console.log(chalk.bgRed(`\n${error.message}`))
   })
 }
 
diff --git a/src/features/proposal/resolveProposal.ts b/src/features/proposal/resolveProposal.ts
index 7477c596bd434413e47db79b16d40df285c6b496..a61360ecefdabe76c9420b01ee81037cf6edcaaa 100644
--- a/src/features/proposal/resolveProposal.ts
+++ b/src/features/proposal/resolveProposal.ts
@@ -9,12 +9,12 @@ async function resolveProposal (tezos: TezosToolkit): Promise<void> {
     if (response.length === 0) throw new Error("Aucune proposition n'est résoluble")
 
     await handleResolveProposal(proposalsByTitle, tezos).then(() => {
-      console.log(chalk.bgGreenBright('\nVous avez résolue la proposition !!\n'))
+      console.log(chalk.bgGreenBright('\nVous avez résolue la proposition !!'))
     }).catch((error) => {
-      console.log(chalk.bgRed(`\n${error.message}\n`))
+      console.log(chalk.bgRed(`\n${error.message}`))
     })
   }).catch((error) => {
-    console.log(chalk.bgRed(`\n${error.message}\n`))
+    console.log(chalk.bgRed(`\n${error.message}`))
   })
 }
 
diff --git a/src/features/proposal/showProposals.ts b/src/features/proposal/showProposals.ts
index 7cb71f9b8ced3b0c40dc0996c8ac48f46c9f0da4..c85dda0a84edd6929aa44841934a75b2856229cc 100644
--- a/src/features/proposal/showProposals.ts
+++ b/src/features/proposal/showProposals.ts
@@ -5,9 +5,12 @@ import { handleGetProposals } from '../../handlers/proposal/proposalHandlers.js'
 async function showProposals (tezos: TezosToolkit): Promise<void> {
   await handleGetProposals(tezos).then((response) => {
     const proposalsByTitle = response
+
+    if (response.length === 0) throw new Error('Aucune proposition existante')
+
     proposalsByTitle.forEach(title => { console.log(chalk.yellow(title)) })
   }).catch((error) => {
-    console.log(chalk.bgRed(`\n${error.message}\n`))
+    console.log(chalk.bgRed(`\n${error.message}`))
   })
 }
 
diff --git a/src/features/proposal/voteProposal.ts b/src/features/proposal/voteProposal.ts
new file mode 100644
index 0000000000000000000000000000000000000000..fd6ec9e4c50260d25f6e827eeb107245638aac3f
--- /dev/null
+++ b/src/features/proposal/voteProposal.ts
@@ -0,0 +1,21 @@
+import { type TezosToolkit } from '@taquito/taquito'
+import chalk from 'chalk'
+import { handleGetOpenProposals, handleVoteProposal } from '../../handlers/proposal/proposalHandlers.js'
+
+async function voteProposal (tezos: TezosToolkit): Promise<void> {
+  await handleGetOpenProposals(tezos).then(async (response) => {
+    const proposalsByTitle: string[] = response
+
+    if (response.length === 0) throw new Error("Aucune proposition n'est ouverte")
+
+    await handleVoteProposal(proposalsByTitle, tezos).then(() => {
+      console.log(chalk.bgGreenBright('\nVous avez voté pour cette proposition !!'))
+    }).catch((error) => {
+      console.log(chalk.bgRed(`\n${error.message}`))
+    })
+  }).catch((error) => {
+    console.log(chalk.bgRed(`\n${error.message}`))
+  })
+}
+
+export { voteProposal }
diff --git a/src/features/token/burnToken.ts b/src/features/token/burnToken.ts
index a2bd04d67ae45e663a4e6c847e5f26cd5fc0e37e..e301093feefbf85904a78b1f495bb646cd185c96 100644
--- a/src/features/token/burnToken.ts
+++ b/src/features/token/burnToken.ts
@@ -4,9 +4,9 @@ import { handleBurnToken } from '../../handlers/token/tokenHandlers.js'
 
 async function burnToken (tezos: TezosToolkit): Promise<void> {
   await handleBurnToken(tezos).then(() => {
-    console.log(chalk.bgGreenBright('\nVous avez bruler vos tokens !!\n'))
+    console.log(chalk.bgGreenBright('\nVous avez bruler vos tokens !!'))
   }).catch((error) => {
-    console.log(chalk.bgRed(`\n${error.message}\n`))
+    console.log(chalk.bgRed(`\n${error.message}`))
   })
 }
 
diff --git a/src/features/token/createToken.ts b/src/features/token/createToken.ts
index 4a780e498235aacd726968485856470bd47bec86..478106f5911ff5226df1b08f64d5f17f6f3664cb 100644
--- a/src/features/token/createToken.ts
+++ b/src/features/token/createToken.ts
@@ -4,9 +4,9 @@ import { handleCreateToken } from '../../handlers/token/tokenHandlers.js'
 
 async function createToken (tezos: TezosToolkit): Promise<void> {
   await handleCreateToken(tezos).then(() => {
-    console.log(chalk.bgGreenBright('\nVotre token a été créé !!\n'))
+    console.log(chalk.bgGreenBright('\nVotre token a été créé !!'))
   }).catch((error) => {
-    console.log(chalk.bgRed(`\n${error.message}\n`))
+    console.log(chalk.bgRed(`\n${error.message}`))
   })
 }
 
diff --git a/src/handlers/association/associationHandlers.ts b/src/handlers/association/associationHandlers.ts
index 7bbfc678455ebfaf8a18fa2f87d0559025737532..f7f4db3fe6c48d7fe4e02bb85f6b172d049591c6 100644
--- a/src/handlers/association/associationHandlers.ts
+++ b/src/handlers/association/associationHandlers.ts
@@ -57,7 +57,7 @@ async function handleCreateAssociation (tezos: TezosToolkit): Promise<void> {
   try {
     await createAssociation(association, tezos)
   } catch (error) {
-    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    const errorMessage = error.lastError?.with?.string ? error.lastError.with.string : 'Unknown error occurred'
     throw new Error(`${errorMessage}`)
   }
 }
@@ -87,7 +87,7 @@ async function handleJoinAssociation (associations: string[], tezos: TezosToolki
   try {
     await joinAssociation(associationName, tezos)
   } catch (error) {
-    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    const errorMessage = error.lastError?.with?.string ? error.lastError.with.string : 'Unknown error occurred'
     throw new Error(`${errorMessage}`)
   }
 }
@@ -102,7 +102,7 @@ async function handleGetAssociations (tezos: TezosToolkit): Promise<string[]> {
     const associations = await getAssociations(tezos)
     return associations.map(association => association.name)
   } catch (error) {
-    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    const errorMessage = error.message ? error.message : 'Unknown error occurred'
     throw new Error(`${errorMessage}`)
   }
 }
@@ -132,7 +132,7 @@ async function handleGetAssociationDetails (associations: string[], tezos: Tezos
   try {
     return await getAssociationDetails(associationName, tezos)
   } catch (error) {
-    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    const errorMessage = error.message ? error.message : 'Unknown error occurred'
     throw new Error(`${errorMessage}`)
   }
 }
@@ -146,7 +146,7 @@ async function handleIsAdmin (tezos: TezosToolkit): Promise<boolean> {
   try {
     return await isAdminOfAssociation(tezos)
   } catch (error) {
-    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    const errorMessage = error.message ? error.message : 'Unknown error occurred'
     throw new Error(`${errorMessage}`)
   }
 }
diff --git a/src/handlers/proposal/proposalHandlers.ts b/src/handlers/proposal/proposalHandlers.ts
index 707f5e32f7518e3c569e904accd5b460b9adebd3..6e92e1a754923b7215463d59ea3cff51f78f44db 100644
--- a/src/handlers/proposal/proposalHandlers.ts
+++ b/src/handlers/proposal/proposalHandlers.ts
@@ -5,8 +5,9 @@ import { type TezosToolkit } from '@taquito/taquito'
 import { type Proposal } from '../../types/Proposal.js'
 
 // IMPORT SERVICES
-import { closeProposal, createProposal, getProposals, resolveProposal } from '../../services/proposal.service.js'
+import { closeProposal, createProposal, getProposals, resolveProposal, voteForProposal } from '../../services/proposal.service.js'
 import inquirer from 'inquirer'
+import { type Vote } from '../../types/Vote.js'
 
 /**
  * Handles the process of creating a proposal.
@@ -57,7 +58,7 @@ async function handleCreateProposal (tezos: TezosToolkit): Promise<void> {
   try {
     await createProposal(proposal, tezos)
   } catch (error) {
-    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    const errorMessage = error.lastError?.with?.string ? error.lastError.with.string : 'Unknown error occurred'
     throw new Error(`${errorMessage}`)
   }
 }
@@ -78,16 +79,16 @@ async function handleResolveProposal (proposals: string[], tezos: TezosToolkit):
     }
   ]
 
-  let associationName: string
+  let proposalName: string
 
   await inquirer.prompt(questions).then(async (answers: { choice: string }) => {
-    associationName = answers.choice
+    proposalName = answers.choice
   })
 
   try {
-    await resolveProposal(associationName, tezos)
+    await resolveProposal(proposalName, tezos)
   } catch (error) {
-    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    const errorMessage = error.lastError?.with?.string ? error.lastError.with.string : 'Unknown error occurred'
     throw new Error(`${errorMessage}`)
   }
 }
@@ -108,16 +109,16 @@ async function handleCloseProposal (proposals: string[], tezos: TezosToolkit): P
     }
   ]
 
-  let associationName: string
+  let proposalName: string
 
   await inquirer.prompt(questions).then(async (answers: { choice: string }) => {
-    associationName = answers.choice
+    proposalName = answers.choice
   })
 
   try {
-    await closeProposal(associationName, tezos)
+    await closeProposal(proposalName, tezos)
   } catch (error) {
-    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    const errorMessage = error.lastError?.with?.string ? error.lastError.with.string : 'Unknown error occurred'
     throw new Error(`${errorMessage}`)
   }
 }
@@ -132,7 +133,7 @@ async function handleGetProposals (tezos: TezosToolkit): Promise<string[]> {
     const proposals: Proposal[] = await getProposals(tezos)
     return proposals.map(proposal => proposal.title)
   } catch (error) {
-    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    const errorMessage = error.message ? error.message : 'Unknown error occurred'
     throw new Error(`${errorMessage}`)
   }
 }
@@ -147,7 +148,7 @@ async function handleGetOpenProposals (tezos: TezosToolkit): Promise<string[]> {
     const proposals: Proposal[] = await getProposals(tezos)
     return proposals.filter(proposal => proposal.isOpen).map(proposal => proposal.title)
   } catch (error) {
-    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    const errorMessage = error.message ? error.message : 'Unknown error occurred'
     throw new Error(`${errorMessage}`)
   }
 }
@@ -162,9 +163,56 @@ async function handleGetSolvableProposals (tezos: TezosToolkit): Promise<string[
     const proposals: Proposal[] = await getProposals(tezos)
     return proposals.filter(proposal => proposal.approveRate >= 51).map(proposal => proposal.title)
   } catch (error) {
-    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    const errorMessage = error.message ? error.message : 'Unknown error occurred'
     throw new Error(`${errorMessage}`)
   }
 }
 
-export { handleCreateProposal, handleResolveProposal, handleGetProposals, handleCloseProposal, handleGetOpenProposals, handleGetSolvableProposals }
+/**
+ * Handles the process of vote proposal.
+ * @param {string[]} proposals - A list of proposal title.
+ * @param {TezosToolkit} tezos - The TezosToolkit instance used for blockchain operations.
+ * @returns {Promise<void>} A promise resolved once the close process is complete.
+ */
+async function handleVoteProposal (proposals: string[], tezos: TezosToolkit): Promise<void> {
+  const voteAvailable = ['Yay', 'Nope', 'Pass']
+
+  const propositionQuestions = [
+    {
+      type: 'list',
+      name: 'choice',
+      message: 'Pour quelle proposition voulez-vous voter ?',
+      choices: proposals
+    }
+  ]
+
+  let proposalName: string
+
+  await inquirer.prompt(propositionQuestions).then(async (answers: { choice: string }) => {
+    proposalName = answers.choice
+  })
+
+  const proposalVoteQuestions = [
+    {
+      type: 'list',
+      name: 'choice',
+      message: 'Quel est votre vote',
+      choices: voteAvailable
+    }
+  ]
+
+  let vote: Vote
+
+  await inquirer.prompt(proposalVoteQuestions).then(async (answers: { choice: Vote }) => {
+    vote = answers.choice
+  })
+
+  try {
+    await voteForProposal(proposalName, vote, tezos)
+  } catch (error) {
+    const errorMessage = error.lastError?.with?.string ? error.lastError.with.string : 'Unknown error occurred'
+    throw new Error(`${errorMessage}`)
+  }
+}
+
+export { handleCreateProposal, handleResolveProposal, handleGetProposals, handleCloseProposal, handleGetOpenProposals, handleGetSolvableProposals, handleVoteProposal }
diff --git a/src/handlers/roleHandlers.ts b/src/handlers/roleHandlers.ts
index 095352b6afbecb7272a4f39b046760e5b8597843..abe0d493f7499bf6017882fe8b05922eb2c50728 100644
--- a/src/handlers/roleHandlers.ts
+++ b/src/handlers/roleHandlers.ts
@@ -11,6 +11,7 @@ import { createProposal } from '../features/proposal/createProposal.js'
 import { resolveProposal } from '../features/proposal/resolveProposal.js'
 import { showProposals } from '../features/proposal/showProposals.js'
 import { closeProposal } from '../features/proposal/closeProposal.js'
+import { voteProposal } from '../features/proposal/voteProposal.js'
 
 /**
    * Handles administrator actions based on the specified choice.
@@ -61,6 +62,9 @@ async function handleAdherentChoice (choice: string, tezos: TezosToolkit): Promi
     case 'Voir les propositions':
       await showProposals(tezos)
       break
+    case 'Voter pour une proposition':
+      await voteProposal(tezos)
+      break
     case 'Voir mon portefeuille':
       await showBalance(tezos)
       break
diff --git a/src/handlers/token/tokenHandlers.ts b/src/handlers/token/tokenHandlers.ts
index edb1f2728d14ba8c78fe18bb524bb9db05e9b594..2c6d1f69a43526e93fb31b100c4f9af93d46c361 100644
--- a/src/handlers/token/tokenHandlers.ts
+++ b/src/handlers/token/tokenHandlers.ts
@@ -38,7 +38,7 @@ async function handleCreateToken (tezos: TezosToolkit): Promise<void> {
   try {
     await createFAToken(nbTokenFungible, tezos)
   } catch (error) {
-    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    const errorMessage = error.lastError?.with?.string ? error.lastError.with.string : 'Unknown error occurred'
     throw new Error(`${errorMessage}`)
   }
 }
@@ -76,7 +76,7 @@ async function handleBurnToken (tezos: TezosToolkit): Promise<void> {
   try {
     await burnToken(nbTokenToBurn, tezos)
   } catch (error) {
-    const errorMessage = error.lastError.with.string ? error.lastError.with.string : 'Unknown error occurred'
+    const errorMessage = error.lastError?.with?.string ? error.lastError.with.string : 'Unknown error occurred'
     throw new Error(`${errorMessage}`)
   }
 }
diff --git a/src/services/association.service.ts b/src/services/association.service.ts
index 6a00b3d038b4c66d874c3b2bf8a2578dcfcc8dc7..8c74d270d0abff38cfa574ca69bfd49f7e4b99fe 100644
--- a/src/services/association.service.ts
+++ b/src/services/association.service.ts
@@ -2,18 +2,7 @@ import { type Operation, type TezosToolkit } from '@taquito/taquito'
 import { type Association } from '../types/Association'
 
 // NEED UPDATE ADDRESS !! (SMART CONTRACT 1: Registre des associations)
-const address = 'KT1Vvjy6eWKztgFkraPYGqkvaiRcLmF2mxAJ'
-
-const mockAssociations: Association[] = [
-  {
-    name: 'Test',
-    description: "Ceci est l'association 1"
-  },
-  {
-    name: 'Association 2',
-    description: "Ceci est l'association 2"
-  }
-]
+const address = 'KT1ACcRhzuDzVKpwzjZTudcQchEijvj7b7cp'
 
 async function createAssociation (association: Association, tezos: TezosToolkit): Promise<void> {
   const contract = await tezos.contract.at(address)
@@ -33,14 +22,20 @@ async function joinAssociation (associationName: string, tezos: TezosToolkit): P
 
 // NEED UPDATE ENTRYPOINT !!
 async function getAssociations (tezos: TezosToolkit): Promise<Association[]> {
-  // const contract = await tezos.contract.at(address)
-  // const op: Operation = await contract.methodsObject.getAssociations().send()
+  const contract = await tezos.contract.at(address)
+  const associations: Association[] = []
 
-  // await op.confirmation()
-  // return op
+  const executionContextParams = {
+    viewCaller: contract.address
+  }
+
+  const associationsMap: Map<string, Association> = await contract.contractViews.listAllAssociations().executeView(executionContextParams)
+
+  associationsMap.forEach((association) => {
+    associations.push(association)
+  })
 
-  // MOCK
-  return mockAssociations
+  return associations
 }
 
 async function getAssociationDetails (associationName: string, tezos: TezosToolkit): Promise<Association> {
diff --git a/src/services/proposal.service.ts b/src/services/proposal.service.ts
index c6caeff394d3ee58c7007eede278afb2851cfd66..215e781729b3784d57ba4ff906f85ec1fa82b0e7 100644
--- a/src/services/proposal.service.ts
+++ b/src/services/proposal.service.ts
@@ -1,5 +1,6 @@
 import { type Operation, type TezosToolkit } from '@taquito/taquito'
 import { type Proposal } from '../types/Proposal'
+import { type Vote } from '../types/Vote'
 
 // NEED UPDATE ADDRESS !! (SMART CONTRACT 2: Factory de DAO)
 const address = 'KT1QZJzhSPQ89K4eC59tmQYCt44qph7wXoJu'
@@ -26,7 +27,7 @@ async function createProposal (proposal: Proposal, tezos: TezosToolkit): Promise
 }
 
 // NEED UPDATE ENTRYPOINT !!
-async function voteForProposal (proposalName: string, vote: boolean, tezos: TezosToolkit): Promise<void> {
+async function voteForProposal (proposalName: string, vote: Vote, tezos: TezosToolkit): Promise<void> {
   const proposalVote = {
     proposalName,
     proposalVote: vote
diff --git a/src/types/Vote.ts b/src/types/Vote.ts
new file mode 100644
index 0000000000000000000000000000000000000000..be3c840dc88da5fb912769ade5130c00acedb6c7
--- /dev/null
+++ b/src/types/Vote.ts
@@ -0,0 +1 @@
+export type Vote = 'Yay' | 'Nope' | 'Pass'
diff --git a/src/utils/getRole.ts b/src/utils/getRole.ts
index b5bab0f62daba0d5b8b2998593c9275d2d8a7e33..d6de12fa4f7caaafe08aa2486790b3cb0ece1098 100644
--- a/src/utils/getRole.ts
+++ b/src/utils/getRole.ts
@@ -3,9 +3,9 @@ import { type Role } from '../types/Role'
 import { handleIsAdmin } from '../handlers/association/associationHandlers.js'
 
 export async function getRole (tezos: TezosToolkit): Promise<Role> {
-  const isAdmin = await handleIsAdmin(tezos)
+  // const isAdmin = await handleIsAdmin(tezos)
 
-  if (isAdmin) return 'ADMIN'
+  // if (isAdmin) return 'ADMIN'
 
   // TEMPORARY
   return 'CONNECTED'
diff --git a/test/handlers/association/associationHandlers.spec.ts b/test/handlers/association/associationHandlers.spec.ts
index 5132f7254632a9fa1d5f5a4de2a0f734d65f3c7b..fa5210c31ec027ee61bb6b226f4f95d19f3ccd75 100644
--- a/test/handlers/association/associationHandlers.spec.ts
+++ b/test/handlers/association/associationHandlers.spec.ts
@@ -141,11 +141,7 @@ describe('associationHandlers', () => {
     describe('when getAssociations is called with error', () => {
       it('should throw error with correct message', async () => {
         const error = {
-          lastError: {
-            with: {
-              string: 'Custom Error'
-            }
-          }
+          message: 'Custom Error'
         }
         getAssociationsSpy.mockRejectedValueOnce(error)
 
@@ -180,11 +176,7 @@ describe('associationHandlers', () => {
     describe('when getAssociationDetails is called with error', () => {
       it('should throw error with correct message', async () => {
         const error = {
-          lastError: {
-            with: {
-              string: 'Custom Error'
-            }
-          }
+          message: 'Custom Error'
         }
         getAssociationDetailsSpy.mockRejectedValueOnce(error)
 
diff --git a/test/handlers/proposal/proposalHandlers.spec.ts b/test/handlers/proposal/proposalHandlers.spec.ts
index eae0f45c744d89c7e9f8054089810240fbc8de6e..7785c335dc6648f35efa2d82dfaeacca7e18c6d1 100644
--- a/test/handlers/proposal/proposalHandlers.spec.ts
+++ b/test/handlers/proposal/proposalHandlers.spec.ts
@@ -1,11 +1,14 @@
-import { handleCreateProposal } from '../../../src/handlers/proposal/proposalHandlers'
+import { handleCloseProposal, handleCreateProposal, handleGetOpenProposals, handleGetProposals, handleGetSolvableProposals, handleResolveProposal } from '../../../src/handlers/proposal/proposalHandlers'
 import { type TezosToolkit } from '@taquito/taquito'
 import { vi, describe, it, expect, beforeEach } from 'vitest'
 
-const { promptSpy, createProposalSpy } =
+const { promptSpy, createProposalSpy, getProposalsSpy, closeProposalSpy, resolveProposalSpy } =
   vi.hoisted(() => {
     return {
       createProposalSpy: vi.fn().mockResolvedValue({}),
+      getProposalsSpy: vi.fn().mockResolvedValue({}),
+      closeProposalSpy: vi.fn().mockResolvedValue({}),
+      resolveProposalSpy: vi.fn().mockResolvedValue({}),
       promptSpy: vi.fn().mockResolvedValue({})
     }
   })
@@ -26,7 +29,10 @@ vi.mock('inquirer', async (importOriginal) => {
 })
 
 vi.mock('../../../src/services/proposal.service', () => ({
-  createProposal: createProposalSpy
+  createProposal: createProposalSpy,
+  getProposals: getProposalsSpy,
+  closeProposal: closeProposalSpy,
+  resolveProposal: resolveProposalSpy
 }))
 
 const mockedTezosToolkit = {} as unknown as TezosToolkit
@@ -68,4 +74,183 @@ describe('proposalHandlers', () => {
       })
     })
   })
+
+  describe('handleCloseProposal', () => {
+    describe('when closeProposal is called with success', () => {
+      it('should close proposal with provided title', async () => {
+        const proposals = ['Proposal 1', 'Proposal 2']
+        const proposalChoose = 'Proposal 1'
+
+        promptSpy.mockResolvedValueOnce({ choice: proposalChoose })
+        await handleCloseProposal(proposals, mockedTezosToolkit)
+
+        expect(closeProposalSpy).toBeCalledWith(proposalChoose, mockedTezosToolkit)
+      })
+    })
+
+    describe('when closeProposal is called with error', () => {
+      it('should throw error with correct message', async () => {
+        const error = {
+          lastError: {
+            with: {
+              string: 'Custom Error'
+            }
+          }
+        }
+        closeProposalSpy.mockRejectedValueOnce(error)
+        const proposals = ['Proposal 1', 'Proposal 2']
+        const proposalChoose = 'Proposal 1'
+
+        promptSpy.mockResolvedValueOnce({ choice: proposalChoose })
+
+        await expect(handleCloseProposal(proposals, mockedTezosToolkit)).rejects.toThrow('Custom Error')
+      })
+    })
+  })
+
+  describe('handleResolveProposal', () => {
+    describe('when resolveProposal is called with success', () => {
+      it('should resolve proposal with provided title', async () => {
+        const proposals = ['Proposal 1', 'Proposal 2']
+        const proposalChoose = 'Proposal 1'
+
+        promptSpy.mockResolvedValueOnce({ choice: proposalChoose })
+        await handleResolveProposal(proposals, mockedTezosToolkit)
+
+        expect(resolveProposalSpy).toBeCalledWith(proposalChoose, mockedTezosToolkit)
+      })
+    })
+
+    describe('when resolveProposal is called with error', () => {
+      it('should throw error with correct message', async () => {
+        const error = {
+          lastError: {
+            with: {
+              string: 'Custom Error'
+            }
+          }
+        }
+        resolveProposalSpy.mockRejectedValueOnce(error)
+        const proposals = ['Proposal 1', 'Proposal 2']
+        const proposalChoose = 'Proposal 1'
+
+        promptSpy.mockResolvedValueOnce({ choice: proposalChoose })
+
+        await expect(handleResolveProposal(proposals, mockedTezosToolkit)).rejects.toThrow('Custom Error')
+      })
+    })
+  })
+
+  describe('handleGetProposals', () => {
+    describe('when getProposals is called with success', () => {
+      it('should call getProposals and return proposal', async () => {
+        getProposalsSpy.mockResolvedValueOnce([
+          {
+            title: 'Proposal 1',
+            description: 'Proposal 1 description'
+          },
+          {
+            title: 'Proposal 2',
+            description: 'Proposal 2 description'
+          }
+        ])
+        const proposals = await handleGetProposals(mockedTezosToolkit)
+
+        expect(getProposalsSpy).toBeCalledWith(mockedTezosToolkit)
+        expect(proposals).toStrictEqual(
+          [
+            'Proposal 1',
+            'Proposal 2'
+          ]
+        )
+      })
+    })
+
+    describe('when getProposals is called with error', () => {
+      it('should throw error with correct message', async () => {
+        const error = {
+          message: 'Custom Error'
+        }
+        getProposalsSpy.mockRejectedValueOnce(error)
+
+        await expect(handleGetProposals(mockedTezosToolkit)).rejects.toThrow('Custom Error')
+      })
+    })
+  })
+
+  describe('handleGetOpenProposals', () => {
+    describe('when getProposals is called with success', () => {
+      it('should call getProposals and return only open proposal', async () => {
+        getProposalsSpy.mockResolvedValueOnce([
+          {
+            title: 'Proposal 1',
+            description: 'Proposal 1 description',
+            isOpen: true
+          },
+          {
+            title: 'Proposal 2',
+            description: 'Proposal 2 description',
+            isOpen: false
+          }
+        ])
+        const proposals = await handleGetOpenProposals(mockedTezosToolkit)
+
+        expect(getProposalsSpy).toBeCalledWith(mockedTezosToolkit)
+        expect(proposals).toStrictEqual(
+          [
+            'Proposal 1'
+          ]
+        )
+      })
+    })
+
+    describe('when getProposals is called with error', () => {
+      it('should throw error with correct message', async () => {
+        const error = {
+          message: 'Custom Error'
+        }
+        getProposalsSpy.mockRejectedValueOnce(error)
+
+        await expect(handleGetOpenProposals(mockedTezosToolkit)).rejects.toThrow('Custom Error')
+      })
+    })
+  })
+
+  describe('handleGetSolvableProposals', () => {
+    describe('when getProposals is called with success', () => {
+      it('should call getProposals and return only solvable proposal', async () => {
+        getProposalsSpy.mockResolvedValueOnce([
+          {
+            title: 'Proposal 1',
+            description: 'Proposal 1 description',
+            approveRate: 49
+          },
+          {
+            title: 'Proposal 2',
+            description: 'Proposal 2 description',
+            approveRate: 51
+          }
+        ])
+        const proposals = await handleGetSolvableProposals(mockedTezosToolkit)
+
+        expect(getProposalsSpy).toBeCalledWith(mockedTezosToolkit)
+        expect(proposals).toStrictEqual(
+          [
+            'Proposal 2'
+          ]
+        )
+      })
+    })
+
+    describe('when getProposals is called with error', () => {
+      it('should throw error with correct message', async () => {
+        const error = {
+          message: 'Custom Error'
+        }
+        getProposalsSpy.mockRejectedValueOnce(error)
+
+        await expect(handleGetSolvableProposals(mockedTezosToolkit)).rejects.toThrow('Custom Error')
+      })
+    })
+  })
 })