feat: add direct donation button (#3560)

* wip

* feat: add directAllocation to allo-v2

* fix: build issue

* feat: update allo sdk version

* feat: fetch txData from sdk

* fix: build issues

* fix: other issues

* feat: update ui

* feat: add useDirectAllocation hook

* feat: add progress modal cmponent in explorer

* feat: add getDirectAllocationPoolId

* feat: add handleDonate to project

* update UI

* fix: zeroAddress bug

* feat: minor ui updates

* test: update tests

* update poolId (new contract deployed

* swap out fo sdk

* chore: code cleanup

* feat: handle case when wallet is not connected

* feat: update max height

* feat: handle error states

* feat: show donate button only on chains that support direct donation

* feat: add error modal

* tests: fix failing tests

* fix: erc20 donation issue

* fix: decimal issue on donation modal

* chore: refactor code

* chore: update lock file

* feat: refactor getbalance in project page

---------

Co-authored-by: Aditya Anand M C <aditya.anandmc@gmail.com>

Author: bhargavaparoksham

packages/common/package.json

@@ -16,7 +16,7 @@
     "test:watch": "vitest watch"
   },
   "dependencies": {
-    "@allo-team/allo-v2-sdk": "^1.0.76",
+    "@allo-team/allo-v2-sdk": "^1.0.77",
     "@ethersproject/abstract-signer": "^5.7.0",
     "@ethersproject/providers": "^5.7.2",
     "@gitcoin/gitcoin-chain-data": "^1.0.17",

packages/common/src/allo/allo.ts

@@ -244,6 +244,23 @@ export interface Allo {
       indexingStatus: Result<null>;
     }
   >;
+
+  directAllocation: (args: {
+    tokenAddress: Address;
+    poolId: string;
+    amount: bigint;
+    recipient: Address;
+    nonce: bigint;
+    requireTokenApproval?: boolean;
+  }) => AlloOperation<
+    Result<null>,
+    {
+      tokenApprovalStatus: Result<TransactionReceipt | null>;
+      transaction: Result<Hex>;
+      transactionStatus: Result<TransactionReceipt>;
+      indexingStatus: Result<null>;
+    }
+  >;
 }
 
 export { AlloOperation };

packages/common/src/allo/backends/allo-v1.ts

@@ -1310,6 +1310,28 @@ export class AlloV1 implements Allo {
       return error(result);
     });
   }
+
+  directAllocation(args: {
+    tokenAddress: Address;
+    poolId: string;
+    amount: bigint;
+    recipient: Address;
+    nonce: bigint;
+    requireTokenApproval?: boolean;
+  }): AlloOperation<
+    Result<null>,
+    {
+      tokenApprovalStatus: Result<TransactionReceipt | null>;
+      transaction: Result<Hex>;
+      transactionStatus: Result<TransactionReceipt>;
+      indexingStatus: Result<null>;
+    }
+  > {
+    return new AlloOperation(async () => {
+      const result = new AlloError(`Unsupported on v1 ${args}`);
+      return error(result);
+    });
+  }
 }
 // todo: move this out?
 export type CreateRoundArgs = {

packages/common/src/allo/backends/allo-v2.ts

@@ -2,6 +2,7 @@ import {
   AlloAbi,
   Allo as AlloV2Contract,
   CreateProfileArgs,
+  DirectAllocationStrategy,
   DirectGrantsLiteStrategy,
   DirectGrantsLiteStrategyTypes,
   DonationVotingMerkleDistributionDirectTransferStrategyAbi,
@@ -82,6 +83,24 @@ export function getAlloAddress(chainId: number) {
   return allo.address();
 }
 
+export function getDirectAllocationPoolId(chainId: number) {
+  switch (chainId) {
+    case 11155111:
+      return 386;
+    default:
+      return undefined;
+  }
+}
+
+export function getDirectAllocationStrategyAddress(chainId: number) {
+  switch (chainId) {
+    case 11155111:
+      return "0xd60BCfa8714949c478d88da51A7450703A32Cf35";
+    default:
+      return undefined;
+  }
+}
+
 export class AlloV2 implements Allo {
   private transactionSender: TransactionSender;
   private ipfsUploader: IpfsUploader;
@@ -1435,6 +1454,114 @@ export class AlloV2 implements Allo {
       return success(null);
     });
   }
+
+  directAllocation(args: {
+    tokenAddress: Address;
+    poolId: string;
+    amount: bigint;
+    recipient: Address;
+    nonce: bigint;
+    requireTokenApproval?: boolean;
+  }): AlloOperation<
+    Result<null>,
+    {
+      tokenApprovalStatus: Result<TransactionReceipt | null>;
+      transaction: Result<Hex>;
+      transactionStatus: Result<TransactionReceipt>;
+      indexingStatus: Result<null>;
+    }
+  > {
+    return new AlloOperation(async ({ emit }) => {
+      if (isNaN(Number(args.poolId))) {
+        return error(new AlloError("Pool ID is not a valid Allo V2 pool ID"));
+      }
+
+      const poolId = BigInt(args.poolId);
+
+      const strategy = new DirectAllocationStrategy({
+        chain: this.chainId,
+        poolId: poolId,
+      });
+
+      const strategyAddress = getDirectAllocationStrategyAddress(this.chainId);
+
+      if (strategyAddress === undefined) {
+        return error(new AlloError("Direct allocation strategy not found"));
+      }
+
+      if (args.tokenAddress === zeroAddress || !args.requireTokenApproval) {
+        emit("tokenApprovalStatus", success(null));
+      } else {
+        const approvalTx = await sendTransaction(this.transactionSender, {
+          address: args.tokenAddress,
+          abi: Erc20ABI,
+          functionName: "approve",
+          args: [strategyAddress, args.amount],
+        });
+
+        if (approvalTx.type === "error") {
+          const result = new AlloError(
+            "Failed to approve token transfer",
+            approvalTx.error
+          );
+          emit("tokenApprovalStatus", error(result));
+          return error(result);
+        }
+        try {
+          const receipt = await this.transactionSender.wait(approvalTx.value);
+          emit("tokenApprovalStatus", success(receipt));
+        } catch (err) {
+          const result = new AlloError("Failed to approve token transfer", err);
+          emit("tokenApprovalStatus", error(result));
+          return error(result);
+        }
+      }
+
+      let _token = args.tokenAddress;
+      if (_token === zeroAddress) {
+        _token = getAddress(NATIVE);
+      }
+
+      const txData = strategy.getAllocateData({
+        profileOwner: args.recipient,
+        amount: BigInt(args.amount.toString()),
+        token: _token,
+        nonce: args.nonce,
+      });
+
+      const tx = await sendRawTransaction(this.transactionSender, {
+        to: txData.to,
+        data: txData.data,
+        value: BigInt(txData.value),
+      });
+
+      emit("transaction", tx);
+
+      if (tx.type === "error") {
+        return tx;
+      }
+
+      let receipt: TransactionReceipt;
+
+      try {
+        receipt = await this.transactionSender.wait(tx.value);
+        emit("transactionStatus", success(receipt));
+      } catch (err) {
+        const result = new AlloError("Failed to fund round", err);
+        emit("transactionStatus", error(result));
+        return error(result);
+      }
+
+      await this.waitUntilIndexerSynced({
+        chainId: this.chainId,
+        blockNumber: receipt.blockNumber,
+      });
+
+      emit("indexingStatus", success(null));
+
+      return success(null);
+    });
+  }
 }
 
 export function serializeProject(project: ProjectWithMerkleProof) {

packages/common/src/types.ts

@@ -94,3 +94,10 @@ export type InputType =
 export type DeepRequired<T> = {
   [K in keyof T]: Required<DeepRequired<T[K]>>;
 };
+
+export type Allocation = {
+  profileOwner: `0x${string}`;
+  amount: bigint;
+  token: `0x${string}`;
+  nonce: bigint;
+};

packages/grant-explorer/src/features/common/GenericModal.tsx

@@ -11,7 +11,7 @@ interface InfoModalProps {
 }
 
 export default function InfoModal({
-  title = "Information Title",
+  title = "",
   titleSize = "sm",
   isOpen = false,
   setIsOpen = () => {