allo-monad-ray
Version:
Monad version of Allo v2 SDK
404 lines (403 loc) • 12.7 kB
JavaScript
import { encodeAbiParameters, encodeFunctionData, extractChain, getContract, parseAbiParameters, } from "viem";
import { Allo } from "../../Allo/Allo";
import { abi as alloAbi } from "../../Allo/allo.config";
import { create } from "../../Client/Client";
import { ZERO_ADDRESS, } from "../../Common/types";
import { supportedChains } from "../../chains.config";
import { abi as easyAbi, bytecode as easyBytecode, } from "./easyRetroFunding.config";
export class EasyRetroFundingStrategy {
constructor({ chain, rpc, address, poolId }) {
const usedChain = extractChain({
chains: supportedChains,
id: chain,
});
this.client = create(usedChain, rpc);
this.allo = new Allo({ chain, rpc }); // to call allocate
if (address) {
this.contract = getContract({
address: address,
abi: easyAbi,
client: {
public: this.client,
}
});
this.strategy = address;
}
this.poolId = poolId || BigInt(-1);
}
async getAllo() {
return this.allo;
}
async setPoolId(poolId) {
this.poolId = poolId;
const strategyAddress = await this.allo.getStrategy(poolId);
this.setContract(strategyAddress);
}
setContract(address) {
this.contract = getContract({
address: address,
abi: easyAbi,
client: {
public: this.client,
}
});
this.strategy = address;
}
// Validation functions
checkPoolId() {
if (this.poolId === BigInt(-1))
throw new Error("EasyRetroFundingStrategy: No poolId provided. Please call `setPoolId` first.");
}
checkStrategy() {
if (!this.strategy)
throw new Error("EasyRetroFundingStrategy: No strategy address provided. Please call `setContract` first.");
}
/* Read Functions */
async getNative() {
this.checkStrategy();
const native = await this.contract.read.NATIVE();
return native;
}
/* Public Storage Variables */
async getDistributionMetadata() {
this.checkStrategy();
const metadata = await this.contract.read.distributionMetadata();
return metadata;
}
async useRegistryAnchor() {
this.checkStrategy();
const anchor = await this.contract.read.useRegistryAnchor();
return anchor;
}
async metadataRequired() {
this.checkStrategy();
const required = await this.contract.read.metadataRequired();
return required;
}
async distributionStarted() {
this.checkStrategy();
const started = await this.contract.read.distributionStarted();
return started;
}
async registrationStartTime() {
this.checkStrategy();
const startTime = await this.contract.read.registrationStartTime();
return startTime;
}
async registrationEndTime() {
this.checkStrategy();
const endTime = await this.contract.read.registrationEndTime();
return endTime;
}
async poolStartTime() {
this.checkStrategy();
const startTime = await this.contract.read.poolStartTime();
return startTime;
}
async poolEndTime() {
this.checkStrategy();
const endTime = await this.contract.read.poolEndTime();
return endTime;
}
async totalPayoutAmount() {
this.checkStrategy();
const amount = await this.contract.read.totalPayoutAmount();
return amount;
}
async recipientsCounter() {
this.checkStrategy();
const counter = await this.contract.read.recipientsCounter();
return counter;
}
async statusesBitMap(index) {
this.checkStrategy();
const bitMap = await this.contract.read.statusesBitMap([index]);
return bitMap;
}
async recipientToStatusIndexes(recipient) {
this.checkStrategy();
const indexes = await this.contract.read.recipientToStatusIndexes([
recipient,
]);
return indexes;
}
async isTokenAllowed(token) {
this.checkStrategy();
const allowed = await this.contract.read.allowedTokens(token);
return allowed;
}
async getClaims(recipient, token) {
const claims = await this.contract.read.claims([recipient, token]);
return claims;
}
async getTotalClaimableAmount(recipient) {
const claims = await this.contract.read.totalClaimableAmount([recipient]);
return claims;
}
/* Public Read Functions */
// TODO: FIX FROM HERE
async getPayouts(recipientIds, data) {
this.checkStrategy();
const payouts = await this.contract.read.getPayouts([recipientIds, data]);
const payoutSummary = payouts.map((payout) => {
return {
address: payout.recipientAddress,
amount: payout.amount,
};
});
return payoutSummary;
}
async getPoolAmount() {
this.checkStrategy();
const amount = await this.contract.read.getPoolAmount();
return amount;
}
async getPoolId() {
this.checkStrategy();
const id = await this.contract.read.getPoolId();
return id;
}
async getRecipient(recipientId) {
this.checkStrategy();
const recipient = await this.contract.read.getRecipient([recipientId]);
return recipient;
}
async getRecipientStatus(recipientId) {
this.checkStrategy();
const status = await this.contract.read.getRecipientStatus([recipientId]);
return status;
}
async getStrategyId() {
this.checkStrategy();
const id = await this.contract.read.getStrategyId();
return id;
}
async hasBeenDistributed(index) {
this.checkStrategy();
const distributed = await this.contract.read.hasBeenDistributed([index]);
return distributed;
}
async isDistributionSet() {
this.checkStrategy();
const set = await this.contract.read.isDistributionSet();
return set;
}
async isPoolActive() {
this.checkStrategy();
const active = await this.contract.read.isPoolActive();
return active;
}
async isValidAllocator(allocator) {
this.checkStrategy();
const valid = await this.contract.read.isValidAllocator([allocator]);
return valid;
}
/**
* Write functions
*/
/**
*
* @returns DeployParams {abi, bytecode}
*/
getDeployParams() {
const version = "EasyRetroFundingStrategyv1.0";
const bytecode = easyBytecode;
const abi = easyAbi;
const constructorArgs = encodeAbiParameters(parseAbiParameters("address, string"), [this.allo.address(), version]);
const constructorArgsNo0x = constructorArgs.slice(2);
return {
abi: abi,
bytecode: (bytecode + constructorArgsNo0x),
};
}
async getInitializeData(data) {
const encodedData = encodeAbiParameters(parseAbiParameters("(bool, bool, uint64, uint64, uint64, uint64)"), [
[
data.useRegistryAnchor,
data.metadataRequired,
data.registrationStartTime,
data.registrationEndTime,
data.poolStartTime,
data.poolEndTime
],
]);
return encodedData;
}
/**
*
* @param data - (address, address, Metadata)
* @returns
*/
getRegisterRecipientData(data) {
this.checkPoolId();
const encoded = encodeAbiParameters(parseAbiParameters("address, address, (uint256, string)"), [
data.registryAnchor || ZERO_ADDRESS,
data.recipientAddress,
[data.metadata.protocol, data.metadata.pointer],
]);
const encodedData = encodeFunctionData({
abi: alloAbi,
functionName: "registerRecipient",
args: [this.poolId, encoded],
});
return {
to: this.allo.address(),
data: encodedData,
value: "0",
};
}
/**
* Batch register recipients
*
* @param data - Array of RegisterDataEasyRetroFunding
*
* @returns TransactionData
*/
getBatchRegisterRecipientData(data) {
this.checkPoolId();
const encodedParams = [];
data.forEach((registerData) => {
const encoded = encodeAbiParameters(parseAbiParameters("address, address, (uint256, string)"), [
registerData.registryAnchor || ZERO_ADDRESS,
registerData.recipientAddress,
[registerData.metadata.protocol, registerData.metadata.pointer],
]);
encodedParams.push(encoded);
});
const poolIds = Array(encodedParams.length).fill(this.poolId);
const encodedData = encodeFunctionData({
abi: alloAbi,
functionName: "batchRegisterRecipient",
args: [poolIds, encodedParams],
});
return {
to: this.allo.address(),
data: encodedData,
value: "0",
};
}
/**
* Fund the pool
*
* @param amount - Amount to fund the pool
*
* @returns TransactionData
*/
fundPool(amount) {
this.checkPoolId();
const encodedData = encodeFunctionData({
abi: alloAbi,
functionName: "fundPool",
args: [this.poolId, amount],
});
return {
to: this.allo.address(),
data: encodedData,
value: "0",
};
}
/**
* Distribute to the recipients
*
* @param recipientIds - Array of recipientIds
* @param data - Array of Distribution
*
* @returns TransactionData
*/
distribute(recipientIds,
// (uint256 _poolId, address[] memory _recipientIds, bytes memory _data)
data) {
this.checkPoolId();
const encodeDistribution = encodeAbiParameters(parseAbiParameters("(uint256 index, address recipientId, uint256 amount)[]"), [data]);
const encodedData = encodeFunctionData({
abi: alloAbi,
functionName: "distribute",
args: [this.poolId, recipientIds, encodeDistribution],
});
return {
to: this.allo.address(),
data: encodedData,
value: "0",
};
}
/**
* Provides a function to batch together multiple calls in a single external call
*
* @param data - Array of encoded data
*
* @returns - Encoded transaction data
*/
multicall(data) {
this.checkPoolId();
const encodedData = encodeFunctionData({
abi: easyAbi,
functionName: "multicall",
args: [data],
});
return {
to: this.strategy,
data: encodedData,
value: "0",
};
}
/**
* Review recipients
*
* @param statuses - Array of status indexes and statusRows
*
* @returns TransactionData
*/
reviewRecipients(statuses, refRecipientsCounter) {
const data = encodeFunctionData({
abi: easyAbi,
functionName: "reviewRecipients",
args: [statuses, refRecipientsCounter],
});
return {
to: this.strategy,
data: data,
value: "0",
};
}
updateDistribution(distributionMetadata) {
const data = encodeFunctionData({
abi: easyAbi,
functionName: "updateDistribution",
args: [distributionMetadata],
});
return {
to: this.strategy,
data: data,
value: "0",
};
}
updatePoolTimestamps(registrationStartTime, registrationEndTime, poolStartTime, poolEndTime) {
const data = encodeFunctionData({
abi: easyAbi,
functionName: "updatePoolTimestamps",
args: [
registrationStartTime,
registrationEndTime,
poolStartTime,
poolEndTime,
],
});
return {
to: this.strategy,
data: data,
value: "0",
};
}
withdraw(address) {
const data = encodeFunctionData({
abi: easyAbi,
functionName: "withdraw",
args: [address],
});
return {
to: this.strategy,
data: data,
value: "0",
};
}
}