aiia-vault-sdk 1.0.1

package/dist/contracts/TradingVault.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/contracts.json

@@ -0,0 +1,28 @@
+{
+    "sepolia": {
+        "Currency-old": "0x8c1598399bEb88F9a2aF5966438D4f481512C2f8",
+        "Reward-old": "0x098048C7F6Afd2dA8661965e2d34bf009faA12F2",
+        "TradingVault": "0x1567fEF642c15bbc0738200F04c52e4966cFA0c9",
+        "TradingVault-implemented": "0x74890EC41c499d998d9131a738EFF51229A7f989",
+        "TradingVault-implemented-old": "0x74890EC41c499d998d9131a738EFF51229A7f989",
+        "Currency": "0x2677818cf5e8519273f354FBDA21F794309d8D98",
+        "Reward": "0x09F827Fa3307cF467F51782722A5e3f43a2598dc",
+        "SeedRoundFundraiser": "0xDB40B1E554718555B2E55574B36f0974635c93f4",
+        "SeedRoundFundraiser-implemented": "0xEF7bDB1A5D287d6B3f9a6bD9008471C728249732",
+        "WETH": "0xC82AE9c8b25F5b48ac200efd3e86Ca372AE1AD91"
+    },
+    "hardhat": {
+        "Currency": "0x5FbDB2315678afecb367f032d93F642f64180aa3",
+        "Reward": "0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0",
+        "TradingVault": "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
+        "TradingVault-implemented": "0x5FbDB2315678afecb367f032d93F642f64180aa3"
+    },
+    "base-sepolia": {
+        "Currency": "0xDB2e50234a3BE8aA4200C96712F190cf712cd8ec",
+        "Reward": "0xa5Ef2328aa2F6F231D15cdcF48503974D0938eD4",
+        "SeedRoundFundraiser": "0xbd520dbcb8e0b062D10d7879D27C20d214a262F6",
+        "SeedRoundFundraiser-implemented": "0x539C6D1f51d42f4A1376B0998b4Fff602C9908a6",
+        "WETH": "0x08a2d38807B1D345b6c1642f8030a29DC2Cc7223",
+        "SeedRoundFundraiser-implemented-old": "0x823f099526F2c69bD764686bb4D41afeD7509366"
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./TradingVault";
+export * from "./SeedRoundFundraiser";
+export * from "./types";

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./TradingVault"), exports);
+__exportStar(require("./SeedRoundFundraiser"), exports);
+__exportStar(require("./types"), exports);

package/dist/types.d.ts

@@ -0,0 +1,291 @@
+import { BaseEventRaw } from "./utils";
+export interface RawEventTypes {
+    TotalAmountUpdated: {
+        newTotalAmount: bigint;
+    };
+    PositionCreated: {
+        user: string;
+        tokenId: bigint;
+        entryPrice: bigint;
+        amount: bigint;
+        openedAt: bigint;
+    };
+    PositionReduced: {
+        user: string;
+        tokenId: bigint;
+        reducedAmount: bigint;
+        remainingAmount: bigint;
+        totalReward: bigint;
+        weight: bigint;
+        userReward: bigint;
+        treasuryReward: bigint;
+        rewardedAmount: bigint;
+        lossAmount: bigint;
+        price: bigint;
+        loss: bigint;
+    };
+    CurrencyBorrowed: {
+        borrower: string;
+        amount: bigint;
+    };
+    CurrencyRepaid: {
+        borrower: string;
+        amount: bigint;
+    };
+    PriceUpdated: {
+        oldPrice: bigint;
+        newPrice: bigint;
+        requiredReward: bigint;
+    };
+    CurrencyUpdated: {
+        oldCurrency: string;
+        newCurrency: string;
+    };
+    RewardTokenUpdated: {
+        oldRewardToken: string;
+        newRewardToken: string;
+    };
+    TreasuryUpdated: {
+        oldTreasury: string;
+        newTreasury: string;
+    };
+    RewardConfigsUpdated: Record<string, never>;
+    ReduceEnabledUpdated: {
+        enabled: boolean;
+    };
+    TotalRewardsUpdated: {
+        oldAmount: bigint;
+        newAmount: bigint;
+    };
+    TotalRewardsHarvestedUpdated: {
+        oldAmount: bigint;
+        newAmount: bigint;
+    };
+}
+export interface RawSeedRoundFundraiserEventTypes {
+    TokenWhitelisted: {
+        token: string;
+        price: bigint;
+    };
+    TokenPriceUpdated: {
+        token: string;
+        oldPrice: bigint;
+        newPrice: bigint;
+    };
+    TokenRemovedFromWhitelist: {
+        token: string;
+    };
+    RoundCreated: {
+        roundId: bigint;
+        startTime: bigint;
+        endTime: bigint;
+        targetFund: bigint;
+        totalAllocation: bigint;
+        maxFundPerAccount: bigint;
+    };
+    RoundUpdated: {
+        roundId: bigint;
+        startTime: bigint;
+        endTime: bigint;
+        targetFund: bigint;
+        totalAllocation: bigint;
+        maxFundPerAccount: bigint;
+    };
+    RoundEnded: {
+        roundId: bigint;
+        raisedFunds: bigint;
+        participants: bigint;
+    };
+    Contribution: {
+        roundId: bigint;
+        contributor: string;
+        token: string;
+        amount: bigint;
+        fundAmount: bigint;
+        tokenAllocation: bigint;
+    };
+    TokensClaimed: {
+        roundId: bigint;
+        user: string;
+        amount: bigint;
+    };
+    ProjectTokenUpdated: {
+        oldToken: string;
+        newToken: string;
+    };
+    ClaimingEnabledUpdated: {
+        roundId: bigint;
+        enabled: boolean;
+    };
+    RefundEnabledUpdated: {
+        roundId: bigint;
+        enabled: boolean;
+    };
+    Refunded: {
+        roundId: bigint;
+        user: string;
+        token: string;
+        amount: bigint;
+    };
+}
+export interface EventTypes {
+    TotalAmountUpdated: {
+        newTotalAmount: number;
+    };
+    PositionCreated: {
+        user: string;
+        tokenId: number;
+        entryPrice: number;
+        amount: number;
+        openedAt: number;
+    };
+    PositionReduced: {
+        user: string;
+        tokenId: number;
+        reducedAmount: number;
+        remainingAmount: number;
+        totalReward: number;
+        weight: number;
+        userReward: number;
+        treasuryReward: number;
+        rewardedAmount: number;
+        lossAmount: number;
+        price: number;
+        loss: number;
+    };
+    CurrencyBorrowed: {
+        borrower: string;
+        amount: number;
+    };
+    CurrencyRepaid: {
+        borrower: string;
+        amount: number;
+    };
+    PriceUpdated: {
+        oldPrice: number;
+        newPrice: number;
+        requiredReward: number;
+    };
+    CurrencyUpdated: {
+        oldCurrency: string;
+        newCurrency: string;
+    };
+    RewardTokenUpdated: {
+        oldRewardToken: string;
+        newRewardToken: string;
+    };
+    TreasuryUpdated: {
+        oldTreasury: string;
+        newTreasury: string;
+    };
+    RewardConfigsUpdated: Record<string, never>;
+    ReduceEnabledUpdated: {
+        enabled: boolean;
+    };
+    TotalRewardsUpdated: {
+        oldAmount: number;
+        newAmount: number;
+    };
+    TotalRewardsHarvestedUpdated: {
+        oldAmount: number;
+        newAmount: number;
+    };
+}
+export interface SeedRoundFundraiserEventTypes {
+    TokenWhitelisted: {
+        token: string;
+        price: number;
+    };
+    TokenPriceUpdated: {
+        token: string;
+        oldPrice: number;
+        newPrice: number;
+    };
+    TokenRemovedFromWhitelist: {
+        token: string;
+    };
+    RoundCreated: {
+        roundId: number;
+        startTime: number;
+        endTime: number;
+        targetFund: number;
+        totalAllocation: number;
+        maxFundPerAccount: number;
+    };
+    RoundUpdated: {
+        roundId: number;
+        startTime: number;
+        endTime: number;
+        targetFund: number;
+        totalAllocation: number;
+        maxFundPerAccount: number;
+    };
+    RoundEnded: {
+        roundId: number;
+        raisedFunds: number;
+        participants: number;
+    };
+    Contribution: {
+        roundId: number;
+        contributor: string;
+        token: string;
+        amount: number;
+        fundAmount: number;
+        tokenAllocation: number;
+    };
+    TokensClaimed: {
+        roundId: number;
+        user: string;
+        amount: number;
+    };
+    ProjectTokenUpdated: {
+        oldToken: string;
+        newToken: string;
+    };
+    ClaimingEnabledUpdated: {
+        roundId: number;
+        enabled: boolean;
+    };
+    RefundEnabledUpdated: {
+        roundId: number;
+        enabled: boolean;
+    };
+    Refunded: {
+        roundId: number;
+        user: string;
+        token: string;
+        amount: number;
+    };
+}
+export type ParsedEventRaw = {
+    [K in keyof RawEventTypes]: BaseEventRaw & {
+        eventName: K;
+        args: RawEventTypes[K];
+    };
+}[keyof RawEventTypes];
+export type ParsedSeedRoundFundraiserEventRaw = {
+    [K in keyof RawSeedRoundFundraiserEventTypes]: BaseEventRaw & {
+        eventName: K;
+        args: RawSeedRoundFundraiserEventTypes[K];
+    };
+}[keyof RawSeedRoundFundraiserEventTypes];
+export type AnyEventRaw = ParsedEventRaw & BaseEventRaw;
+export type ParsedEvent = {
+    [K in keyof EventTypes]: {
+        eventName: K;
+        blockNumber: number;
+        transactionHash: string;
+        args: EventTypes[K];
+        timestamp: number | null;
+    };
+}[keyof EventTypes];
+export type ParsedSeedRoundFundraiserEvent = {
+    [K in keyof SeedRoundFundraiserEventTypes]: {
+        eventName: K;
+        blockNumber: number;
+        transactionHash: string;
+        args: SeedRoundFundraiserEventTypes[K];
+        timestamp: number | null;
+    };
+}[keyof SeedRoundFundraiserEventTypes];
+export type AnyEvent = ParsedEvent;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,95 @@
+import { ethers } from "ethers";
+export declare const LOG_PREFIXES: {
+    INFO: string;
+    BLOCK: string;
+    EVENT: string;
+    ERROR: string;
+    SAVE: string;
+    DEBUG: string;
+};
+export declare const sleep: (ms: number) => Promise<void>;
+export declare const getRandomProvider: (providers: ethers.Provider[]) => ethers.Provider;
+export declare const checkRpcHealth: (provider: ethers.Provider, index?: number) => Promise<boolean>;
+export declare const getTransactionStatus: (provider: ethers.Provider, txHash: string, maxRetries?: number) => Promise<{
+    hash: string;
+    status: boolean | null;
+    confirmations: number;
+    isCompleted: boolean;
+    attempts: number;
+}>;
+export declare const getTokenDecimals: (tokenAddress: string, provider: ethers.Provider) => Promise<number>;
+export declare const getTokenSymbol: (tokenAddress: string, provider: ethers.Provider) => Promise<string>;
+export declare const getTokenAllowance: (tokenAddress: string, owner: string, spender: string, provider: ethers.Provider) => Promise<bigint>;
+export declare const buildApproveERC20Tx: (tokenAddress: string, spender: string, amount: bigint, provider: ethers.Provider) => Promise<ethers.ContractTransaction>;
+export declare const getRewardWeight: (duration: number, configs: Array<{
+    weight: number;
+    duration: number;
+}>) => number;
+export declare const resolveContractAddress: (rpcUrl: string, contractName: string, contracts: any, providedAddress?: string) => string;
+export interface BaseEventRaw {
+    eventName: string;
+    blockNumber: number;
+    transactionHash: string;
+    args: Record<string, any>;
+    timestamp: number | null;
+}
+/**
+ * Generic function to get all events from a contract within a block range
+ * @param contract The ethers contract instance
+ * @param getRandomProvider Function to get a random provider
+ * @param fromBlock Starting block number
+ * @param toBlock Ending block number
+ * @returns Array of parsed events with timestamps
+ */
+export declare const getAllEvents: <TEventRaw extends BaseEventRaw, TContract extends ethers.BaseContract>(contract: TContract, getRandomProvider: () => ethers.Provider, getContractWithRandomProvider: () => TContract, fromBlock: number, toBlock: number) => Promise<TEventRaw[]>;
+/**
+ * Generic function to stream blockchain events
+ * @param getProvider Function to get a provider
+ * @param getAllEvents Function to get events for a block range
+ * @param formatEvent Function to format raw events
+ * @param onEvent Callback for each processed event
+ * @param saveLatestBlock Function to save the latest processed block
+ * @param fromBlock Starting block number
+ * @param batchSize Number of blocks to process in each batch
+ * @param sleepTime Time to wait between iterations when caught up
+ */
+export declare const streamEvents: <TRawEvent, TFormattedEvent>({ getProvider, getAllEvents, formatEvent, onEvent, saveLatestBlock, fromBlock, batchSize, sleepTime, }: {
+    getProvider: () => ethers.Provider;
+    getAllEvents: (fromBlock: number, toBlock: number) => Promise<TRawEvent[]>;
+    formatEvent: (event: TRawEvent) => TFormattedEvent;
+    onEvent: (event: TFormattedEvent) => Promise<void>;
+    saveLatestBlock: (blockNumber: number) => Promise<void>;
+    fromBlock: number;
+    batchSize?: number;
+    sleepTime?: number;
+}) => Promise<void>;
+/**
+ * Generic function to sign and send a transaction
+ * @param tx The transaction to send
+ * @param wallet The wallet or sendTransaction function to use
+ * @param getRandomProvider Function to get a random provider
+ * @param contract Optional contract instance
+ * @param callbacks Optional callbacks for transaction events
+ * @returns Transaction result with status
+ */
+export declare const signAndSendTransaction: (tx: ethers.ContractTransaction, wallet: ethers.Wallet | any, getRandomProvider: () => ethers.Provider, { onSubmit, onFinally, onError, }?: {
+    onSubmit?: (tx: string) => void | Promise<void>;
+    onFinally?: (status: {
+        status: boolean | null;
+        confirmations: number;
+        txHash: string;
+        isCompleted: boolean;
+        attempts: number;
+    }) => void | Promise<void>;
+    onError?: (error: Error) => void | Promise<void>;
+}, contract?: ethers.BaseContract) => Promise<{
+    transaction: {
+        hash: string;
+    };
+    status: {
+        status: boolean | null;
+        confirmations: number;
+        isCompleted: boolean;
+        attempts: number;
+    };
+}>;