(feat): add support for passing allowlist by uri, parsing and inserting

sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hypercerts-org/sdk",
-  "version": "2.0.0-alpha.28",
+  "version": "2.0.0-alpha.29",
   "description": "SDK for hypercerts protocol",
   "repository": "git@github.com:hypercerts-org/hypercerts.git",
   "author": "Hypercerts team",

sdk/src/client.ts

@@ -30,6 +30,7 @@ import { ParserReturnType } from "./utils/txParser";
 import { isClaimOnChain } from "./utils/chains";
 import { StoreAllowList201AnyOfTwoData, StoreMetadata201AnyOf } from "./__generated__/api";
 import { HypercertStorage } from "./types/storage";
+import { fetchFromHttpsOrIpfs } from "./utils/fetchers";
 
 /**
  * The `HypercertClient` is a core class in the hypercerts SDK, providing a high-level interface to interact with the hypercerts system.
@@ -128,7 +129,38 @@ export class HypercertClient implements HypercertClientInterface {
     let root;
 
     if (allowList) {
-      const tree = parseAllowListEntriesToMerkleTree(allowList);
+      let allowListEntries: AllowlistEntry[] = [];
+      if (typeof allowList === "string") {
+        // fetch the csv contents
+        const csvContents = await fetchFromHttpsOrIpfs(allowList);
+
+        if (!csvContents) {
+          throw new ClientError("No contents found in the csv", { allowList });
+        }
+
+        if (typeof csvContents !== "string") {
+          throw new ClientError("Invalid contents found in the csv", { allowList });
+        }
+        // parse the csv contents into an array of AllowlistEntry
+        // get first row as headers
+        const headers = (csvContents as string).split("\n")[0].split(",");
+        // map headers onto other rows
+        const rows = (csvContents as string)
+          .split("\n")
+          .slice(1)
+          .map((row) => {
+            const values = row.split(",");
+            return Object.fromEntries(headers.map((header, i) => [header, values[i]]));
+          });
+        allowListEntries = rows.map((entry) => {
+          const { address, units } = entry;
+          return { address, units: BigInt(units) };
+        });
+      } else {
+        allowListEntries = allowList;
+      }
+
+      const tree = parseAllowListEntriesToMerkleTree(allowListEntries);
 
       // store allowlist on IPFS
       const allowlistStoreRes = await this.storage.storeAllowlist(

sdk/src/types/client.ts

@@ -100,7 +100,7 @@ export interface MintParams extends TransactionParams {
   metaData: HypercertMetadata;
   totalUnits: bigint;
   transferRestriction: TransferRestrictions;
-  allowList?: AllowlistEntry[];
+  allowList?: AllowlistEntry[] | string;
 }
 
 export interface TransferParams extends TransactionParams {

sdk/src/utils/fetchers.ts

@@ -55,3 +55,46 @@ const getWeb3UpGatewayUri = (cidOrIpfsUri: string) => {
 };
 
 export { getFromIPFS };
+
+export const fetchFromHTTPS = async ({ uri }: { uri: string }) => {
+  // URL validation
+  const url = new URL(uri);
+  try {
+    const res = await axios.get(url.toString());
+
+    if (!res || !res.data) {
+      return;
+    }
+
+    return res.data;
+  } catch (error) {
+    console.error(`Failed to get metadata from URI ${uri} `, error);
+    return;
+  }
+};
+
+export const fetchFromHttpsOrIpfs = async (uri?: string): Promise<unknown> => {
+  if (!uri || uri === "ipfs://null" || uri === "ipfs://") {
+    console.error("[fetchFromHttpsOrIpfs] URI is missing");
+    return;
+  }
+
+  let fetchResult;
+
+  // Try from IPFS
+  if (uri.startsWith("ipfs://")) {
+    fetchResult = await getFromIPFS(uri);
+  }
+
+  // Try from HTTPS
+  if (uri.startsWith("https://")) {
+    fetchResult = await fetchFromHTTPS({ uri });
+  }
+
+  // If nothing found yet, try from IPFS as CID
+  if (!fetchResult) {
+    fetchResult = await getFromIPFS(uri);
+  }
+
+  return fetchResult;
+};