@show-karma/karma-gap-sdk 0.4.16 → 0.4.18

package/core/class/GAP.js

@@ -0,0 +1,289 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GAP = void 0;
+const CommunityResolverABI_json_1 = __importDefault(require("../abi/CommunityResolverABI.json"));
+const MultiAttester_json_1 = __importDefault(require("../abi/MultiAttester.json"));
+const ProjectResolver_json_1 = __importDefault(require("../abi/ProjectResolver.json"));
+const eas_sdk_1 = require("@ethereum-attestation-service/eas-sdk");
+const ethers_1 = require("ethers");
+const package_json_1 = require("../../package.json");
+const consts_1 = require("../consts");
+const types_1 = require("../types");
+const get_web3_provider_1 = require("../utils/get-web3-provider");
+const GapSchema_1 = require("./GapSchema");
+const GraphQL_1 = require("./GraphQL");
+const Schema_1 = require("./Schema");
+/**
+ * GAP SDK Facade.
+ *
+ * This is the main class that is used to interact with the GAP SDK.
+ *
+ * This class implements the singleton pattern to ensure only one instance exists
+ * throughout the application lifecycle.
+ *
+ * Using this class, the user will be able to:
+ *
+ * - Create and manage attestations
+ * - Create and manage schemas
+ * - Fetch data from the EAS
+ *
+ * #### Features
+ *  - EAS Client: used to interact with EAS contracts
+ *  - EAS Fetcher: used to fetch data from the EAS GraphQL API, providing methods for:
+ *    - Get projects
+ *    - Get grants with its details
+ *    - Get grantees
+ *    - Get members
+ *    - Get tags
+ *    - Get external links
+ *    - Get schemas
+ *    - Get attestations by pair, attester, recipient, schema, or UID
+ *    - Get dependent attestations
+ * - Schema: used to create and manage schemas
+ * - Attestation: used to create and manage attestations
+ * - Replace schemas: used to replace the schema list with a new list
+ * - Replace single schema: used to replace a single schema from the schema list
+ *
+ * ---
+ * @example
+ * ```ts
+ * import { GAP } from "./core/class/GAP";
+ * import { GapSchema } from "./core/class/GapSchema";
+ * import { Schema } from "./core/class/Schema";
+ * import { MountEntities, Networks } from "./core/consts";
+ *
+ * const schemas = MountEntities(Networks.sepolia);
+ *
+ * // Initialize the singleton instance
+ * const gap = GAP.getInstance({
+ *   network: "sepolia",
+ *   owner: "0xd7d1DB401EA825b0325141Cd5e6cd7C2d01825f2",
+ *   schemas: Object.values(schemas),
+ * });
+ *
+ * // Later in the code, get the same instance
+ * const sameGap = GAP.getInstance();
+ *
+ * gap.fetcher
+ *   .fetchProjects()
+ *   .then((res) => {
+ *     console.log(JSON.stringify(res, null, 2));
+ *   })
+ *
+ * ```
+ */
+class GAP extends types_1.Facade {
+    /**
+     * Get the singleton instance of GAP for a specific network.
+     * If no instance exists for the network, creates one with the provided args.
+     * @param args Optional initialization arguments
+     * @returns The singleton instance of GAP for the specified network
+     */
+    static getInstance(args) {
+        if (!args) {
+            throw new Error("Network must be specified when getting GAP instance");
+        }
+        const existingInstance = GAP.instances.get(args.network);
+        if (existingInstance) {
+            return existingInstance;
+        }
+        if (!args) {
+            throw new Error("Initialization arguments required for first instance");
+        }
+        const newInstance = new GAP(args);
+        GAP.instances.set(args.network, newInstance);
+        return newInstance;
+    }
+    /**
+     * Creates a new instance of GAP.
+     * You can either use this constructor directly or use the singleton pattern via getInstance().
+     * @param args Initialization arguments
+     */
+    constructor(args) {
+        super();
+        /**
+         * Generates a slug from a text.
+         * @param text
+         * @returns
+         */
+        this.generateSlug = async (text) => {
+            let slug = text
+                .toLowerCase()
+                // Remove emojis
+                .replace(/([\uE000-\uF8FF]|\uD83C[\uDF00-\uDFFF]|\uD83D[\uDC00-\uDDFF])/g, "")
+                // Remove basic text emoticons
+                .replace(/[:;=][()DP]/g, "")
+                .replace(/ /g, "-")
+                .replace(/[^\w-]+/g, "")
+                .trim()
+                .replace(/^-+|-+$/g, ""); // Remove leading and trailing hyphens
+            const checkSlug = async (currentSlug, counter = 0) => {
+                const slugToCheck = counter === 0 ? currentSlug : `${currentSlug}-${counter}`;
+                const slugExists = await this.fetch.slugExists(slugToCheck);
+                if (slugExists) {
+                    return checkSlug(currentSlug, counter + 1);
+                }
+                return slugToCheck.toLowerCase();
+            };
+            return checkSlug(slug);
+        };
+        const schemas = args.schemas || Object.values((0, consts_1.MountEntities)(consts_1.Networks[args.network]));
+        this.network = args.network;
+        this._eas = new eas_sdk_1.EAS(consts_1.Networks[args.network].contracts.eas);
+        this.fetch =
+            args.apiClient ||
+                new GraphQL_1.GapEasClient({
+                    network: args.network,
+                });
+        this.fetch.gapInstance = this;
+        this.assertGelatoOpts(args);
+        GAP._gelatoOpts = args.gelatoOpts;
+        GAP.remoteStorage = args.remoteStorage;
+        this._schemas = schemas.map((schema) => new GapSchema_1.GapSchema(schema, this, false, args.globalSchemas ? !args.globalSchemas : false));
+        Schema_1.Schema.validate(this.network);
+        console.info(`Loaded GAP SDK v${package_json_1.version} for network ${this.network}`);
+        GAP.instances.set(this.network, this);
+    }
+    assertGelatoOpts(args) {
+        if (args.gelatoOpts &&
+            !(args.gelatoOpts.sponsorUrl || args.gelatoOpts.apiKey)) {
+            throw new Error("You must provide a `sponsorUrl` or an `apiKey`.");
+        }
+        if (args.gelatoOpts?.sponsorUrl &&
+            args.gelatoOpts?.contained &&
+            !args.gelatoOpts.env_gelatoApiKey) {
+            throw new Error("You must provide `env_gelatoApiKey` to be able to use it in a backend handler.");
+        }
+        if ((args.gelatoOpts?.env_gelatoApiKey ||
+            args.gelatoOpts?.apiKey ||
+            args.gelatoOpts?.sponsorUrl) &&
+            !args.gelatoOpts?.useGasless) {
+            console.warn("GAP::You are using gelatoOpts but not setting useGasless to true. This will send transactions through the normal provider.");
+        }
+    }
+    /**
+     * Creates the attestation payload using a specific schema.
+     * @param from
+     * @param to
+     * @param data
+     * @param schema
+     */
+    async attest(attestation) {
+        const schema = GapSchema_1.GapSchema.find(attestation.schemaName, this.network);
+        return schema.attest(attestation);
+    }
+    /**
+     * Replaces the schema list with a new list.
+     * @param schemas
+     */
+    replaceSchemas(schemas) {
+        Schema_1.Schema.replaceAll(schemas, this.network);
+    }
+    /**
+     *  Replaces a schema from the schema list.
+     * @throws {SchemaError} if desired schema name does not exist.
+     */
+    replaceSingleSchema(schema) {
+        Schema_1.Schema.replaceOne(schema, this.network);
+    }
+    /**
+     * Returns a copy of the original schema with no pointers.
+     * @param name
+     * @returns
+     */
+    findSchema(name) {
+        const found = Schema_1.Schema.get(name, this.network);
+        return GapSchema_1.GapSchema.clone(found);
+    }
+    /**
+     * Find many schemas by name and return their copies as an array in the same order.
+     * @param names
+     * @returns
+     */
+    findManySchemas(names) {
+        const schemas = Schema_1.Schema.getMany(names, this.network);
+        return schemas.map((s) => GapSchema_1.GapSchema.clone(s));
+    }
+    /**
+     * Get the multicall contract
+     * @param signer
+     */
+    static async getMulticall(signer) {
+        const chain = (await signer.provider.getNetwork()) || signer.provider.network;
+        const network = Object.values(consts_1.Networks).find((n) => +n.chainId === Number(chain.chainId));
+        if (!network)
+            throw new Error(`Network ${chain.name || chain.chainId} not supported.`);
+        const address = network.contracts.multicall;
+        return new ethers_1.ethers.Contract(address, MultiAttester_json_1.default, signer);
+    }
+    /**
+     * Get the multicall contract
+     * @param signer
+     */
+    static async getProjectResolver(signer, chainId) {
+        const currentChainId = chainId ||
+            Number((await signer.provider.getNetwork())?.chainId ||
+                (await signer.getChainId()));
+        const provider = chainId ? (0, get_web3_provider_1.getWeb3Provider)(chainId) : signer;
+        const network = Object.values(consts_1.Networks).find((n) => +n.chainId === Number(currentChainId));
+        const address = network.contracts.projectResolver;
+        return new ethers_1.ethers.Contract(address, ProjectResolver_json_1.default, provider);
+    }
+    /**
+     * Get the multicall contract
+     * @param signer
+     */
+    static async getCommunityResolver(signer, chainId) {
+        const currentChainId = chainId ||
+            Number((await signer.provider.getNetwork())?.chainId ||
+                (await signer.getChainId()));
+        const provider = chainId ? (0, get_web3_provider_1.getWeb3Provider)(chainId) : signer;
+        const network = Object.values(consts_1.Networks).find((n) => +n.chainId === Number(currentChainId));
+        const address = network.contracts.communityResolver;
+        return new ethers_1.ethers.Contract(address, CommunityResolverABI_json_1.default, provider);
+    }
+    get schemas() {
+        return this._schemas;
+    }
+    /**
+     * Defined if the transactions will be gasless or not.
+     *
+     * In case of true, the transactions will be sent through [Gelato](https://gelato.network)
+     * and an API key is needed.
+     */
+    static set gelatoOpts(gelatoOpts) {
+        if (typeof this._gelatoOpts === "undefined") {
+            this._gelatoOpts = gelatoOpts;
+        }
+        else {
+            throw new Error("Cannot change a readonly value gelatoOpts.");
+        }
+    }
+    /**
+     * Defined if the transactions will be gasless or not.
+     *
+     * In case of true, the transactions will be sent through [Gelato](https://gelato.network)
+     * and an API key is needed.
+     */
+    static get gelatoOpts() {
+        return this._gelatoOpts;
+    }
+    static set useGasLess(useGasLess) {
+        if (useGasLess &&
+            !this._gelatoOpts?.apiKey &&
+            !this._gelatoOpts?.sponsorUrl &&
+            !this._gelatoOpts?.env_gelatoApiKey) {
+            throw new Error("You must provide a `sponsorUrl` or an `apiKey` before using gasless transactions.");
+        }
+        this._gelatoOpts.useGasless = useGasLess;
+    }
+    static get remoteClient() {
+        return this.remoteStorage;
+    }
+}
+exports.GAP = GAP;
+GAP.instances = new Map();
+GAP._gelatoOpts = null;

package/core/class/GapSchema.d.ts

@@ -0,0 +1,34 @@
+import { IGapSchema, SchemaInterface, TNetwork, TSchemaName } from '../types';
+import { Schema } from './Schema';
+import { GAP } from './GAP';
+/**
+ * Represents the GapSchema
+ * @extends Schema
+ */
+export declare class GapSchema extends Schema implements IGapSchema {
+    readonly name: TSchemaName;
+    readonly references: TSchemaName;
+    constructor(args: SchemaInterface<TSchemaName>, gap: GAP, strict?: boolean, ignoreSchema?: boolean);
+    /**
+     * Clones a schema without references to the original.
+     * @param schema
+     * @returns
+     */
+    static clone(schema: GapSchema): GapSchema;
+    /**
+     * Returns a copy of the original schema with no pointers.
+     * @param name
+     * @returns
+     */
+    static find(name: TSchemaName, network: TNetwork): GapSchema;
+    /**
+     * Find many schemas by name and return their copies as an array in the same order.
+     * @param names
+     * @returns
+     */
+    static findMany(names: TSchemaName[], network: TNetwork): GapSchema[];
+    /**
+     * Get all schemas that references this schema.
+     */
+    get children(): GapSchema[];
+}

package/core/class/GapSchema.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GapSchema = void 0;
+const utils_1 = require("../utils");
+const Schema_1 = require("./Schema");
+/**
+ * Represents the GapSchema
+ * @extends Schema
+ */
+class GapSchema extends Schema_1.Schema {
+    constructor(args, gap, strict = false, ignoreSchema = false) {
+        super(args, gap, strict, ignoreSchema);
+        if (!ignoreSchema)
+            Schema_1.Schema.add(gap.network, new GapSchema({
+                name: args.name,
+                schema: args.schema.map((s) => ({ ...s })),
+                uid: args.uid,
+                references: args.references,
+                revocable: args.revocable,
+                oldSchemas: args.oldSchemas,
+            }, gap, strict, true));
+    }
+    /**
+     * Clones a schema without references to the original.
+     * @param schema
+     * @returns
+     */
+    static clone(schema) {
+        return new GapSchema({
+            name: schema.name,
+            schema: schema.schema.map((s) => ({ ...s })),
+            uid: schema.uid,
+            references: schema.references,
+            revocable: schema.revocable,
+        }, schema.gap, false, true);
+    }
+    /**
+     * Returns a copy of the original schema with no pointers.
+     * @param name
+     * @returns
+     */
+    static find(name, network) {
+        const found = Schema_1.Schema.get(name, network);
+        return this.clone(found);
+    }
+    /**
+     * Find many schemas by name and return their copies as an array in the same order.
+     * @param names
+     * @returns
+     */
+    static findMany(names, network) {
+        const schemas = Schema_1.Schema.getMany(names, network);
+        return schemas.map((s) => this.clone(s));
+    }
+    /**
+     * Get all schemas that references this schema.
+     */
+    get children() {
+        return (0, utils_1.mapFilter)(GapSchema.schemas[this.gap.network], (s) => s.references === this.name || s.references === this.uid, (s) => new GapSchema(s, s.gap, false, true));
+    }
+}
+exports.GapSchema = GapSchema;

package/core/class/Gelato/{Gelato.ts → Gelato.js}

@@ -5,13 +5,11 @@
 // /* eslint-disable class-methods-use-this */
 // /* eslint-disable no-useless-constructor */
 // /* eslint-disable import/no-extraneous-dependencies */
-
 // import { GelatoRelay } from "@gelatonetwork/relay-sdk";
 // import { ethers } from "ethers";
 // import axios from "axios";
 // import ABI from "./";
 // import { Hex } from "core/types";
-
 // enum TaskState {
 //   CheckPending = "CheckPending",
 //   ExecPending = "ExecPending",
@@ -22,15 +20,12 @@
 //   Cancelled = "Cancelled",
 //   NotFound = "NotFound",
 // }
-
 // export class DelegateRegistryContract extends GelatoRelay {
 //   contract: ethers.Contract;
-
 //   constructor(readonly contractAddress: Hex) {
 //     super();
 //     this.contract = new ethers.Contract(contractAddress, ABI);
 //   }
-
 //   /**
 //    * Returns the r, s, v values of a signature
 //    * @param signature
@@ -42,7 +37,6 @@
 //     const v = `0x${signature.slice(130, 132)}`;
 //     return { r, s, v };
 //   }
-
 //   /**
 //    * Returns the nonce of a delegate
 //    * @param address
@@ -56,13 +50,11 @@
 //       args: [address],
 //       chainId: 10,
 //     });
-
 //     return {
 //       nonce: Number(nonce),
 //       next: Number(nonce + 1n),
 //     };
 //   }
-
 //   /**
 //    * Waits for a transaction to be mined at Gelato Network
 //    * @param taskId
@@ -100,14 +92,12 @@
 //             );
 //             break;
 //           }
-
 //           await new Promise((r) => setTimeout(r, 500));
 //         }
 //       };
 //       loop();
 //     });
 //   }
-
 //   /**
 //    * Executes a transaction on the DelegateRegistry contract
 //    * @param fn the function to call
@@ -127,7 +117,6 @@
 //       wait: () => waitForTransaction({ hash }),
 //     };
 //   }
-
 //   public async registerDelegate(data: DelegateWithProfile) {
 //     return this.transaction("registerDelegate", [
 //       data.tokenAddress,
@@ -135,7 +124,6 @@
 //       JSON.stringify(data.profile),
 //     ]);
 //   }
-
 //   /**
 //    * Creates the payload for register delegate by signature
 //    * returning the payload
@@ -149,9 +137,7 @@
 //     const { nonce } = await this.getNonce(address);
 //     // 2 minutes expiry
 //     const expiry = ((Date.now() + 1000 * 120) / 1000).toFixed(0);
-
 //     const metadata = JSON.stringify(data.profile);
-
 //     const types = {
 //       RegisterDelegate: [
 //         { name: "tokenAddress", type: "address" },
@@ -178,9 +164,7 @@
 //       primaryType: "RegisterDelegate",
 //       types,
 //     });
-
 //     const { r, s, v } = this.getRSV(signature);
-
 //     const { data: payload } =
 //       await this.contract.populateTransaction.registerDelegateBySig(
 //         address,
@@ -193,7 +177,6 @@
 //         r,
 //         s
 //       );
-
 //     // eslint-disable-next-line no-console
 //     console.log({ payload, signature, r, s, v });
 //     if (!payload) throw new Error("Payload is undefined");
@@ -209,7 +192,6 @@
 //       },
 //     ];
 //   }
-
 //   /**
 //    * Sends a sponsored call to the DelegateRegistry contract using GelatoRelay
 //    * @param payload
@@ -218,13 +200,11 @@
 //   static async sendGelato(...params: Parameters<GelatoRelay["sponsoredCall"]>) {
 //     const client = new this(params[0].target as Hex);
 //     const relayResponse = await client.sponsoredCall(...params);
-
 //     return {
 //       taskId: relayResponse.taskId,
 //       wait: () => client.wait(relayResponse.taskId),
 //     };
 //   }
-
 //   /**
 //    * Deregisters a delegate on the DelegateRegistry contract
 //    * @param tokenAddress
@@ -234,7 +214,6 @@
 //   public deregisterDelegate(tokenAddress: string, tokenChainId: number) {
 //     return this.transaction("deregisterDelegate", [tokenAddress, tokenChainId]);
 //   }
-
 //   /**
 //    * Returns a delegate from the DelegateRegistry contract
 //    * @param delegateAddress
@@ -265,7 +244,6 @@
 //           interests
 //         }
 //       }`;
-
 //     const {
 //       data: {
 //         data: { delegates },
@@ -273,7 +251,6 @@
 //     } = await axios.post<{ data: DelegateStatementRes }>(this.subgraphUrl, {
 //       query,
 //     });
-
 //     return delegates.map((item) => {
 //       if (Array.isArray(item?.interests))
 //         return item as DelegateRegistryWithInterests;

package/core/class/GrantProgramRegistry/Allo.d.ts

@@ -0,0 +1,17 @@
+import { ethers } from "ethers";
+export declare class AlloBase {
+    private signer;
+    private contract;
+    private allo;
+    private pinataJWTToken;
+    constructor(signer: ethers.Signer, pinataJWTToken: string, chainId: number);
+    saveAndGetCID(data: any, pinataMetadata?: {
+        name: string;
+    }): Promise<any>;
+    encodeStrategyInitData(applicationStart: number, applicationEnd: number, roundStart: number, roundEnd: number, payoutToken: string): Promise<string>;
+    createGrant(args: any, callback?: Function): Promise<{
+        poolId: string;
+        txHash: string;
+    }>;
+    updatePoolMetadata(poolId: string, poolMetadata: any, callback?: Function): Promise<any>;
+}

package/core/class/GrantProgramRegistry/Allo.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AlloBase = void 0;
+const ethers_1 = require("ethers");
+const Allo_json_1 = __importDefault(require("../../abi/Allo.json"));
+const consts_1 = require("../../consts");
+const ethers_2 = require("ethers");
+const allo_v2_sdk_1 = require("@allo-team/allo-v2-sdk/");
+const axios_1 = __importDefault(require("axios"));
+// ABI fragment for the Initialized event
+const INITIALIZED_EVENT = ["event Initialized(uint256 poolId, bytes data)"];
+class AlloBase {
+    constructor(signer, pinataJWTToken, chainId) {
+        this.signer = signer;
+        this.contract = new ethers_1.ethers.Contract(consts_1.AlloContracts.alloProxy, Allo_json_1.default, signer);
+        this.allo = new allo_v2_sdk_1.Allo({ chain: chainId });
+        this.pinataJWTToken = pinataJWTToken;
+    }
+    async saveAndGetCID(data, pinataMetadata = { name: "via karma-gap-sdk" }) {
+        try {
+            const res = await axios_1.default.post("https://api.pinata.cloud/pinning/pinJSONToIPFS", {
+                pinataContent: data,
+                pinataMetadata: pinataMetadata,
+            }, {
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.pinataJWTToken}`,
+                },
+            });
+            return res.data.IpfsHash;
+        }
+        catch (error) {
+            console.log(error);
+        }
+    }
+    async encodeStrategyInitData(applicationStart, applicationEnd, roundStart, roundEnd, payoutToken) {
+        const encoder = new ethers_2.AbiCoder();
+        const initStrategyData = encoder.encode(["bool", "bool", "uint256", "uint256", "uint256", "uint256", "address[]"], [
+            false,
+            true,
+            applicationStart,
+            applicationEnd,
+            roundStart,
+            roundEnd,
+            [payoutToken],
+        ]);
+        return initStrategyData;
+    }
+    async createGrant(args, callback) {
+        console.log("Creating grant...");
+        const walletBalance = await this.signer.provider.getBalance(await this.signer.getAddress());
+        console.log("Wallet balance:", (0, ethers_1.formatEther)(walletBalance.toString()), " ETH");
+        try {
+            const metadata_cid = await this.saveAndGetCID({
+                round: args.roundMetadata,
+                application: args.applicationMetadata,
+            });
+            const metadata = {
+                protocol: BigInt(1),
+                pointer: metadata_cid,
+            };
+            const initStrategyData = (await this.encodeStrategyInitData(args.applicationStart, args.applicationEnd, args.roundStart, args.roundEnd, args.payoutToken));
+            const createPoolArgs = {
+                profileId: args.profileId,
+                strategy: args.strategy,
+                initStrategyData: initStrategyData,
+                token: args.payoutToken,
+                amount: BigInt(args.matchingFundAmt),
+                metadata: metadata,
+                managers: args.managers,
+            };
+            callback?.("preparing");
+            const txData = this.allo.createPool(createPoolArgs);
+            const tx = await this.signer.sendTransaction({
+                data: txData.data,
+                to: txData.to,
+                value: BigInt(txData.value),
+            });
+            callback?.("pending");
+            const receipt = await tx.wait();
+            callback?.("confirmed");
+            // Create interface to parse the logs
+            const iface = new ethers_1.ethers.Interface(INITIALIZED_EVENT);
+            let poolId;
+            // Find the Initialized event in the logs
+            const initializedLog = receipt.logs.find((log) => {
+                try {
+                    const parsed = iface.parseLog(log);
+                    return parsed.name === "Initialized";
+                }
+                catch {
+                    return false;
+                }
+            });
+            if (initializedLog) {
+                const parsedLog = iface.parseLog(initializedLog);
+                poolId = parsedLog.args.poolId.toString();
+                console.log(`Transaction ${tx.hash} - Found poolId: ${poolId}`);
+            }
+            else {
+                poolId = receipt.logs[receipt.logs.length - 1].topics[1]; // Fallback to Initialized order logic
+                console.log(`No Initialized event found in tx ${tx.hash}`);
+            }
+            return {
+                poolId: BigInt(poolId).toString(),
+                txHash: tx.hash,
+            };
+        }
+        catch (error) {
+            console.error(`Failed to create pool: ${error}`);
+            throw new Error(`Failed to create pool metadata: ${error}`);
+        }
+    }
+    async updatePoolMetadata(poolId, poolMetadata, callback) {
+        try {
+            callback?.("preparing");
+            const metadata_cid = await this.saveAndGetCID(poolMetadata);
+            const metadata = {
+                protocol: 1,
+                pointer: metadata_cid,
+            };
+            const tx = await this.contract.updatePoolMetadata(poolId, metadata);
+            callback?.("pending");
+            const receipt = await tx.wait();
+            callback?.("confirmed");
+            return receipt;
+        }
+        catch (error) {
+            console.error(`Failed to update pool metadata: ${error}`);
+            throw new Error(`Failed to update pool metadata: ${error}`);
+        }
+    }
+}
+exports.AlloBase = AlloBase;