@underscore-finance/sdk 1.2.8 → 1.2.9

package/dist/contracts/SwitchboardBravo.js

@@ -3,6 +3,7 @@
 /* eslint-disable */
 /* @ts-nocheck */
 import { singleQuery, mutate } from '@dappql/async';
+import { encodeEventTopics, parseEventLogs, } from 'viem';
 export const abi = [
     {
         name: 'PendingRecoverFundsAction',
@@ -1763,66 +1764,187 @@ export const mutation = {
     executePendingAction: getMutation('executePendingAction'),
     cancelPendingAction: getMutation('cancelPendingAction'),
 };
-export function toSdk(publicClient, walletClient) {
+export function parseEvents(eventName, events) {
+    return events.map((event) => {
+        return {
+            event,
+            parsed: parseEventLogs({
+                abi,
+                eventName,
+                logs: [event],
+            }),
+        };
+    });
+}
+export function getEventTopic(eventName) {
+    return encodeEventTopics({ abi, eventName })[0];
+}
+export function toSdk(publicClient, walletClient, addressResolver) {
     return {
         deployAddress,
         abi,
+        events: {
+            PendingRecoverFundsAction: {
+                topic: getEventTopic('PendingRecoverFundsAction'),
+                parse: (events) => parseEvents('PendingRecoverFundsAction', events),
+            },
+            PendingRecoverFundsManyAction: {
+                topic: getEventTopic('PendingRecoverFundsManyAction'),
+                parse: (events) => parseEvents('PendingRecoverFundsManyAction', events),
+            },
+            PendingRecoverNftAction: {
+                topic: getEventTopic('PendingRecoverNftAction'),
+                parse: (events) => parseEvents('PendingRecoverNftAction', events),
+            },
+            PendingLootAdjustAction: {
+                topic: getEventTopic('PendingLootAdjustAction'),
+                parse: (events) => parseEvents('PendingLootAdjustAction', events),
+            },
+            PendingRecoverDepositRewardsAction: {
+                topic: getEventTopic('PendingRecoverDepositRewardsAction'),
+                parse: (events) => parseEvents('PendingRecoverDepositRewardsAction', events),
+            },
+            AssetDataUpdated: {
+                topic: getEventTopic('AssetDataUpdated'),
+                parse: (events) => parseEvents('AssetDataUpdated', events),
+            },
+            AllAssetDataUpdated: {
+                topic: getEventTopic('AllAssetDataUpdated'),
+                parse: (events) => parseEvents('AllAssetDataUpdated', events),
+            },
+            PendingSetEjectionModeAction: {
+                topic: getEventTopic('PendingSetEjectionModeAction'),
+                parse: (events) => parseEvents('PendingSetEjectionModeAction', events),
+            },
+            PauseExecuted: {
+                topic: getEventTopic('PauseExecuted'),
+                parse: (events) => parseEvents('PauseExecuted', events),
+            },
+            RecoverFundsExecuted: {
+                topic: getEventTopic('RecoverFundsExecuted'),
+                parse: (events) => parseEvents('RecoverFundsExecuted', events),
+            },
+            RecoverFundsManyExecuted: {
+                topic: getEventTopic('RecoverFundsManyExecuted'),
+                parse: (events) => parseEvents('RecoverFundsManyExecuted', events),
+            },
+            RecoverNftExecuted: {
+                topic: getEventTopic('RecoverNftExecuted'),
+                parse: (events) => parseEvents('RecoverNftExecuted', events),
+            },
+            DepositPointsUpdated: {
+                topic: getEventTopic('DepositPointsUpdated'),
+                parse: (events) => parseEvents('DepositPointsUpdated', events),
+            },
+            LootClaimedForUser: {
+                topic: getEventTopic('LootClaimedForUser'),
+                parse: (events) => parseEvents('LootClaimedForUser', events),
+            },
+            LootClaimedForManyUsers: {
+                topic: getEventTopic('LootClaimedForManyUsers'),
+                parse: (events) => parseEvents('LootClaimedForManyUsers', events),
+            },
+            LootAdjusted: {
+                topic: getEventTopic('LootAdjusted'),
+                parse: (events) => parseEvents('LootAdjusted', events),
+            },
+            RecoverDepositRewardsExecuted: {
+                topic: getEventTopic('RecoverDepositRewardsExecuted'),
+                parse: (events) => parseEvents('RecoverDepositRewardsExecuted', events),
+            },
+            SetEjectionModeExecuted: {
+                topic: getEventTopic('SetEjectionModeExecuted'),
+                parse: (events) => parseEvents('SetEjectionModeExecuted', events),
+            },
+            GovChangeTimeLockModified: {
+                topic: getEventTopic('GovChangeTimeLockModified'),
+                parse: (events) => parseEvents('GovChangeTimeLockModified', events),
+            },
+            ExpirationSet: {
+                topic: getEventTopic('ExpirationSet'),
+                parse: (events) => parseEvents('ExpirationSet', events),
+            },
+            ActionTimeLockSet: {
+                topic: getEventTopic('ActionTimeLockSet'),
+                parse: (events) => parseEvents('ActionTimeLockSet', events),
+            },
+            GovChangeStarted: {
+                topic: getEventTopic('GovChangeStarted'),
+                parse: (events) => parseEvents('GovChangeStarted', events),
+            },
+            GovChangeConfirmed: {
+                topic: getEventTopic('GovChangeConfirmed'),
+                parse: (events) => parseEvents('GovChangeConfirmed', events),
+            },
+            GovChangeCancelled: {
+                topic: getEventTopic('GovChangeCancelled'),
+                parse: (events) => parseEvents('GovChangeCancelled', events),
+            },
+            GovRelinquished: {
+                topic: getEventTopic('GovRelinquished'),
+                parse: (events) => parseEvents('GovRelinquished', events),
+            },
+            UndyHqSetupFinished: {
+                topic: getEventTopic('UndyHqSetupFinished'),
+                parse: (events) => parseEvents('UndyHqSetupFinished', events),
+            },
+        },
         // Queries
-        getAddys: (...args) => singleQuery(publicClient, call.getAddys(...args)),
-        getUndyHq: (...args) => singleQuery(publicClient, call.getUndyHq(...args)),
-        getUndyHqFromGov: (...args) => singleQuery(publicClient, call.getUndyHqFromGov(...args)),
-        canGovern: (...args) => singleQuery(publicClient, call.canGovern(...args)),
-        getGovernors: (...args) => singleQuery(publicClient, call.getGovernors(...args)),
-        hasPendingGovChange: (...args) => singleQuery(publicClient, call.hasPendingGovChange(...args)),
-        isValidGovTimeLock: (...args) => singleQuery(publicClient, call.isValidGovTimeLock(...args)),
-        minGovChangeTimeLock: (...args) => singleQuery(publicClient, call.minGovChangeTimeLock(...args)),
-        maxGovChangeTimeLock: (...args) => singleQuery(publicClient, call.maxGovChangeTimeLock(...args)),
-        governance: (...args) => singleQuery(publicClient, call.governance(...args)),
-        pendingGov: (...args) => singleQuery(publicClient, call.pendingGov(...args)),
-        numGovChanges: (...args) => singleQuery(publicClient, call.numGovChanges(...args)),
-        govChangeTimeLock: (...args) => singleQuery(publicClient, call.govChangeTimeLock(...args)),
-        canConfirmAction: (...args) => singleQuery(publicClient, call.canConfirmAction(...args)),
-        isExpired: (...args) => singleQuery(publicClient, call.isExpired(...args)),
-        hasPendingAction: (...args) => singleQuery(publicClient, call.hasPendingAction(...args)),
-        getActionConfirmationBlock: (...args) => singleQuery(publicClient, call.getActionConfirmationBlock(...args)),
-        isValidActionTimeLock: (...args) => singleQuery(publicClient, call.isValidActionTimeLock(...args)),
-        minActionTimeLock: (...args) => singleQuery(publicClient, call.minActionTimeLock(...args)),
-        maxActionTimeLock: (...args) => singleQuery(publicClient, call.maxActionTimeLock(...args)),
-        pendingActions: (...args) => singleQuery(publicClient, call.pendingActions(...args)),
-        actionId: (...args) => singleQuery(publicClient, call.actionId(...args)),
-        actionTimeLock: (...args) => singleQuery(publicClient, call.actionTimeLock(...args)),
-        expiration: (...args) => singleQuery(publicClient, call.expiration(...args)),
-        actionType: (...args) => singleQuery(publicClient, call.actionType(...args)),
-        pendingPauseActions: (...args) => singleQuery(publicClient, call.pendingPauseActions(...args)),
-        pendingRecoverFundsActions: (...args) => singleQuery(publicClient, call.pendingRecoverFundsActions(...args)),
-        pendingRecoverFundsManyActions: (...args) => singleQuery(publicClient, call.pendingRecoverFundsManyActions(...args)),
-        pendingRecoverNftActions: (...args) => singleQuery(publicClient, call.pendingRecoverNftActions(...args)),
-        pendingLootAdjustActions: (...args) => singleQuery(publicClient, call.pendingLootAdjustActions(...args)),
-        pendingRecoverDepositRewardsActions: (...args) => singleQuery(publicClient, call.pendingRecoverDepositRewardsActions(...args)),
-        pendingSetEjectionModeActions: (...args) => singleQuery(publicClient, call.pendingSetEjectionModeActions(...args)),
+        getAddys: (...args) => singleQuery(publicClient, call.getAddys(...args), {}, addressResolver),
+        getUndyHq: (...args) => singleQuery(publicClient, call.getUndyHq(...args), {}, addressResolver),
+        getUndyHqFromGov: (...args) => singleQuery(publicClient, call.getUndyHqFromGov(...args), {}, addressResolver),
+        canGovern: (...args) => singleQuery(publicClient, call.canGovern(...args), {}, addressResolver),
+        getGovernors: (...args) => singleQuery(publicClient, call.getGovernors(...args), {}, addressResolver),
+        hasPendingGovChange: (...args) => singleQuery(publicClient, call.hasPendingGovChange(...args), {}, addressResolver),
+        isValidGovTimeLock: (...args) => singleQuery(publicClient, call.isValidGovTimeLock(...args), {}, addressResolver),
+        minGovChangeTimeLock: (...args) => singleQuery(publicClient, call.minGovChangeTimeLock(...args), {}, addressResolver),
+        maxGovChangeTimeLock: (...args) => singleQuery(publicClient, call.maxGovChangeTimeLock(...args), {}, addressResolver),
+        governance: (...args) => singleQuery(publicClient, call.governance(...args), {}, addressResolver),
+        pendingGov: (...args) => singleQuery(publicClient, call.pendingGov(...args), {}, addressResolver),
+        numGovChanges: (...args) => singleQuery(publicClient, call.numGovChanges(...args), {}, addressResolver),
+        govChangeTimeLock: (...args) => singleQuery(publicClient, call.govChangeTimeLock(...args), {}, addressResolver),
+        canConfirmAction: (...args) => singleQuery(publicClient, call.canConfirmAction(...args), {}, addressResolver),
+        isExpired: (...args) => singleQuery(publicClient, call.isExpired(...args), {}, addressResolver),
+        hasPendingAction: (...args) => singleQuery(publicClient, call.hasPendingAction(...args), {}, addressResolver),
+        getActionConfirmationBlock: (...args) => singleQuery(publicClient, call.getActionConfirmationBlock(...args), {}, addressResolver),
+        isValidActionTimeLock: (...args) => singleQuery(publicClient, call.isValidActionTimeLock(...args), {}, addressResolver),
+        minActionTimeLock: (...args) => singleQuery(publicClient, call.minActionTimeLock(...args), {}, addressResolver),
+        maxActionTimeLock: (...args) => singleQuery(publicClient, call.maxActionTimeLock(...args), {}, addressResolver),
+        pendingActions: (...args) => singleQuery(publicClient, call.pendingActions(...args), {}, addressResolver),
+        actionId: (...args) => singleQuery(publicClient, call.actionId(...args), {}, addressResolver),
+        actionTimeLock: (...args) => singleQuery(publicClient, call.actionTimeLock(...args), {}, addressResolver),
+        expiration: (...args) => singleQuery(publicClient, call.expiration(...args), {}, addressResolver),
+        actionType: (...args) => singleQuery(publicClient, call.actionType(...args), {}, addressResolver),
+        pendingPauseActions: (...args) => singleQuery(publicClient, call.pendingPauseActions(...args), {}, addressResolver),
+        pendingRecoverFundsActions: (...args) => singleQuery(publicClient, call.pendingRecoverFundsActions(...args), {}, addressResolver),
+        pendingRecoverFundsManyActions: (...args) => singleQuery(publicClient, call.pendingRecoverFundsManyActions(...args), {}, addressResolver),
+        pendingRecoverNftActions: (...args) => singleQuery(publicClient, call.pendingRecoverNftActions(...args), {}, addressResolver),
+        pendingLootAdjustActions: (...args) => singleQuery(publicClient, call.pendingLootAdjustActions(...args), {}, addressResolver),
+        pendingRecoverDepositRewardsActions: (...args) => singleQuery(publicClient, call.pendingRecoverDepositRewardsActions(...args), {}, addressResolver),
+        pendingSetEjectionModeActions: (...args) => singleQuery(publicClient, call.pendingSetEjectionModeActions(...args), {}, addressResolver),
         // Mutations
-        startGovernanceChange: (...args) => mutate(walletClient, mutation.startGovernanceChange)(...args),
-        confirmGovernanceChange: (...args) => mutate(walletClient, mutation.confirmGovernanceChange)(...args),
-        cancelGovernanceChange: (...args) => mutate(walletClient, mutation.cancelGovernanceChange)(...args),
-        relinquishGov: (...args) => mutate(walletClient, mutation.relinquishGov)(...args),
-        setGovTimeLock: (...args) => mutate(walletClient, mutation.setGovTimeLock)(...args),
-        finishUndyHqSetup: (...args) => mutate(walletClient, mutation.finishUndyHqSetup)(...args),
-        setActionTimeLock: (...args) => mutate(walletClient, mutation.setActionTimeLock)(...args),
-        setExpiration: (...args) => mutate(walletClient, mutation.setExpiration)(...args),
-        setActionTimeLockAfterSetup: (...args) => mutate(walletClient, mutation.setActionTimeLockAfterSetup)(...args),
-        pause: (...args) => mutate(walletClient, mutation.pause)(...args),
-        recoverFunds: (...args) => mutate(walletClient, mutation.recoverFunds)(...args),
-        recoverFundsMany: (...args) => mutate(walletClient, mutation.recoverFundsMany)(...args),
-        recoverNft: (...args) => mutate(walletClient, mutation.recoverNft)(...args),
-        claimLootForUser: (...args) => mutate(walletClient, mutation.claimLootForUser)(...args),
-        claimLootForManyUsers: (...args) => mutate(walletClient, mutation.claimLootForManyUsers)(...args),
-        adjustLoot: (...args) => mutate(walletClient, mutation.adjustLoot)(...args),
-        recoverDepositRewards: (...args) => mutate(walletClient, mutation.recoverDepositRewards)(...args),
-        updateDepositPoints: (...args) => mutate(walletClient, mutation.updateDepositPoints)(...args),
-        updateAssetData: (...args) => mutate(walletClient, mutation.updateAssetData)(...args),
-        updateAllAssetData: (...args) => mutate(walletClient, mutation.updateAllAssetData)(...args),
-        setEjectionMode: (...args) => mutate(walletClient, mutation.setEjectionMode)(...args),
-        executePendingAction: (...args) => mutate(walletClient, mutation.executePendingAction)(...args),
-        cancelPendingAction: (...args) => mutate(walletClient, mutation.cancelPendingAction)(...args),
+        startGovernanceChange: (...args) => mutate(walletClient, mutation.startGovernanceChange, { addressResolver })(...args),
+        confirmGovernanceChange: (...args) => mutate(walletClient, mutation.confirmGovernanceChange, { addressResolver })(...args),
+        cancelGovernanceChange: (...args) => mutate(walletClient, mutation.cancelGovernanceChange, { addressResolver })(...args),
+        relinquishGov: (...args) => mutate(walletClient, mutation.relinquishGov, { addressResolver })(...args),
+        setGovTimeLock: (...args) => mutate(walletClient, mutation.setGovTimeLock, { addressResolver })(...args),
+        finishUndyHqSetup: (...args) => mutate(walletClient, mutation.finishUndyHqSetup, { addressResolver })(...args),
+        setActionTimeLock: (...args) => mutate(walletClient, mutation.setActionTimeLock, { addressResolver })(...args),
+        setExpiration: (...args) => mutate(walletClient, mutation.setExpiration, { addressResolver })(...args),
+        setActionTimeLockAfterSetup: (...args) => mutate(walletClient, mutation.setActionTimeLockAfterSetup, { addressResolver })(...args),
+        pause: (...args) => mutate(walletClient, mutation.pause, { addressResolver })(...args),
+        recoverFunds: (...args) => mutate(walletClient, mutation.recoverFunds, { addressResolver })(...args),
+        recoverFundsMany: (...args) => mutate(walletClient, mutation.recoverFundsMany, { addressResolver })(...args),
+        recoverNft: (...args) => mutate(walletClient, mutation.recoverNft, { addressResolver })(...args),
+        claimLootForUser: (...args) => mutate(walletClient, mutation.claimLootForUser, { addressResolver })(...args),
+        claimLootForManyUsers: (...args) => mutate(walletClient, mutation.claimLootForManyUsers, { addressResolver })(...args),
+        adjustLoot: (...args) => mutate(walletClient, mutation.adjustLoot, { addressResolver })(...args),
+        recoverDepositRewards: (...args) => mutate(walletClient, mutation.recoverDepositRewards, { addressResolver })(...args),
+        updateDepositPoints: (...args) => mutate(walletClient, mutation.updateDepositPoints, { addressResolver })(...args),
+        updateAssetData: (...args) => mutate(walletClient, mutation.updateAssetData, { addressResolver })(...args),
+        updateAllAssetData: (...args) => mutate(walletClient, mutation.updateAllAssetData, { addressResolver })(...args),
+        setEjectionMode: (...args) => mutate(walletClient, mutation.setEjectionMode, { addressResolver })(...args),
+        executePendingAction: (...args) => mutate(walletClient, mutation.executePendingAction, { addressResolver })(...args),
+        cancelPendingAction: (...args) => mutate(walletClient, mutation.cancelPendingAction, { addressResolver })(...args),
     };
 }

package/dist/contracts/SwitchboardCharlie.d.ts

@@ -1,4 +1,5 @@
-import { PublicClient, WalletClient } from 'viem';
+import { AddressResolverFunction } from '@dappql/async';
+import { ParseEventLogsReturnType, Log, RpcLog, PublicClient, WalletClient } from 'viem';
 type ExtractArgs<T> = T extends (...args: infer P) => any ? P : never;
 type Address = `0x${string}`;
 export declare const abi: readonly [{
@@ -2826,9 +2827,257 @@ export declare const mutation: {
         argsType: ExtractArgs<Contract['mutations'][K]> | undefined;
     };
 };
+export type ParsedEvent<T extends keyof Contract['events']> = {
+    event: RpcLog | Log;
+    parsed: ParseEventLogsReturnType<typeof abi, T>;
+};
+export declare function parseEvents<T extends keyof Contract['events']>(eventName: T, events: (RpcLog | Log)[]): ParsedEvent<T>[];
+export declare function getEventTopic<T extends keyof Contract['events']>(eventName: T): Address;
 export type SDK = {
     deployAddress: Address | undefined;
     abi: typeof abi;
+    events: {
+        PendingRedemptionBufferChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingRedemptionBufferChange'>[];
+        };
+        RedemptionBufferSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'RedemptionBufferSet'>[];
+        };
+        PendingMinYieldWithdrawAmountChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingMinYieldWithdrawAmountChange'>[];
+        };
+        MinYieldWithdrawAmountSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'MinYieldWithdrawAmountSet'>[];
+        };
+        PendingSnapShotPriceConfigChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingSnapShotPriceConfigChange'>[];
+        };
+        SnapShotPriceConfigSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'SnapShotPriceConfigSet'>[];
+        };
+        PendingApprovedVaultTokenChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingApprovedVaultTokenChange'>[];
+        };
+        ApprovedVaultTokenSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'ApprovedVaultTokenSet'>[];
+        };
+        PendingApprovedVaultTokensChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingApprovedVaultTokensChange'>[];
+        };
+        ApprovedVaultTokensSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'ApprovedVaultTokensSet'>[];
+        };
+        PendingPerformanceFeeChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingPerformanceFeeChange'>[];
+        };
+        PerformanceFeeSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PerformanceFeeSet'>[];
+        };
+        PendingDefaultTargetVaultTokenChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingDefaultTargetVaultTokenChange'>[];
+        };
+        DefaultTargetVaultTokenSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'DefaultTargetVaultTokenSet'>[];
+        };
+        PendingMaxDepositAmountChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingMaxDepositAmountChange'>[];
+        };
+        MaxDepositAmountSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'MaxDepositAmountSet'>[];
+        };
+        PendingIsLeveragedVaultChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingIsLeveragedVaultChange'>[];
+        };
+        IsLeveragedVaultSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'IsLeveragedVaultSet'>[];
+        };
+        CanDepositSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'CanDepositSet'>[];
+        };
+        CanWithdrawSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'CanWithdrawSet'>[];
+        };
+        VaultOpsFrozenSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'VaultOpsFrozenSet'>[];
+        };
+        ShouldAutoDepositSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'ShouldAutoDepositSet'>[];
+        };
+        ShouldEnforceAllowlistSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'ShouldEnforceAllowlistSet'>[];
+        };
+        AllowlistUserSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'AllowlistUserSet'>[];
+        };
+        AllowlistBatchSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'AllowlistBatchSet'>[];
+        };
+        PendingCollateralVaultChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingCollateralVaultChange'>[];
+        };
+        CollateralVaultSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'CollateralVaultSet'>[];
+        };
+        PendingLeverageVaultChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingLeverageVaultChange'>[];
+        };
+        LeverageVaultSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'LeverageVaultSet'>[];
+        };
+        PendingSlippagesChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingSlippagesChange'>[];
+        };
+        SlippagesSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'SlippagesSet'>[];
+        };
+        PendingLevgVaultHelperChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingLevgVaultHelperChange'>[];
+        };
+        LevgVaultHelperSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'LevgVaultHelperSet'>[];
+        };
+        PendingMaxDebtRatioChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingMaxDebtRatioChange'>[];
+        };
+        MaxDebtRatioSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'MaxDebtRatioSet'>[];
+        };
+        PendingAddManagerChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingAddManagerChange'>[];
+        };
+        ManagerAdded: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'ManagerAdded'>[];
+        };
+        PendingRemoveManagerChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingRemoveManagerChange'>[];
+        };
+        ManagerRemoved: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'ManagerRemoved'>[];
+        };
+        PriceSnapshotAdded: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PriceSnapshotAdded'>[];
+        };
+        YieldPositionUpdated: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'YieldPositionUpdated'>[];
+        };
+        PerformanceFeesClaimed: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PerformanceFeesClaimed'>[];
+        };
+        PendingRegisterVaultTokenOnLegoChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingRegisterVaultTokenOnLegoChange'>[];
+        };
+        VaultTokenRegisteredOnLego: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'VaultTokenRegisteredOnLego'>[];
+        };
+        VaultTokenDeregisteredOnLego: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'VaultTokenDeregisteredOnLego'>[];
+        };
+        PendingMorphoRewardsAddrChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingMorphoRewardsAddrChange'>[];
+        };
+        MorphoRewardsAddrSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'MorphoRewardsAddrSet'>[];
+        };
+        PendingEulerRewardsAddrChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingEulerRewardsAddrChange'>[];
+        };
+        EulerRewardsAddrSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'EulerRewardsAddrSet'>[];
+        };
+        PendingCompRewardsAddrChange: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'PendingCompRewardsAddrChange'>[];
+        };
+        CompRewardsAddrSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'CompRewardsAddrSet'>[];
+        };
+        LeftoversSwept: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'LeftoversSwept'>[];
+        };
+        GovChangeTimeLockModified: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'GovChangeTimeLockModified'>[];
+        };
+        ExpirationSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'ExpirationSet'>[];
+        };
+        ActionTimeLockSet: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'ActionTimeLockSet'>[];
+        };
+        GovChangeStarted: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'GovChangeStarted'>[];
+        };
+        GovChangeConfirmed: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'GovChangeConfirmed'>[];
+        };
+        GovChangeCancelled: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'GovChangeCancelled'>[];
+        };
+        GovRelinquished: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'GovRelinquished'>[];
+        };
+        UndyHqSetupFinished: {
+            topic: Address;
+            parse: (events: (RpcLog | Log)[]) => ParsedEvent<'UndyHqSetupFinished'>[];
+        };
+    };
     getAddys: (...args: ExtractArgs<Contract['calls']['getAddys']>) => Promise<CallReturn<'getAddys'>>;
     getUndyHq: (...args: ExtractArgs<Contract['calls']['getUndyHq']>) => Promise<CallReturn<'getUndyHq'>>;
     getUndyHqFromGov: (...args: ExtractArgs<Contract['calls']['getUndyHqFromGov']>) => Promise<CallReturn<'getUndyHqFromGov'>>;
@@ -2918,6 +3167,6 @@ export type SDK = {
     executePendingAction: (...args: ExtractArgs<Contract['mutations']['executePendingAction']>) => Promise<Address>;
     cancelPendingAction: (...args: ExtractArgs<Contract['mutations']['cancelPendingAction']>) => Promise<Address>;
 };
-export declare function toSdk(publicClient?: PublicClient, walletClient?: WalletClient): SDK;
+export declare function toSdk(publicClient?: PublicClient, walletClient?: WalletClient, addressResolver?: AddressResolverFunction): SDK;
 export {};
 //# sourceMappingURL=SwitchboardCharlie.d.ts.map