allo-monad-ray/dist/esm/strategies/DirectAllocationStrategy/DirectAllocationStrategy.js

Monad version of Allo v2 SDK

import { extractChain, getContract, encodeAbiParameters, encodeFunctionData, parseAbiParameters } from "viem";
import { Allo } from "../../Allo/Allo";
import { supportedChains } from "../../chains.config";
import { create } from "../../Client/Client";
import { NATIVE } from "../../types";
import { abi as alloAbi } from "../../Allo/allo.config";
import { abi as directAllocationAbi, bytecode as directAllocationBytecode, } from "./directAllocation.config";
export class DirectAllocationStrategy {
    constructor({ chain, rpc, address, poolId }) {
        const usedChain = extractChain({
            chains: supportedChains,
            id: chain,
        });
        this.client = create(usedChain, rpc);
        this.allo = new Allo({ chain, rpc });
        if (address) {
            this.contract = getContract({
                address: address,
                abi: directAllocationAbi,
                client: {
                    public: this.client,
                }
            });
            this.strategy = address;
        }
        this.poolId = poolId || BigInt(-1);
    }
    getDeployParams() {
        const constructorArgs = encodeAbiParameters(parseAbiParameters("address,string"), [this.allo.address(), "DirectAllocationStrategyv1.0"]);
        const constructorArgsNo0x = constructorArgs.slice(2);
        return {
            abi: directAllocationAbi,
            bytecode: (directAllocationBytecode +
                constructorArgsNo0x),
        };
    }
    async setPoolId(poolId) {
        this.poolId = poolId;
        const strategyAddress = await this.allo.getStrategy(poolId);
        this.setContract(strategyAddress);
    }
    setContract(address) {
        this.contract = getContract({
            address: address,
            abi: directAllocationAbi,
            client: {
                public: this.client,
            }
        });
        this.strategy = address;
    }
    checkPoolId() {
        if (this.poolId === BigInt(-1))
            throw new Error("DirectAllocationStrategy: No poolId provided. Please call `setPoolId` first.");
    }
    checkStrategy() {
        if (!this.strategy)
            throw new Error("DirectAllocationStrategy: No strategy address provided. Please call `setContract` first.");
    }
    async getNative() {
        this.checkStrategy();
        const native = await this.contract.read.NATIVE();
        return native;
    }
    async getAllo() {
        return this.contract.read.getAllo();
    }
    async getPoolId() {
        this.checkStrategy();
        const poolId = await this.contract.read.getPoolId();
        return poolId;
    }
    async getStrategyId() {
        this.checkStrategy();
        const id = await this.contract.read.getStrategyId();
        return id;
    }
    // Write methods
    getAllocateData(allocation) {
        this.checkPoolId();
        const encoded = encodeAbiParameters(parseAbiParameters("address,uint256,address,uint256"), [allocation.profileOwner, allocation.amount, allocation.token, allocation.nonce]);
        const encodedData = encodeFunctionData({
            abi: alloAbi,
            functionName: "allocate",
            args: [this.poolId, encoded],
        });
        return {
            to: this.allo.address(),
            data: encodedData,
            value: allocation.token.toLowerCase() === NATIVE ? allocation.amount.toString() : "0",
        };
    }
    // Note: batchAllocate will not be supported for NATIVE tokens until Allo v2.1
    getBatchAllocateData(allocations) {
        this.checkPoolId();
        const encodedParams = [];
        allocations.forEach((allocation) => {
            const encoded = encodeAbiParameters(parseAbiParameters("address,uint256,address,uint256"), [allocation.profileOwner, allocation.amount, allocation.token, allocation.nonce]);
            encodedParams.push(encoded);
        });
        const poolIds = Array(encodedParams.length).fill(this.poolId);
        const encodedData = encodeFunctionData({
            abi: alloAbi,
            functionName: "batchAllocate",
            args: [poolIds, encodedParams],
        });
        return {
            to: this.allo.address(),
            data: encodedData,
            value: "0",
        };
    }
}