Fixes tests

.gitignore

@@ -43,4 +43,7 @@ Thumbs.db
 !.env.example
 certs/*
 
-.nx/cache
+.nx/cache
+
+# Docker
+docker/data/**/*

apps/api/.env.example

@@ -9,7 +9,7 @@ DASHBOARD_URL="https://localhost:8082"
 WALLET_URL="https://localhost:8083"
 WIDGET_URL="https://localhost:8080"
 HARDHAT_RPC="https://localhost:8547"
-HARDHAT_RPC_TEST_OVERRIDE="http://localhost:8545"
+HARDHAT_RPC_TEST_OVERRIDE="http://127.0.0.1:8545"
 POLYGON_RPC=""
 ETHEREUM_RPC=""
 PRIVATE_KEY="0x873c254263b17925b686f971d7724267710895f1585bb0533db8e693a2af32ff"

apps/api/project.json

@@ -57,6 +57,22 @@
                 }
             }
         },
+        "hardhat": {
+            "dependsOn": ["^build"],
+            "executor": "nx:run-commands",
+            "options": {
+                "command": "npx hardhat node --hostname 0.0.0.0",
+                "cwd": "apps/api/src/app/hardhat"
+            }
+        },
+        "hardhat-deploy": {
+            "dependsOn": ["^build"],
+            "executor": "nx:run-commands",
+            "options": {
+                "command": "npx hardhat run scripts/deploy.ts --network localhost",
+                "cwd": "apps/api/src/app/hardhat"
+            }
+        },
         "lint": {
             "executor": "@nx/eslint:lint",
             "outputs": ["{options.outputFile}"],

apps/api/src/app/controllers/ve/ve.test.ts

@@ -275,6 +275,7 @@ describe('VESytem', () => {
                 .query({ walletId: String(safeWallet._id) })
                 .send({ isEarlyAttempt: false });
             expect(status).toBe(403);
+            console.log(body);
             expect(body.error.message).toBe('Funds are locked');
         });
 

apps/api/src/app/controllers/ve/withdraw/post.controller.ts

@@ -24,7 +24,11 @@ const controller = async ({ wallet, body }: Request, res: Response) => {
 
     // Check if client requests early exit and end date has not past
     const isEarlyWithdraw = Number(lock.end) > Number(now);
-    if (!body.isEarlyAttempt && isEarlyWithdraw) throw new ForbiddenError('Funds are locked');
+    console.log(typeof body.isEarlyAttempt, body.isEarlyAttempt, isEarlyWithdraw, Number(lock.end), Number(now));
+    if (!body.isEarlyAttempt && isEarlyWithdraw) {
+        console.log('Funds are locked');
+        throw new ForbiddenError('Funds are locked');
+    }
 
     // Propose the withdraw transaction
     const txs = await VoteEscrowService.withdraw(wallet, isEarlyWithdraw);

apps/api/src/app/middlewares/errorOutput.ts

@@ -15,7 +15,9 @@ interface ErrorResponse {
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 export const errorOutput = (error: any, req: Request, res: Response, next: NextFunction) => {
     let status = 500;
+    console.log(error);
     const response: ErrorResponse = { error: { message: 'Unable to fulfill request' } };
+    console.log(error instanceof THXHttpError);
     if (error instanceof THXHttpError || error.status) {
         status = error.status;
         response.error.message = error.message;
@@ -24,6 +26,6 @@ export const errorOutput = (error: any, req: Request, res: Response, next: NextF
         response.error.stack = error.stack;
     }
 
-    res.status(status);
-    res.json(response);
+    console.log(status, response);
+    res.status(status).json(response);
 };

apps/api/src/app/services/SafeService.ts

@@ -8,6 +8,7 @@ import Safe, { SafeAccountConfig, SafeFactory } from '@safe-global/protocol-kit'
 import SafeApiKit from '@safe-global/api-kit';
 import {
     SafeMultisigTransactionResponse,
+    SafeTransactionData,
     SafeTransactionDataPartial,
     SafeVersion,
 } from '@safe-global/safe-core-sdk-types';
@@ -17,7 +18,7 @@ import { Job } from '@hokify/agenda';
 import { convertObjectIdToNumber } from '../util';
 import TransactionService from './TransactionService';
 
-function getSafeSDK(chainId: ChainId) {
+function getSafeApiKit(chainId: ChainId) {
     const { txServiceUrl, ethAdapter } = getProvider(chainId);
     return new SafeApiKit({ txServiceUrl, ethAdapter });
 }
@@ -166,19 +167,18 @@ async function proposeTransaction(wallet: WalletDocument, safeTransactionData: S
 
     // Create hash for this transaction
     const safeTxHash = await safe.getTransactionHash(safeTransaction);
-    const signedTx = await safe.signTransaction(safeTransaction);
-
-    const safeAPIKit = getSafeSDK(wallet.chainId);
+    const signature = await safe.signTransactionHash(safeTxHash);
+    const apiKit = getSafeApiKit(wallet.chainId);
 
     logger.info({ safeTxHash, nonce });
 
     try {
-        await safeAPIKit.proposeTransaction({
+        await apiKit.proposeTransaction({
             safeAddress: wallet.address,
             safeTxHash,
-            safeTransactionData: signedTx.data as any,
+            safeTransactionData: safeTransaction.data as any,
             senderAddress: toChecksumAddress(await signer.getAddress()),
-            senderSignature: signedTx.signatures[0].data,
+            senderSignature: signature.data,
         });
 
         logger.info(`Safe TX Proposed: ${safeTxHash}`);
@@ -195,8 +195,8 @@ async function confirmTransaction(wallet: WalletDocument, safeTxHash: string) {
         safeAddress: wallet.address,
         contractNetworks,
     });
-    const signedTx = await safe.signTransactionHash(safeTxHash);
-    return await confirm(wallet, safeTxHash, signedTx.data);
+    const signature = await safe.signTransactionHash(safeTxHash);
+    return await confirm(wallet, safeTxHash, signature.data);
 }
 
 async function confirm(wallet: WalletDocument, safeTxHash: string, signatureData: string) {
@@ -207,13 +207,13 @@ async function confirm(wallet: WalletDocument, safeTxHash: string, signatureData
 
 async function executeTransaction(wallet: WalletDocument, safeTxHash: string) {
     const { ethAdapter } = getProvider(wallet.chainId);
-    const safeService = getSafeSDK(wallet.chainId);
+    const apiKit = getSafeApiKit(wallet.chainId);
     const safe = await Safe.create({
         ethAdapter,
         safeAddress: wallet.address,
         contractNetworks,
     });
-    const safeTransaction = await safeService.getTransaction(safeTxHash);
+    const safeTransaction = await apiKit.getTransaction(safeTxHash);
     const executeTxResponse = await safe.executeTransaction(safeTransaction as any);
     const receipt = await executeTxResponse.transactionResponse?.wait();
     const tx = await Transaction.findOne({ safeTxHash });
@@ -224,15 +224,15 @@ async function executeTransaction(wallet: WalletDocument, safeTxHash: string) {
 }
 
 async function getLastPendingTransactions(wallet: WalletDocument) {
-    const safeService = getSafeSDK(wallet.chainId);
-    const { results }: any = await safeService.getPendingTransactions(wallet.address);
+    const apiKit = getSafeApiKit(wallet.chainId);
+    const { results }: any = await apiKit.getPendingTransactions(wallet.address);
 
     return results as unknown as SafeMultisigTransactionResponse[];
 }
 
 async function getTransaction(wallet: WalletDocument, safeTxHash: string): Promise<SafeMultisigTransactionResponse> {
-    const safeSDK = getSafeSDK(wallet.chainId);
-    return (await safeSDK.getTransaction(safeTxHash)) as unknown as SafeMultisigTransactionResponse;
+    const apiKit = getSafeApiKit(wallet.chainId);
+    return (await apiKit.getTransaction(safeTxHash)) as unknown as SafeMultisigTransactionResponse;
 }
 
 export default {

apps/api/src/app/services/TransactionService.ts

@@ -178,6 +178,7 @@ async function proposeSafeAsync(
         data,
         value: '0',
     });
+    if (!safeTxHash) throw new Error("Couldn't propose transaction.");
 
     await SafeService.confirmTransaction(wallet, safeTxHash);
 

apps/api/src/app/services/VoteEscrowService.ts

@@ -171,8 +171,6 @@ async function claimExternalRewardsJob() {
             );
 
             // Execute directly using the relayer
-            await ve.methods.claimExternalRewards().send();
-
             const receipt = await TransactionService.send(
                 ve.options.address,
                 ve.methods.claimExternalRewards(),

apps/api/src/app/util/errors.ts

@@ -4,6 +4,7 @@ class THXError extends Error {
     constructor(message?: string) {
         super(message);
         this.name = this.constructor.name;
+        this.message = message || 'No error message';
         Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
     }
 }

apps/api/src/app/util/jest/config.ts

@@ -24,7 +24,7 @@ export async function beforeAllCallback(options = { skipWalletCreation: false })
 
     const { web3, defaultAccount, ethAdapter } = getProvider(ChainId.Hardhat);
     // Wait for this hardhat log:
-    const lastDeployedContractAddress = '0x726c9c8278ec209cfbe6bbb1d02e65df6fcb7cda';
+    const lastDeployedContractAddress = '0x58C0e64cBB7E5C7D0201A3a5c2D899cC70B0dc4c';
     const fn = () => web3.eth.getCode(lastDeployedContractAddress);
     const fnCondition = (result: string) => result === '0x';