@superfluid-finance/sdk-core 1.0.1-dev.c4f51ea.0

package/dist/main/typechain/factories/ERC20WithTokenInfo__factory.d.ts

@@ -0,0 +1,35 @@
+import { Signer } from "ethers";
+import { Provider } from "@ethersproject/providers";
+import type { ERC20WithTokenInfo, ERC20WithTokenInfoInterface } from "../ERC20WithTokenInfo";
+export declare class ERC20WithTokenInfo__factory {
+    static readonly abi: ({
+        anonymous: boolean;
+        inputs: {
+            indexed: boolean;
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        outputs?: undefined;
+        stateMutability?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    })[];
+    static createInterface(): ERC20WithTokenInfoInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): ERC20WithTokenInfo;
+}

package/dist/main/typechain/factories/IConstantFlowAgreementV1__factory.d.ts

@@ -0,0 +1,35 @@
+import { Signer } from "ethers";
+import { Provider } from "@ethersproject/providers";
+import type { IConstantFlowAgreementV1, IConstantFlowAgreementV1Interface } from "../IConstantFlowAgreementV1";
+export declare class IConstantFlowAgreementV1__factory {
+    static readonly abi: ({
+        anonymous: boolean;
+        inputs: {
+            indexed: boolean;
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        outputs?: undefined;
+        stateMutability?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    })[];
+    static createInterface(): IConstantFlowAgreementV1Interface;
+    static connect(address: string, signerOrProvider: Signer | Provider): IConstantFlowAgreementV1;
+}

package/dist/main/typechain/factories/IInstantDistributionAgreementV1__factory.d.ts

@@ -0,0 +1,35 @@
+import { Signer } from "ethers";
+import { Provider } from "@ethersproject/providers";
+import type { IInstantDistributionAgreementV1, IInstantDistributionAgreementV1Interface } from "../IInstantDistributionAgreementV1";
+export declare class IInstantDistributionAgreementV1__factory {
+    static readonly abi: ({
+        anonymous: boolean;
+        inputs: {
+            indexed: boolean;
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        outputs?: undefined;
+        stateMutability?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    })[];
+    static createInterface(): IInstantDistributionAgreementV1Interface;
+    static connect(address: string, signerOrProvider: Signer | Provider): IInstantDistributionAgreementV1;
+}

package/dist/main/typechain/factories/IResolver__factory.d.ts

@@ -0,0 +1,22 @@
+import { Signer } from "ethers";
+import { Provider } from "@ethersproject/providers";
+import type { IResolver, IResolverInterface } from "../IResolver";
+export declare class IResolver__factory {
+    static readonly abi: {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+    }[];
+    static createInterface(): IResolverInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): IResolver;
+}

package/dist/main/typechain/factories/SuperToken__factory.d.ts

@@ -0,0 +1,46 @@
+import { Signer } from "ethers";
+import { Provider } from "@ethersproject/providers";
+import type { SuperToken, SuperTokenInterface } from "../SuperToken";
+export declare class SuperToken__factory {
+    static readonly abi: ({
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+        name?: undefined;
+        outputs?: undefined;
+    } | {
+        anonymous: boolean;
+        inputs: {
+            indexed: boolean;
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    })[];
+    static createInterface(): SuperTokenInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): SuperToken;
+}

package/dist/main/typechain/factories/SuperfluidLoader__factory.d.ts

@@ -0,0 +1,37 @@
+import { Signer } from "ethers";
+import { Provider } from "@ethersproject/providers";
+import type { SuperfluidLoader, SuperfluidLoaderInterface } from "../SuperfluidLoader";
+export declare class SuperfluidLoader__factory {
+    static readonly abi: ({
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        name?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            components: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+    })[];
+    static createInterface(): SuperfluidLoaderInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): SuperfluidLoader;
+}

package/dist/main/typechain/factories/Superfluid__factory.d.ts

@@ -0,0 +1,82 @@
+import { Signer } from "ethers";
+import { Provider } from "@ethersproject/providers";
+import type { Superfluid, SuperfluidInterface } from "../Superfluid";
+export declare class Superfluid__factory {
+    static readonly abi: ({
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+        name?: undefined;
+        outputs?: undefined;
+    } | {
+        anonymous: boolean;
+        inputs: {
+            indexed: boolean;
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            components: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    } | {
+        inputs: {
+            components: {
+                internalType: string;
+                name: string;
+                type: string;
+            }[];
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: never[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    })[];
+    static createInterface(): SuperfluidInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): Superfluid;
+}

package/dist/main/typechain/factories/TestToken__factory.d.ts

@@ -0,0 +1,46 @@
+import { Signer } from "ethers";
+import { Provider } from "@ethersproject/providers";
+import type { TestToken, TestTokenInterface } from "../TestToken";
+export declare class TestToken__factory {
+    static readonly abi: ({
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+        name?: undefined;
+        outputs?: undefined;
+    } | {
+        anonymous: boolean;
+        inputs: {
+            indexed: boolean;
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        type: string;
+        stateMutability?: undefined;
+        outputs?: undefined;
+    } | {
+        inputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        name: string;
+        outputs: {
+            internalType: string;
+            name: string;
+            type: string;
+        }[];
+        stateMutability: string;
+        type: string;
+        anonymous?: undefined;
+    })[];
+    static createInterface(): TestTokenInterface;
+    static connect(address: string, signerOrProvider: Signer | Provider): TestToken;
+}

package/dist/main/typechain/index.d.ts

@@ -0,0 +1,16 @@
+export type { ERC20WithTokenInfo } from "./ERC20WithTokenInfo";
+export type { IConstantFlowAgreementV1 } from "./IConstantFlowAgreementV1";
+export type { IInstantDistributionAgreementV1 } from "./IInstantDistributionAgreementV1";
+export type { IResolver } from "./IResolver";
+export type { Superfluid } from "./Superfluid";
+export type { SuperfluidLoader } from "./SuperfluidLoader";
+export type { SuperToken } from "./SuperToken";
+export type { TestToken } from "./TestToken";
+export { ERC20WithTokenInfo__factory } from "./factories/ERC20WithTokenInfo__factory";
+export { IConstantFlowAgreementV1__factory } from "./factories/IConstantFlowAgreementV1__factory";
+export { IInstantDistributionAgreementV1__factory } from "./factories/IInstantDistributionAgreementV1__factory";
+export { IResolver__factory } from "./factories/IResolver__factory";
+export { Superfluid__factory } from "./factories/Superfluid__factory";
+export { SuperfluidLoader__factory } from "./factories/SuperfluidLoader__factory";
+export { SuperToken__factory } from "./factories/SuperToken__factory";
+export { TestToken__factory } from "./factories/TestToken__factory";

package/dist/main/types.d.ts

@@ -0,0 +1,2 @@
+export declare type DataMode = "SUBGRAPH_ONLY" | "SUBGRAPH_WEB3" | "WEB3_ONLY";
+export declare type FlowActionType = 0 | 1 | 2;

package/dist/main/utils.d.ts

@@ -0,0 +1,89 @@
+import { JsonFragment } from "@ethersproject/abi";
+import { ethers } from "ethers";
+import { IIndexSubscription } from "./interfaces";
+/**
+ * @dev Checks if address is a valid ethereum address and normalizes so it can be used by both subgraph and web3.
+ * @param address
+ * @returns The normalized address.
+ */
+export declare const normalizeAddress: (address?: string | undefined) => string;
+export declare const isNullOrEmpty: (str: string | null | undefined) => boolean;
+/**
+ * @dev Removes the 8-character signature hash from `callData`.
+ * @param callData
+ * @returns function parameters
+ */
+export declare const removeSigHashFromCallData: (callData: string) => string;
+/**
+ * @dev A wrapper function for getting the ethers TransactionDescription object given fragments (e.g. ABI), callData and the value amount sent.
+ * @param fragments ABI
+ * @param data callData of a function
+ * @param value amount of ether sent
+ * @returns ethers.TransactionDescription object
+ */
+export declare const getTransactionDescription: (fragments: string | readonly (string | ethers.utils.Fragment | JsonFragment)[], data: string, value?: string | undefined) => ethers.utils.TransactionDescription;
+/**
+ * @dev Gets the per second flow rate given an `amountPerYear` value.
+ * @param amountPerYear the amount you want to stream per year
+ * @returns flow rate per second
+ */
+export declare const getPerSecondFlowRateByYear: (amountPerYear: string) => string;
+/**
+ * @dev Gets the per second flow rate given an `amountPerMonth` value.
+ * @param amountPerMonth the amount you want to stream per month
+ * @returns flow rate per second
+ */
+export declare const getPerSecondFlowRateByMonth: (amountPerMonth: string) => string;
+/**
+ * @dev Gets the per second flow rate given an `amountPerDay` value.
+ * @param amountPerDay the amount you want to stream per day
+ * @returns flow rate per second
+ */
+export declare const getPerSecondFlowRateByDay: (amountPerDay: string) => string;
+/**
+ * @dev The formula for calculating the flowed amount since updated using Subgraph data.
+ * @param netFlowRate the net flow rate of the user
+ * @param currentTimestamp the current timestamp
+ * @param updatedAtTimestamp the updated at timestamp of the `AccountTokenSnapshot` entity
+ * @returns the flowed amount since the updatedAt timestamp
+ */
+export declare const flowedAmountSinceUpdatedAt: ({ netFlowRate, currentTimestamp, updatedAtTimestamp, }: {
+    netFlowRate: string;
+    currentTimestamp: string;
+    updatedAtTimestamp: string;
+}) => number;
+/**
+ * @dev The formula for calculating the total amount distributed to the subscriber (pending or received).
+ * @param indexSubscriptions the index subscriptions of a single token from an account.
+ * @returns the total amount received since updated at (both pending and actually distributed)
+ */
+export declare const subscriptionTotalAmountDistributedSinceUpdated: (indexSubscriptions: IIndexSubscription[]) => number;
+/**
+ * @dev The formula for calculating the total amount received (approved subscriptions).
+ * @param indexSubscriptions the index subscriptions of a single token from an account.
+ * @returns the total amount received since updated at (actually distributed into wallet)
+ */
+export declare const subscriptionTotalAmountReceivedSinceUpdated: (indexSubscriptions: IIndexSubscription[]) => number;
+/**
+ * @dev The formula for calculating the total amount that is claimable.
+ * @param indexSubscriptions the index subscriptions of a single token from an account.
+ * @returns the total amount that can be claimed since updated at
+ */
+export declare const subscriptionTotalAmountClaimableSinceUpdatedAt: (indexSubscriptions: IIndexSubscription[]) => number;
+export declare const getStringCurrentTimeInSeconds: () => number;
+export declare const getSanitizedTimestamp: (timestamp: ethers.BigNumberish) => Date;
+/**
+ * @dev The formula for calculating the balance until updated at of a user (claimable + received tokens from index)
+ * @param currentBalance the current balance until updated at from the `AccountTokenSnapshot` entity
+ * @param netFlowRate the net flow rate of the user
+ * @param currentTimestamp the current timestamp
+ * @param updatedAtTimestamp the updated at timestamp of the `AccountTokenSnapshot` entity
+ * @returns the balance since the updated at timestamp
+ */
+export declare const getBalance: ({ currentBalance, netFlowRate, currentTimestamp, updatedAtTimestamp, indexSubscriptions, }: {
+    currentBalance: string;
+    netFlowRate: string;
+    currentTimestamp: string;
+    updatedAtTimestamp: string;
+    indexSubscriptions: IIndexSubscription[];
+}) => number;

package/dist/main/validation.d.ts

@@ -0,0 +1,8 @@
+import { IEventFilter } from ".";
+import { IAccountTokenSnapshotFilter, IIndexRequestFilter, IIndexSubscriptionRequestFilter, IStreamRequestFilter, ISuperTokenRequestFilter } from "./interfaces";
+export declare const validateSuperTokenRequest: (filter: ISuperTokenRequestFilter) => void;
+export declare const validateEventRequest: (filter: IEventFilter) => void;
+export declare const validateIndexRequest: (filter: IIndexRequestFilter) => void;
+export declare const validateIndexSubscriptionRequest: (filter: IIndexSubscriptionRequestFilter) => void;
+export declare const validateStreamRequest: (filter: IStreamRequestFilter) => void;
+export declare const validateAccountTokenSnapshotRequest: (filter: IAccountTokenSnapshotFilter) => void;

package/dist/module/BatchCall.d.ts

@@ -0,0 +1,53 @@
+import { ethers } from "ethers";
+import Host from "./Host";
+import { IConfig } from "./interfaces";
+import Operation from "./Operation";
+interface IBatchCallOptions {
+    config: IConfig;
+    operations: ReadonlyArray<Operation>;
+}
+interface OperationStruct {
+    readonly operationType: number;
+    readonly target: string;
+    readonly data: string;
+}
+/**
+ * @dev BatchCall Helper Class
+ * @description A helper class to create `BatchCall` objects which can be executed.
+ */
+export default class BatchCall {
+    options: IBatchCallOptions;
+    host: Host;
+    constructor(options: IBatchCallOptions);
+    /**
+     * @dev Gets the call agreement function arguments.
+     * @param callData callData of the function
+     * @returns {ethers.utils.Result} call agreement function arguments
+     */
+    getCallAgreementFunctionArgs: (callData: string) => ethers.utils.Result;
+    /**
+     * @dev Given an `Operation` object, gets the `OperationStruct` object.
+     * @param operation an `Operation` object
+     * @param index the index of the `Operation` in the batchCall
+     * @returns {Promise<OperationStruct>} OperationStruct object for batchCall
+     */
+    getOperationStruct: (operation: Operation, index: number) => Promise<OperationStruct>;
+    /**
+     * @dev Gets an array of `OperationStruct` objects to be passed to batchCall.
+     * @returns {Promise<OperationStruct>[]} array of operation struct promises
+     */
+    get getOperationStructArrayPromises(): Promise<OperationStruct>[];
+    /**
+     * @dev Executes a batch call given the operations on this class.
+     * @param signer the signer of the transaction
+     * @returns {Promise<ethers.ContractTransaction>} ContractTransaction object
+     */
+    exec: (signer: ethers.Signer) => Promise<ethers.ContractTransaction>;
+    /**
+     * @dev Executes a forward batch call given the operations on this class.
+     * @param signer the signer of the transaction
+     * @returns {Promise<ethers.ContractTransaction>} ContractTransaction object
+     */
+    execForward: (signer: ethers.Signer) => Promise<ethers.ContractTransaction>;
+}
+export {};

package/dist/module/ConstantFlowAgreementV1.d.ts

@@ -0,0 +1,74 @@
+import { IAgreementV1Options, ICreateFlowParams, IDeleteFlowParams, IUpdateFlowParams, IGetFlowParams, IGetAccountFlowInfoParams, IWeb3FlowInfoParams, IWeb3FlowInfo } from "./interfaces";
+import Operation from "./Operation";
+import Host from "./Host";
+/**
+ * @dev Constant Flow Agreement V1 Helper Class
+ * @description A helper class to interact with the CFAV1 contract.
+ */
+export default class ConstantFlowAgreementV1 {
+    readonly options: IAgreementV1Options;
+    readonly host: Host;
+    constructor(options: IAgreementV1Options);
+    private get cfaContract();
+    /**
+     * @dev Get the details of a flow.
+     * @param superToken the superToken of the agreement
+     * @param sender the sender of the flow
+     * @param receiver the receiver of the flow
+     * @param providerOrSigner a provider or signer object
+     * @returns {Promise<IWeb3FlowInfo>} Web3 Flow info object
+     */
+    getFlow: ({ superToken, sender, receiver, providerOrSigner, }: IGetFlowParams) => Promise<IWeb3FlowInfo>;
+    /**
+     * @dev Get the flow info of an account (net flow).
+     * @param superToken the superToken of the agreement
+     * @param account the account we're querying
+     * @param providerOrSigner a provider or signer object
+     * @returns {Promise<IWeb3FlowInfo>} Web3 Flow info object
+     */
+    getAccountFlowInfo: ({ superToken, account, providerOrSigner, }: IGetAccountFlowInfoParams) => Promise<IWeb3FlowInfo>;
+    /**
+     * @dev Get the net flow of an account.
+     * @param superToken the superToken of the agreement
+     * @param account the account we're querying
+     * @param providerOrSigner a provider or signer object
+     * @returns {Promise<string>} Web3 Flow info object
+     */
+    getNetFlow: ({ superToken, account, providerOrSigner, }: IGetAccountFlowInfoParams) => Promise<string>;
+    /**
+     * @dev Create a flow.
+     * @param flowRate The specified flow rate.
+     * @param receiver The receiver of the flow.
+     * @param superToken The token to be flowed.
+     * @param userData Extra user data provided.
+     * @returns {Operation} An instance of Operation which can be executed or batched.
+     */
+    createFlow: ({ flowRate, receiver, superToken, userData, }: ICreateFlowParams) => Operation;
+    /**
+     * @dev Update a flow.
+     * @param flowRate The specified flow rate.
+     * @param receiver The receiver of the flow.
+     * @param superToken The token to be flowed.
+     * @param userData Extra user data provided.
+     * @returns {Operation} An instance of Operation which can be executed or batched.
+     */
+    updateFlow: ({ flowRate, receiver, superToken, userData, }: IUpdateFlowParams) => Operation;
+    /**
+     * @dev Delete a flow.
+     * @param superToken The token to be flowed.
+     * @param sender The sender of the flow.
+     * @param receiver The receiver of the flow.
+     * @param userData Extra user data provided.
+     * @returns {Operation} An instance of Operation which can be executed or batched.
+     */
+    deleteFlow: ({ superToken, sender, receiver, userData, }: IDeleteFlowParams) => Operation;
+    /**
+     * @dev Sanitizes flow info, converting BigNumber to string.
+     * @param timestamp last updated timestamp of flow
+     * @param flowRate the current flow rate
+     * @param deposit the deposit amount
+     * @param owedDeposit any owed depsit
+     * @returns {IWeb3FlowInfo} sanitized web3 flow info
+     */
+    _sanitizeflowInfo: ({ timestamp, flowRate, deposit, owedDeposit, }: IWeb3FlowInfoParams) => IWeb3FlowInfo;
+}

package/dist/module/Framework.d.ts

@@ -0,0 +1,75 @@
+import { ethers } from "ethers";
+import { Signer } from "@ethersproject/abstract-signer";
+import { IConfig, ISignerConstructorOptions } from "./interfaces";
+import { DataMode } from "./types";
+import BatchCall from "./BatchCall";
+import ConstantFlowAgreementV1 from "./ConstantFlowAgreementV1";
+import Host from "./Host";
+import InstantDistributionAgreementV1 from "./InstantDistributionAgreementV1";
+import SuperToken from "./SuperToken";
+import Query from "./Query";
+import Operation from "./Operation";
+export interface IFrameworkOptions {
+    chainId?: number;
+    customSubgraphQueriesEndpoint?: string;
+    dataMode?: DataMode;
+    networkName?: string;
+    resolverAddress?: string;
+    protocolReleaseVersion?: string;
+    provider: ethers.providers.Provider;
+}
+export interface IFrameworkSettings {
+    chainId: number;
+    customSubgraphQueriesEndpoint: string;
+    dataMode: DataMode;
+    networkName: string;
+    protocolReleaseVersion: string;
+    provider: ethers.providers.Provider;
+    config: IConfig;
+}
+/**
+ * @dev Superfluid Framework Class
+ * @description The entrypoint for the SDK-core, `create` an instance of this for full functionality.
+ */
+export default class Framework {
+    readonly userInputOptions: IFrameworkOptions;
+    settings: IFrameworkSettings;
+    cfaV1: ConstantFlowAgreementV1;
+    host: Host;
+    idaV1: InstantDistributionAgreementV1;
+    query: Query;
+    private constructor();
+    /**
+     * @dev Creates the Framework object based on user provided `options`.
+     * @param options.chainId the chainId of your desired network (e.g. 137 = matic)
+     * @param options.customSubgraphQueriesEndpoint your custom subgraph endpoint
+     * @param options.dataMode the data mode you'd like the framework to use (SUBGRAPH_ONLY, SUBGRAPH_WEB3, WEB3_ONLY)
+     * @param options.networkName the desired network (e.g. "matic", "rinkeby", etc.)
+     * @param options.resolverAddress a custom resolver address (advanced use for testing)
+     * @param options.protocolReleaseVersion a custom release version (advanced use for testing)
+     * @param options.provider a provider object necessary for initializing the framework
+     * @returns `Framework` class
+     */
+    static create: (options: IFrameworkOptions) => Promise<Framework>;
+    /**
+     * @dev Create a signer which can be used to sign transactions.
+     * @param options.web3Provider a Web3Provider object (e.g. client side - metamask, web3modal)
+     * @param options.provider an ethers Provider object (e.g. via Hardhat ethers)
+     * @param options.privateKey a test account private key
+     * @param options.signer a signer object (e.g. ethers.Wallet instance)
+     * @returns `ethers.Signer` object
+     */
+    createSigner: (options: ISignerConstructorOptions) => Signer;
+    /**
+     * @dev Create a `BatchCall` class from the `Framework`.
+     * @param operations the list of operations to execute
+     * @returns `BatchCall` class
+     */
+    batchCall: (operations: Operation[]) => BatchCall;
+    /**
+     * @dev Load a `SuperToken` class from the `Framework`.
+     * @param address the `SuperToken` address
+     * @returns `SuperToken` class
+     */
+    loadSuperToken: (address: string) => Promise<SuperToken>;
+}