Merge pull request #27 from syscoin/sponsor-wallet-implementation

feat(sponsor-wallet): add implementation

Author: osiastedian

.github/workflows/aws.yml

@@ -6,7 +6,7 @@ on:
   push:
     branches:
       - main
-      - mongodb-migrate
+      - sponsor-wallet-implementation
 
 env:
   AWS_REGION: us-east-1                   # set this to your preferred AWS region, e.g. us-west-1

api/services/__tests__/sponsor-wallet.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, it, jest } from "@jest/globals";
+const SponsorWalletMock = jest.mock("models/sponsor-wallet");
+// Mock util/get-web3
+
+const web3Mock = {
+  eth: {
+    accounts: {
+      privateKeyToAccount: jest.fn(),
+    },
+    getBalance: jest.fn(),
+    sendSignedTransaction: jest.fn(),
+  },
+  utils: {
+    fromWei: jest.fn(),
+  },
+};
+jest.mock("utils/get-web3", () => {
+  return jest.fn(() => web3Mock);
+});
+import SponsorWalletService from "../sponsor-wallet";
+
+describe("SponsorWalletService", () => {
+  describe("createSponsorWallet", () => {
+    it("should throw an error if privateKey provided is invalid", async () => {
+      const service = new SponsorWalletService();
+
+      await expect(
+        service.createSponsorWallet("invalidPrivateKey")
+      ).rejects.toThrow("Private key must be 32 bytes long");
+    });
+
+    /**
+     * To Do Test:
+     * 1. It should throw error if address balance is less than 0.01
+     * 2. It should create a new wallet if address balance is greater than 0.01
+     */
+  });
+
+  describe("sponsorTransaction", () => {
+    /**
+     * To Do Test:
+     * 1. It should throw error if no wallet available
+     * 2. When there is a wallet available
+     * 2.1 It should throw error if transaction config is invalid
+     * 2.2 It should throw return tx hash from the receipt if transaction config is valid
+     */
+    // Jest Mock Mongoose Model SponsorWallet
+  });
+});

api/services/sponsor-wallet.ts

@@ -0,0 +1,202 @@
+import SponsorWallet, { ISponsorWallet } from "models/sponsor-wallet";
+import SponsorWalletTransactions, {
+  ISponsorWalletTransaction,
+  SponsorWalletTransactionStatus,
+} from "models/sponsor-wallet-transactions";
+import web3 from "utils/get-web3";
+import { TransactionConfig } from "web3-core";
+
+export class SponsorWalletService {
+  public async createSponsorWallet(privateKey: string) {
+    const account = web3.eth.accounts.privateKeyToAccount(privateKey);
+
+    const balanceInWei = await web3.eth.getBalance(account.address);
+
+    const balanceEth = web3.utils.fromWei(balanceInWei, "ether");
+
+    if (Number(balanceEth) < 0.01) {
+      throw new Error(`${account.address} Balance is less than 0.01`);
+    }
+
+    const wallet = new SponsorWallet({
+      address: account.address,
+      privateKey,
+    });
+    await wallet.save();
+    return wallet.toObject();
+  }
+
+  public async sponsorTransaction(
+    transferId: string,
+    transactionConfig: Omit<TransactionConfig, "nonce">
+  ): Promise<ISponsorWalletTransaction> {
+    const wallet = await this.getAvailableWalletForSigning();
+
+    if (!wallet) {
+      throw new Error("No Sponsor Wallet available");
+    }
+
+    const existingTransaction = await SponsorWalletTransactions.findOne({
+      transferId: transferId,
+    });
+
+    if (existingTransaction) {
+      return existingTransaction;
+    }
+
+    const nonce = await this.getWalletNextNonce(wallet.id);
+
+    const sender = web3.eth.accounts.privateKeyToAccount(wallet.privateKey);
+
+    const signedTransaction = await sender.signTransaction({
+      ...transactionConfig,
+      nonce,
+    });
+
+    if (
+      signedTransaction.rawTransaction === undefined ||
+      signedTransaction.transactionHash === undefined
+    ) {
+      throw new Error("Raw transaction is undefined");
+    }
+
+    let walletTransaction = new SponsorWalletTransactions({
+      transferId: transferId,
+      walletId: wallet.id,
+      transactionHash: signedTransaction.transactionHash,
+      status: "pending",
+    });
+
+    walletTransaction = await walletTransaction.save();
+
+    let receipt = await web3.eth
+      .getTransactionReceipt(signedTransaction.transactionHash)
+      .catch(() => undefined);
+    let status: SponsorWalletTransactionStatus = "success";
+
+    if (!receipt) {
+      receipt = await web3.eth.sendSignedTransaction(
+        signedTransaction.rawTransaction
+      );
+      status = "pending";
+    }
+
+    walletTransaction.status = status;
+
+    return walletTransaction.save();
+  }
+
+  public async updateSponsorWalletTransactionStatus(transactionHash: string) {
+    const transaction = await SponsorWalletTransactions.findOne({
+      transactionHash,
+    });
+
+    if (!transaction || transaction.status !== "pending") {
+      return;
+    }
+
+    const receipt = await web3.eth.getTransactionReceipt(transactionHash);
+    if (!receipt?.blockNumber) {
+      return;
+    }
+
+    transaction.status = receipt.status ? "success" : "failed";
+    await transaction.save();
+  }
+
+  private async getWalletNextNonce(walletId: string): Promise<number> {
+    const wallet = await SponsorWallet.findOne({ id: walletId });
+    if (!wallet) {
+      throw new Error("Wallet not found");
+    }
+    const lastTransaction = await SponsorWalletTransactions.findOne({
+      walletId: wallet?.id,
+    }).sort({ createdAt: -1 });
+
+    if (!lastTransaction) {
+      const nonce = await web3.eth.getTransactionCount(
+        wallet.address,
+        "pending"
+      );
+      return nonce;
+    }
+
+    const transaction = await web3.eth.getTransaction(
+      lastTransaction.transactionHash
+    );
+
+    return transaction.nonce + 1;
+  }
+
+  private async getAvailableWalletForSigning(): Promise<ISponsorWallet> {
+    const walletWithNoPendingTransactions =
+      await this.getWalletWithNoPendingTransactions();
+
+    if (walletWithNoPendingTransactions.length > 0) {
+      return walletWithNoPendingTransactions[0];
+    }
+
+    const walletWithLeastPendingTransactions =
+      await this.getWalletWithLeastPendingTransactions();
+
+    return walletWithLeastPendingTransactions;
+  }
+
+  private getWalletWithNoPendingTransactions(): Promise<ISponsorWallet[]> {
+    return SponsorWallet.aggregate([
+      {
+        $lookup: {
+          from: "sponsorwallettransactions",
+          localField: "_id",
+          foreignField: "walletId",
+          as: "transactions",
+        },
+      },
+      {
+        $match: {
+          "transactions.status": {
+            $ne: "pending",
+          },
+        },
+      },
+    ]);
+  }
+
+  private getWalletWithLeastPendingTransactions(): Promise<ISponsorWallet> {
+    return SponsorWallet.aggregate([
+      {
+        $lookup: {
+          from: "sponsorwallettransactions",
+          localField: "_id",
+          foreignField: "walletId",
+          as: "transactions",
+        },
+      },
+      {
+        $match: {
+          "transactions.status": "pending",
+        },
+      },
+      {
+        $project: {
+          id: "$_id",
+          address: 1,
+          privateKey: 1,
+          pendingTransactionCount: {
+            $size: "$transactions",
+          },
+        },
+      },
+      {
+        $sort: {
+          pendingTransactionCount: 1,
+        },
+      },
+      {
+        $limit: 1,
+      },
+    ]).then((wallets) => wallets[0]);
+  }
+}
+
+export default SponsorWalletService;

api/services/transfer.ts

@@ -2,11 +2,12 @@ import { ITransfer } from "@contexts/Transfer/types";
 import { UserCredential, signInWithEmailAndPassword } from "firebase/auth";
 import firebase from "firebase-setup";
 import { doc, getDoc } from "firebase/firestore";
-import dbConnect from "lib/mongodb";
 import TransferModel from "models/transfer";
+import { SponsorWalletService } from "./sponsor-wallet";
 
 export class TransferService {
   private isAuthenticated = false;
+  private sponsorWalletService = new SponsorWalletService();
   constructor() {
     this.authenticate();
   }
@@ -68,6 +69,17 @@ export class TransferService {
   }
 
   async upsertTransfer(transfer: ITransfer): Promise<ITransfer> {
+    const submitProofsTxLog = transfer.logs.find(
+      (log) => log.status === "submit-proofs"
+    );
+    if (submitProofsTxLog) {
+      const { hash } = submitProofsTxLog.payload.data;
+      if (hash) {
+        await this.sponsorWalletService.updateSponsorWalletTransactionStatus(
+          hash
+        );
+      }
+    }
     const results = await TransferModel.updateOne(
       { id: transfer.id },
       { ...transfer, updatedAt: Date.now() },

components/Bridge/v3/Steps/SubmitProofs.tsx

@@ -45,12 +45,14 @@ const SubmitProofs: React.FC<Props> = ({ successStatus }) => {
   const foundation = useSyscoinSubmitProofs(transfer, onSuccess);
   const self = useSubmitProof(transfer, spvProof);
 
+  const foundationFundingAvailable = isEnabled("foundationFundingAvailable");
+
   const {
     mutate: submitProofs,
     isLoading: isSigning,
     isError: isSignError,
     error: signError,
-  } = isEnabled("foundationFundingAvailable") ? foundation : self;
+  } = foundationFundingAvailable ? foundation : self;
 
   const sign = () => {
     submitProofs(undefined, { onSuccess });
@@ -65,7 +67,13 @@ const SubmitProofs: React.FC<Props> = ({ successStatus }) => {
   }
 
   if (isSigning) {
-    return <Alert severity="info">Check NEVM Wallet for signing</Alert>;
+    return (
+      <Alert severity="info">
+        {foundationFundingAvailable
+          ? "Submitting proofs..."
+          : "Check NEVM Wallet for signing"}
+      </Alert>
+    );
   }
 
   if (isSignError) {

components/Bridge/v3/hooks/useFeatureFlags.ts

@@ -2,6 +2,7 @@ import { useQuery } from "react-query";
 
 type FeatureFlags = {
   foundationFundingAvailable: boolean;
+  adminEnabled: boolean;
 };
 
 export const useFeatureFlags = () => {

components/Bridge/v3/hooks/useSyscoinSubmitProofs.tsx

@@ -1,6 +1,7 @@
 import { ITransfer } from "@contexts/Transfer/types";
 import { useMutation } from "react-query";
 import { useWeb3 } from "../context/Web";
+import { ISponsorWalletTransaction } from "models/sponsor-wallet-transactions";
 
 const useSyscoinSubmitProofs = (
   transfer: ITransfer,
@@ -10,7 +11,7 @@ const useSyscoinSubmitProofs = (
   return useMutation(
     ["syscoin-submit-proofs", transfer.id],
     async () => {
-      const submitProofsResponse: { signedTx: string } = await fetch(
+      const submitProofsResponse: ISponsorWalletTransaction = await fetch(
         `/api/transfer/${transfer.id}/signed-submit-proofs-tx`
       ).then((res) => {
         if (res.ok) {
@@ -19,32 +20,11 @@ const useSyscoinSubmitProofs = (
         return res.json().then(({ message }) => Promise.reject(message));
       });
 
-      const { signedTx } = submitProofsResponse;
-
-      return new Promise((resolve, reject) => {
-        web3.eth
-          .sendSignedTransaction(signedTx)
-          .once("transactionHash", (hash: string | { success: false }) => {
-            if (typeof hash !== "string" && !hash.success) {
-              reject("Failed to submit proofs. Check browser logs");
-              console.error("Submission failed", hash);
-            } else {
-              resolve(hash);
-            }
-          })
-          .on("error", (error: { message: string }) => {
-            if (/might still be mined/.test(error.message)) {
-              resolve("");
-            } else {
-              console.error(error);
-              reject(error.message);
-            }
-          });
-      });
+      return submitProofsResponse.transactionHash;
     },
     {
       onSuccess: (data) => {
-        onSuccess(data as string);
+        onSuccess(data);
       },
     }
   );

jest.config.js

@@ -0,0 +1,13 @@
+const { pathsToModuleNameMapper } = require('ts-jest')
+// In the following statement, replace `./tsconfig` with the path to your `tsconfig` file
+// which contains the path mapping (ie the `compilerOptions.paths` option):
+const { compilerOptions } = require('./tsconfig.json')
+
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+module.exports = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  roots: ['<rootDir>'],
+  modulePaths: [compilerOptions.baseUrl], // <-- This will be set to 'baseUrl' value
+  moduleNameMapper: pathsToModuleNameMapper(compilerOptions.paths /*, { prefix: '<rootDir>/' } */),
+}