@hinkal/common 0.2.9 → 0.2.11

package/types/remote-proof.types.d.mts

@@ -0,0 +1,15 @@
+import { NewZkCallDataType } from './snark.types';
+export type HandshakeResponseType = {
+    public_key: string;
+};
+export type RemoteProofType = {
+    pi_a: string[];
+    pi_b: string[][];
+    pi_c: string[];
+    protocol: string;
+};
+export type GenerateProofResponseType = {
+    proof: RemoteProofType;
+    public_signals: string[];
+    zk_calldata: NewZkCallDataType;
+};

package/types/rewards.types.d.mts

@@ -0,0 +1,230 @@
+import { networkRegistry } from '../constants/chains.constants';
+export declare enum TIER_LEVEL {
+    None = "None",
+    Bronze = "Bronze",
+    Silver = "Silver",
+    Gold = "Gold",
+    Platinum = "Platinum",
+    Diamond = "Diamond",
+    Elite = "Elite"
+}
+export declare enum LP_TIER {
+    None = "None",
+    Bronze = "Bronze",
+    Silver = "Silver",
+    Gold = "Gold",
+    Platinum = "Platinum",
+    Diamond = "Diamond"
+}
+export interface TraderIndex {
+    tier: TIER_LEVEL;
+    activeCode: string;
+    inviteeDiscount: number;
+    userTransactions: number;
+    userTrade: number;
+    traderRebates: number;
+}
+export interface AffiliateIndex {
+    tier: TIER_LEVEL;
+    tradersReferred: number;
+    trade: number;
+    transactions: number;
+    lockedDeposit: number;
+    referrerDiscount: number;
+    referrerRebates: number;
+}
+export interface ReferralIndex {
+    referralCode: string;
+    tradersReferred: number;
+    trade: number;
+    transactions: number;
+}
+export interface WeeklyReferralIndex extends ReferralIndex {
+    week: number;
+    consistency: number;
+    rebates: number;
+}
+export interface LpIndex {
+    tier: LP_TIER;
+    lockedDeposit: number;
+    lockinDuration: number;
+    feeDiscount: number;
+    lpRebates: number;
+    revenueRebates: number;
+}
+export interface UserIndex {
+    lpPoints: number;
+    referralPoints: number;
+    certificationPoints: number;
+    tradePoints: number;
+    ambassadorPoints: number;
+    totalPoints: number;
+    boost: number;
+}
+export interface AnonymityStakingUserIndex {
+    position: number;
+    username: string;
+    points: number;
+    referralPoints: number;
+    totalPoints: number;
+}
+export interface AnonymityStakingReferralPointsIndex {
+    referralCode: string;
+    numberOfStakersReferred: number;
+    cumulativeValue: number;
+}
+export interface CombinedReferralIndex extends ReferralIndex, AnonymityStakingReferralPointsIndex {
+}
+export declare enum RewardsPageTabs {
+    Points = "POINTS",
+    ReferralProgram = "REFERRAL",
+    LrtPoints = "LRT_POINTS",
+    LPProgram = "LP",
+    RewardsHistory = "HISTORY"
+}
+export declare enum RewardsHistoryStatuses {
+    InProgress = "In Progress",
+    Closed = "Closed"
+}
+export declare enum RewardsHistorySnapshots {
+    Pending = "Pending",
+    Submitted = "Submitted",
+    Unsubmitted = "Didn't Submit"
+}
+export declare enum RewardsHistoryEligibility {
+    Pending = "Pending",
+    Eligible = "Eligible",
+    Ineligible = "Ineligible"
+}
+export declare enum RewardsHistoryDistribution {
+    Pending = "Pending",
+    Completed = "Completed",
+    Unsubmitted = "Didn't Submit"
+}
+export interface RewardsHistoryItem<T> {
+    id: number;
+    date: string;
+    status: RewardsHistoryStatuses;
+    snapshot: RewardsHistorySnapshots;
+    eligibility: RewardsHistoryEligibility;
+    distribution: RewardsHistoryDistribution;
+    data: T;
+}
+export declare enum RafflePrizeType {
+    Gold = "Gold",
+    Silver = "Silver"
+}
+export declare enum PointType {
+    CertificationPoints = "CertificationPoints",
+    TradePoints = "TradePoints",
+    LPPoints = "LPPoints",
+    ReferralPoints = "ReferralPoints",
+    GalxePoints = "GalxePoints",
+    ZealyPoints = "ZealyPoints",
+    TaskOnPoints = "TaskOnPoints",
+    BonusPoints = "BonusPoints"
+}
+export type PointData = {
+    [PointType.CertificationPoints]: number;
+    [PointType.TradePoints]: number;
+    [PointType.LPPoints]: number;
+    [PointType.ReferralPoints]: number;
+    [PointType.GalxePoints]: number;
+    [PointType.ZealyPoints]: number;
+    [PointType.TaskOnPoints]?: number;
+    [PointType.BonusPoints]?: number;
+    RafflePrize?: RafflePrizeType;
+    boost?: number;
+    points: number;
+};
+export type TradingData = {
+    volume: number;
+    transactions: number;
+};
+export interface RewardsHistoryData {
+    week: number;
+    affiliateIndex: AffiliateIndex;
+    traderIndex: TraderIndex;
+    lpIndex: LpIndex;
+    points?: PointData;
+    isVerified: boolean;
+    paymentStatus?: PaymentStatus;
+    eligibility?: boolean;
+    rafflePrize: RafflePrizeType;
+    raffleTickets: number;
+}
+export declare enum Timeline {
+    Season = "Season",
+    Week = "Week"
+}
+export type CountDown = {
+    daysLeft: number;
+    hoursLeft: number;
+    minutesLeft: number;
+    secondsLeft: number;
+};
+export type RewardPaymentInfo = {
+    chainId: number;
+    receivingAddress: string;
+    rewardTokenAddress: string;
+};
+export declare enum PaymentStatus {
+    PAID = "PAID",
+    PENDING = "PENDING"
+}
+export declare enum CertifyType {
+    Certify = 0,
+    CheckActivity = 1
+}
+export declare enum RewardPage {
+    Points = 0,
+    Trader = 1,
+    Affiliate = 2,
+    LP = 3,
+    History = 4
+}
+export declare enum BonusType {
+    ReclaimCheck = 0,
+    IntegrationCheck = 1,
+    RandomPrizeGold = 2,
+    RandomPrizeSilver = 3
+}
+export type UserPoints = Record<string, number>;
+export type UserPointsTokens = Record<string, UserPoints>;
+export type UserPointsResponse = {
+    Result: UserPointsTokens;
+};
+export declare const emptyUserPointsResponse: {
+    Result: {};
+};
+export type UserPointsBreakdown = {
+    EtherFi: number;
+    Renzo: number;
+    Kelp: number;
+    Zircuit: number;
+};
+export declare const emptyUserPointsBreakdown: {
+    renzo: number;
+    kelp: number;
+    etherFi: number;
+    zircuit: number;
+};
+export interface HistoryIndexesProps {
+    week: number;
+    lpIndex: LpIndex;
+    affiliateIndex: AffiliateIndex;
+    traderIndex: TraderIndex;
+    points?: PointData;
+    raffleTickets: number;
+    rafflePrize: RafflePrizeType;
+    lpProgramStartWeek: number;
+    raffleProgramStartWeek: number;
+}
+export type HashInfoByChain = Record<keyof typeof networkRegistry, {
+    lastCertifiedHash: string;
+    week: number;
+}>;
+export type WeekOption = {
+    value: number;
+    label: string;
+};

package/types/slippage.types.d.mts

@@ -0,0 +1,15 @@
+export declare enum SlippageType {
+    Swap = "Swap",
+    CurveDeposit = "CurveDeposit",
+    CurveWithdraw = "CurveWithdraw",
+    Beefy = "Beefy",
+    Pendle = "Pendle"
+}
+export interface ISlippageLevels {
+    [SlippageType.Swap]: number;
+    [SlippageType.CurveDeposit]: number;
+    [SlippageType.CurveWithdraw]: number;
+    [SlippageType.Beefy]: number;
+    [SlippageType.Pendle]: number;
+}
+export declare const slippageLevels: ISlippageLevels;

package/types/snark.types.d.mts

@@ -0,0 +1,40 @@
+interface ZkBaseInputType {
+    rootHashHinkal: bigint | undefined;
+    shieldedPrivateKey: string;
+    inAmounts: string[];
+    inBlindings: string[];
+    inNullifiers: string[];
+    inCommitmentSiblings: string[][];
+    inCommitmentSiblingSides: string[][];
+    outCommitments: string[];
+    rootHashAccessToken: bigint | undefined;
+    accessTokenSiblings: string[];
+    accessTokenSiblingSides: string[];
+    relayFee: bigint;
+    relay: string;
+}
+export interface ZkInputType extends ZkBaseInputType {
+    publicAmount: bigint;
+    recipientAddress: string;
+    erc20TokenAddress: string;
+    outAmounts: string[];
+    outShieldedPublicKey: string[];
+    outBlindings: string[];
+}
+export interface ZkExternalInputType extends ZkBaseInputType {
+    inSwapAmount: bigint;
+    inErc20TokenAddress: string;
+    outAmount: bigint;
+    outBlinding: bigint;
+    outSwapAmount: bigint;
+    outErc20TokenAddress: string;
+    outSwapBlinding: bigint;
+    externalActionId: bigint;
+    externalActionMetadataHash: bigint;
+}
+export interface ZkResultType {
+    proof: string;
+    publicSignals: string[];
+}
+export type NewZkCallDataType = [[string, string], [[string, string], [string, string]], [string, string], string[]];
+export {};

package/types/time.types.d.mts

@@ -0,0 +1,31 @@
+export declare const secondInMilliseconds = 1000;
+export declare const minuteInMilliseconds: number;
+export declare const hourInMilliseconds: number;
+export declare const dayInMilliseconds: number;
+export declare const weekInMilliseconds: number;
+export declare const getDateFromWeek: (week: number) => Date;
+export declare const getWeekTimestamps: (week: number) => {
+    initialTimestamp: number;
+    endTimestamp: number;
+};
+export declare const getCurrentWeek: () => number;
+export declare const parseWeek: (week: unknown) => number | undefined;
+export declare const toDateString: (date: Date, delimiter?: string) => string;
+export declare const isWeekCurrent: (week: number) => boolean;
+export declare const hasCertificationPeriodExpired: (week: number) => boolean;
+export declare const getNextDay: (date: Date) => Date;
+export declare enum MONTHS {
+    JANUARY = 0,
+    FEBRUARY = 1,
+    MARCH = 2,
+    APRIL = 3,
+    MAY = 4,
+    JUNE = 5,
+    JULY = 6,
+    AUGUST = 7,
+    SEPTEMBER = 8,
+    OCTOBER = 9,
+    NOVEMBER = 10,
+    DECEMBER = 11
+}
+export declare const divideMonthOnIntervals: (year: number, month: MONTHS) => number[];

package/types/token.types.d.mts

@@ -0,0 +1,36 @@
+export interface ERC20Token {
+    chainId: number;
+    erc20TokenAddress: string;
+    wrappedErc20TokenAddress?: string;
+    underlyingErc20TokenAddress?: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    logoURI?: string;
+    logoURIs?: string[];
+    whitelisted?: boolean;
+    isCustom?: true;
+    isNFT?: boolean;
+    approvalType?: ApprovalType;
+    isVolatile?: boolean;
+    sharedAddress?: string;
+    isPendleToken?: boolean;
+    isHToken?: boolean;
+    hasHToken?: boolean;
+    aaveToken?: boolean;
+}
+export declare enum ApprovalType {
+    Classic = 0,
+    ERC20Permit = 1,
+    DAIPermit = 2
+}
+export interface NFT {
+    tokenId: number;
+    timestamp: string;
+}
+export interface TokenBalance {
+    token: ERC20Token;
+    balance: bigint;
+    timestamp?: string;
+    nfts?: NFT[];
+}

package/types/transactions.types.d.mts

@@ -0,0 +1,55 @@
+import { BigNumber } from 'ethers';
+import { HookDataType, StealthAddressStructure } from './circom-data.types';
+export interface RawTx {
+    blockNumber: number;
+    timeStamp: number;
+    isError: string;
+    methodId: string;
+    input: string;
+    logs: Log[];
+    hash: string;
+    gas: number;
+    gasPrice: number;
+    contract?: string;
+}
+type Log = {
+    topics: string[];
+    data: string;
+};
+export interface EventLog {
+    address: string;
+    topics: string[];
+    data: string;
+    blockNumber: string;
+    blockHash: string;
+    timeStamp: string;
+    gasPrice: string;
+    gasUsed: string;
+    logIndex: string;
+    transactionHash: string;
+    transactionIndex: string;
+}
+export interface DecodedTx<T = bigint, K = BigNumber> extends RawTx {
+    decodedInput: {
+        erc20TokenAddresses: string[];
+        amountChanges: K[];
+        flatFees: K[];
+        externalActionId: K;
+        externalActionMetadata: string;
+        encryptedOutputs: string[];
+        hookData: HookDataType;
+        stealthAddressStructure: StealthAddressStructure<T>;
+    };
+    status: string;
+}
+export interface DecodedTxWithUtxos<T = bigint, K = BigNumber> extends DecodedTx<T, K> {
+    utxosArray?: OnChainUtxo<T>[];
+}
+export type OnChainUtxo<AmountType = bigint> = {
+    amount: AmountType;
+    erc20TokenAddress: string;
+    timeStamp: string;
+    tokenId: number;
+};
+export declare const emptyDecodedTx: DecodedTx;
+export {};

package/webworker/performTaskWithWorker.d.mts

@@ -0,0 +1,5 @@
+import { WorkerVariant } from './worker.registry';
+export declare const performTaskWithWorker: <P, T>(workerData: {
+    type: WorkerVariant;
+    payload: P;
+}) => Promise<T>;

package/webworker/snarkjsWorker/snarkjsWorker.types.d.mts

@@ -0,0 +1,14 @@
+import { WorkerParams, WorkerPayload } from '../worker.types';
+export declare enum SnarkJSWorkerActionType {
+    FULL_PROVE = 0
+}
+export interface SnarkJSWorkerFullProvePayload extends WorkerPayload<{
+    input: any;
+    chainId: number;
+    wasmFilePath: string;
+    zKeyFilePath: string;
+}> {
+    type: SnarkJSWorkerActionType.FULL_PROVE;
+}
+export type SnarkJSPayload = SnarkJSWorkerFullProvePayload;
+export type SnarkJSParams = WorkerParams<SnarkJSPayload>;

package/webworker/snarkjsWorker/snarkjsWorkerLauncher.d.mts

@@ -0,0 +1 @@
+export {};

package/webworker/snarkjsWorker/snarkjsWorkerLogic.d.mts

@@ -0,0 +1,10 @@
+/**
+ * This Web Worker only handle snarkjs operation.
+ * If possible, avoid importing modules form main project and instead pass data along with message
+ * to ensure this worker stay lean.
+ */
+import { WorkerProxy } from '../workerProxy';
+import { SnarkJSParams } from './snarkjsWorker.types';
+declare const workerProxy: WorkerProxy;
+export declare const onWorkerMessage: (data: SnarkJSParams) => Promise<void>;
+export default workerProxy;

package/webworker/utxoWorker/utxoWorker.types.d.mts

@@ -0,0 +1,29 @@
+import { EncryptedOutputWithSign } from '../../types/commitments.types';
+import { WorkerParams, WorkerPayload } from '../worker.types';
+import { IUtxoConstructor } from '../../data-structures/utxo/Utxo';
+export declare enum UtxoWorkerActionType {
+    BATCH_FILTER_UTXOS_WITH_NULLIFIER = 0,
+    BUILD_UTXOS = 1,
+    DECIPHER_OUTPUTS = 2
+}
+export interface BatchFilterUtxosWithNullifierPayload extends WorkerPayload<{
+    utxos: IUtxoConstructor[];
+    nullifiers: Set<string>;
+}> {
+    type: UtxoWorkerActionType.BATCH_FILTER_UTXOS_WITH_NULLIFIER;
+}
+export interface BuildBatchProcessPayload extends WorkerPayload<{
+    signature: string;
+    encryptedOutputs: EncryptedOutputWithSign[];
+}> {
+    type: UtxoWorkerActionType.BUILD_UTXOS;
+}
+export interface DecipherProcessPayload extends WorkerPayload<{
+    encryptedOutputs: EncryptedOutputWithSign[];
+    lastOutput: string;
+    signature: string;
+}> {
+    type: UtxoWorkerActionType.DECIPHER_OUTPUTS;
+}
+export type UtxoWorkerPayload = BuildBatchProcessPayload | BatchFilterUtxosWithNullifierPayload | DecipherProcessPayload;
+export type UtxoWorkerParams = WorkerParams<UtxoWorkerPayload>;

package/webworker/utxoWorker/utxoWorkerLauncher.d.mts

@@ -0,0 +1 @@
+export {};

package/webworker/utxoWorker/utxoWorkerLogic.d.mts

@@ -0,0 +1,8 @@
+import { WorkerProxy } from '../workerProxy';
+import { BatchFilterUtxosWithNullifierPayload, BuildBatchProcessPayload, DecipherProcessPayload, UtxoWorkerParams } from './utxoWorker.types';
+declare const workerProxy: WorkerProxy;
+export declare const handleFilterUtxosWithNullifier: ({ data }: BatchFilterUtxosWithNullifierPayload) => Promise<void>;
+export declare const handleBuildUtxosMessage: ({ data }: BuildBatchProcessPayload) => Promise<void>;
+export declare const handleDecipherMessage: ({ data }: DecipherProcessPayload) => Promise<void>;
+export declare const onWorkerMessage: (data: UtxoWorkerParams) => Promise<void>;
+export default workerProxy;

package/webworker/viteWorkerURL.constant.d.mts

@@ -0,0 +1,9 @@
+/**
+ * These imports tell vite to generate and bundle worker file.
+ * These are import conditionally because we do not have vite when running on node.
+ */
+export declare const getWorkerViteURL: () => Promise<{
+    ZKProof: any;
+    SnarkJS: any;
+    UTXO: any;
+}>;

package/webworker/worker.registry.d.mts

@@ -0,0 +1,10 @@
+export declare enum WorkerVariant {
+    ZKProof = "ZKProof",
+    SnarkJS = "SnarkJS",
+    UTXO = "UTXO"
+}
+export declare const workerNodeURL: {
+    ZKProof: string;
+    SnarkJS: string;
+    UTXO: string;
+};

package/webworker/worker.types.d.mts

@@ -0,0 +1,33 @@
+export interface WorkerPayload<T> {
+    data: T;
+}
+export interface WorkerMetadata {
+    hostLocation: {
+        origin?: string;
+        protocol?: string;
+        host?: string;
+        port?: string;
+        hostname?: string;
+        href?: string;
+    };
+    /**
+     * Importing these in worker script will executed the whole constant script in worker env,
+     * which could resolve into different values, as well as, result in many unnecessary imports
+     */
+    constants: {
+        chains: {
+            chainIds: {
+                [key: string]: number;
+            };
+        };
+        /**
+         * Worker do not have access to window.location -> so this will always be false if import
+         * directly from vite constant file.
+         */
+        isDevelopment: boolean;
+    };
+}
+export interface WorkerParams<T = WorkerPayload<unknown>> {
+    payload: T;
+    metadata: WorkerMetadata;
+}

package/webworker/workerErrorHandler.d.mts

@@ -0,0 +1 @@
+export declare const addWorkerErrorHandler: () => void;

package/webworker/workerFactory.d.mts

@@ -0,0 +1,7 @@
+import { WorkerVariant } from './worker.registry';
+export declare class WorkerFactory {
+    private constructor();
+    private static resolveWorkerURL;
+    private static createWorker;
+    static getWebWorker(workerVariant: WorkerVariant): Promise<any>;
+}

package/webworker/workerProxy.d.mts

@@ -0,0 +1,40 @@
+/**
+ * This class mimic interface of real Web Worker so it can be passed to code that expect normal web
+ * worker on browser side and operate as if it is the same, while executing the actual code on main
+ * thread when Node environment is detected.
+ *
+ * The reason we need this is because hardhat, at the time of writting (Mar 12, 2024), do not support
+ * ES Module worker with typescript. Enabling experimental ESM support for `ts-node` does not work
+ * across all machines and environment, thus, we decided to run the worker's logic on main thread
+ * during hardhat step.
+ */
+export declare class WorkerProxy {
+    private isNode;
+    /**
+     * This allow browser or main thread to listen for worker response message
+     * using the normal `worker.onmessage = () => {}` syntax. Is should only be side on the
+     * main thread side, not on worker side.
+     */
+    onmessage: ((e: {
+        data: any;
+    }) => void) | null;
+    private _eventEmitter;
+    /**
+     * Lazy load event emitter so it is only initialize if require/if in node environment
+     */
+    private get eventEmitter();
+    constructor();
+    terminate(): void;
+    /**
+     * This postMessage() should only be called when intending to send message from main thread to
+     * worker; In a typical browser environment, this will just act as a normal postMessage() function.
+     */
+    postMessage(message: unknown): void;
+    /**
+     * A separate postMessage() is needed because both main thread and worker thread communicate with
+     * each other using postMessage(), but we cannot (and do not) differentiate between the two
+     * while running on main thread on hardhat
+     */
+    postMessageToMainThread(message: unknown): void;
+    attachWorkerSideOnMessage(fn: (e: any) => void | Promise<void>): void;
+}

package/webworker/zkProofWorker/zkProofWorker.types.d.mts

@@ -0,0 +1,38 @@
+import { IUtxoConstructor } from '../../data-structures/utxo/Utxo';
+import { type MerkleTreeJson } from '../../data-structures/merkle-tree';
+import { WorkerParams, WorkerPayload } from '../worker.types';
+export declare enum ZKProofWorkerActionType {
+    CALC_COMMITMENTS_SIBLING_AND_SIDES = 0,
+    CALC_ACCESS_TOKEN_SIBLING_AND_SIDES = 1,
+    BUILD_IN_NULLIFIERS = 2
+}
+export interface ZKProofWorkerCalcCommitmentsPayload extends WorkerPayload<{
+    inputUtxosSerialized: IUtxoConstructor[][];
+    merkleTreeSerialized: MerkleTreeJson;
+    userSignature: string;
+}> {
+    type: ZKProofWorkerActionType.CALC_COMMITMENTS_SIBLING_AND_SIDES;
+}
+export interface ZKProofWorkerCalcCommitmentsReturn {
+    inCommitmentSiblings: string[][][];
+    inCommitmentSiblingSides: string[][][];
+}
+export interface ZKProofWorkerCalcAccessTokenPayload extends WorkerPayload<{
+    merkleTreeAccessTokenSerialized: MerkleTreeJson;
+    userSignature: string;
+}> {
+    type: ZKProofWorkerActionType.CALC_ACCESS_TOKEN_SIBLING_AND_SIDES;
+}
+export interface ZKProofWorkerCalcAccessTokenReturn {
+    accessTokenSiblings: string[];
+    accessTokenSiblingSides: string[];
+}
+export interface ZKProofWorkerBuildInNullifiersPayload extends WorkerPayload<{
+    inputUtxosSerialized: IUtxoConstructor[][];
+    onChainCreation: boolean[];
+}> {
+    type: ZKProofWorkerActionType.BUILD_IN_NULLIFIERS;
+}
+export type ZKProofWorkerBuildInNullifiersReturn = string[][];
+export type ZKProofWorkerPayload = ZKProofWorkerCalcCommitmentsPayload | ZKProofWorkerCalcAccessTokenPayload | ZKProofWorkerBuildInNullifiersPayload;
+export type ZKProofWorkerParams = WorkerParams<ZKProofWorkerPayload>;

package/webworker/zkProofWorker/zkProofWorkerLauncher.d.mts

@@ -0,0 +1 @@
+export {};

package/webworker/zkProofWorker/zkProofWorkerLogic.d.mts

@@ -0,0 +1,8 @@
+import { WorkerProxy } from '../workerProxy';
+import { ZKProofWorkerBuildInNullifiersPayload, ZKProofWorkerCalcAccessTokenPayload, ZKProofWorkerCalcCommitmentsPayload, ZKProofWorkerParams } from './zkProofWorker.types';
+declare const workerProxy: WorkerProxy;
+export declare const handleCalcCommitmentsSiblingAndSides: (payload: ZKProofWorkerCalcCommitmentsPayload) => void;
+export declare const handleCalcAccessTokenSiblingAndSides: (payload: ZKProofWorkerCalcAccessTokenPayload) => void;
+export declare const handleBuildInNullifiers: (payload: ZKProofWorkerBuildInNullifiersPayload) => void;
+export declare const onWorkerMessage: (data: ZKProofWorkerParams) => Promise<void>;
+export default workerProxy;