@kasufinance/kasu-sdk 1.0.1

package/dist/contracts/KasuPoolExternalTVLAbi.d.ts

@@ -0,0 +1,411 @@
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
+export interface KasuPoolExternalTVLAbiInterface extends utils.Interface {
+    functions: {
+        "balanceOf(address,uint256)": FunctionFragment;
+        "balanceOfBatch(address[],uint256[])": FunctionFragment;
+        "burn(address,uint256,uint256)": FunctionFragment;
+        "burnBatch(address,uint256[],uint256[])": FunctionFragment;
+        "burnExternalTVL(address,uint256)": FunctionFragment;
+        "exists(uint256)": FunctionFragment;
+        "externalTVLOfPool(address)": FunctionFragment;
+        "initialize(string)": FunctionFragment;
+        "isApprovedForAll(address,address)": FunctionFragment;
+        "mintExternalTVL(address,uint256)": FunctionFragment;
+        "onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)": FunctionFragment;
+        "onERC1155Received(address,address,uint256,uint256,bytes)": FunctionFragment;
+        "poolId(address)": FunctionFragment;
+        "safeBatchTransferFrom(address,address,uint256[],uint256[],bytes)": FunctionFragment;
+        "safeTransferFrom(address,address,uint256,uint256,bytes)": FunctionFragment;
+        "setApprovalForAll(address,bool)": FunctionFragment;
+        "setExternalTVL(address,uint256)": FunctionFragment;
+        "setExternalTVLBatch(address[],uint256[])": FunctionFragment;
+        "setURI(string)": FunctionFragment;
+        "supportsInterface(bytes4)": FunctionFragment;
+        "totalSupply()": FunctionFragment;
+        "totalSupply(uint256)": FunctionFragment;
+        "uri(uint256)": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "balanceOf" | "balanceOfBatch" | "burn" | "burnBatch" | "burnExternalTVL" | "exists" | "externalTVLOfPool" | "initialize" | "isApprovedForAll" | "mintExternalTVL" | "onERC1155BatchReceived" | "onERC1155Received" | "poolId" | "safeBatchTransferFrom" | "safeTransferFrom" | "setApprovalForAll" | "setExternalTVL" | "setExternalTVLBatch" | "setURI" | "supportsInterface" | "totalSupply()" | "totalSupply(uint256)" | "uri"): FunctionFragment;
+    encodeFunctionData(functionFragment: "balanceOf", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "balanceOfBatch", values: [string[], BigNumberish[]]): string;
+    encodeFunctionData(functionFragment: "burn", values: [string, BigNumberish, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "burnBatch", values: [string, BigNumberish[], BigNumberish[]]): string;
+    encodeFunctionData(functionFragment: "burnExternalTVL", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "exists", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "externalTVLOfPool", values: [string]): string;
+    encodeFunctionData(functionFragment: "initialize", values: [string]): string;
+    encodeFunctionData(functionFragment: "isApprovedForAll", values: [string, string]): string;
+    encodeFunctionData(functionFragment: "mintExternalTVL", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "onERC1155BatchReceived", values: [string, string, BigNumberish[], BigNumberish[], BytesLike]): string;
+    encodeFunctionData(functionFragment: "onERC1155Received", values: [string, string, BigNumberish, BigNumberish, BytesLike]): string;
+    encodeFunctionData(functionFragment: "poolId", values: [string]): string;
+    encodeFunctionData(functionFragment: "safeBatchTransferFrom", values: [string, string, BigNumberish[], BigNumberish[], BytesLike]): string;
+    encodeFunctionData(functionFragment: "safeTransferFrom", values: [string, string, BigNumberish, BigNumberish, BytesLike]): string;
+    encodeFunctionData(functionFragment: "setApprovalForAll", values: [string, boolean]): string;
+    encodeFunctionData(functionFragment: "setExternalTVL", values: [string, BigNumberish]): string;
+    encodeFunctionData(functionFragment: "setExternalTVLBatch", values: [string[], BigNumberish[]]): string;
+    encodeFunctionData(functionFragment: "setURI", values: [string]): string;
+    encodeFunctionData(functionFragment: "supportsInterface", values: [BytesLike]): string;
+    encodeFunctionData(functionFragment: "totalSupply()", values?: undefined): string;
+    encodeFunctionData(functionFragment: "totalSupply(uint256)", values: [BigNumberish]): string;
+    encodeFunctionData(functionFragment: "uri", values: [BigNumberish]): string;
+    decodeFunctionResult(functionFragment: "balanceOf", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "balanceOfBatch", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "burn", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "burnBatch", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "burnExternalTVL", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "exists", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "externalTVLOfPool", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "isApprovedForAll", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "mintExternalTVL", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "onERC1155BatchReceived", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "onERC1155Received", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "poolId", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "safeBatchTransferFrom", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "safeTransferFrom", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setApprovalForAll", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setExternalTVL", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setExternalTVLBatch", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setURI", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "supportsInterface", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply()", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "totalSupply(uint256)", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "uri", data: BytesLike): Result;
+    events: {
+        "ApprovalForAll(address,address,bool)": EventFragment;
+        "ExternalTVLSet(address,uint256,uint256)": EventFragment;
+        "Initialized(uint64)": EventFragment;
+        "TransferBatch(address,address,address,uint256[],uint256[])": EventFragment;
+        "TransferSingle(address,address,address,uint256,uint256)": EventFragment;
+        "URI(string,uint256)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "ApprovalForAll"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "ExternalTVLSet"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TransferBatch"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "TransferSingle"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "URI"): EventFragment;
+}
+export interface ApprovalForAllEventObject {
+    account: string;
+    operator: string;
+    approved: boolean;
+}
+export type ApprovalForAllEvent = TypedEvent<[
+    string,
+    string,
+    boolean
+], ApprovalForAllEventObject>;
+export type ApprovalForAllEventFilter = TypedEventFilter<ApprovalForAllEvent>;
+export interface ExternalTVLSetEventObject {
+    pool: string;
+    oldAmount: BigNumber;
+    newAmount: BigNumber;
+}
+export type ExternalTVLSetEvent = TypedEvent<[
+    string,
+    BigNumber,
+    BigNumber
+], ExternalTVLSetEventObject>;
+export type ExternalTVLSetEventFilter = TypedEventFilter<ExternalTVLSetEvent>;
+export interface InitializedEventObject {
+    version: BigNumber;
+}
+export type InitializedEvent = TypedEvent<[BigNumber], InitializedEventObject>;
+export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
+export interface TransferBatchEventObject {
+    operator: string;
+    from: string;
+    to: string;
+    ids: BigNumber[];
+    values: BigNumber[];
+}
+export type TransferBatchEvent = TypedEvent<[
+    string,
+    string,
+    string,
+    BigNumber[],
+    BigNumber[]
+], TransferBatchEventObject>;
+export type TransferBatchEventFilter = TypedEventFilter<TransferBatchEvent>;
+export interface TransferSingleEventObject {
+    operator: string;
+    from: string;
+    to: string;
+    id: BigNumber;
+    value: BigNumber;
+}
+export type TransferSingleEvent = TypedEvent<[
+    string,
+    string,
+    string,
+    BigNumber,
+    BigNumber
+], TransferSingleEventObject>;
+export type TransferSingleEventFilter = TypedEventFilter<TransferSingleEvent>;
+export interface URIEventObject {
+    value: string;
+    id: BigNumber;
+}
+export type URIEvent = TypedEvent<[string, BigNumber], URIEventObject>;
+export type URIEventFilter = TypedEventFilter<URIEvent>;
+export interface KasuPoolExternalTVLAbi extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: KasuPoolExternalTVLAbiInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        balanceOf(account: string, id: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
+        balanceOfBatch(accounts: string[], ids: BigNumberish[], overrides?: CallOverrides): Promise<[BigNumber[]]>;
+        burn(account: string, id: BigNumberish, value: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        burnBatch(account: string, ids: BigNumberish[], values: BigNumberish[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        burnExternalTVL(pool: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        exists(id: BigNumberish, overrides?: CallOverrides): Promise<[boolean]>;
+        externalTVLOfPool(pool: string, overrides?: CallOverrides): Promise<[BigNumber]>;
+        initialize(baseURI_: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        isApprovedForAll(account: string, operator: string, overrides?: CallOverrides): Promise<[boolean]>;
+        mintExternalTVL(pool: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        onERC1155BatchReceived(arg0: string, arg1: string, arg2: BigNumberish[], arg3: BigNumberish[], arg4: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        onERC1155Received(arg0: string, arg1: string, arg2: BigNumberish, arg3: BigNumberish, arg4: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        poolId(pool: string, overrides?: CallOverrides): Promise<[BigNumber]>;
+        safeBatchTransferFrom(from: string, to: string, ids: BigNumberish[], values: BigNumberish[], data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        safeTransferFrom(from: string, to: string, id: BigNumberish, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        setApprovalForAll(operator: string, approved: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        setExternalTVL(pool: string, targetAmount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        setExternalTVLBatch(pools: string[], targetAmounts: BigNumberish[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        setURI(newURI: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<[boolean]>;
+        "totalSupply()"(overrides?: CallOverrides): Promise<[BigNumber]>;
+        "totalSupply(uint256)"(id: BigNumberish, overrides?: CallOverrides): Promise<[BigNumber]>;
+        uri(arg0: BigNumberish, overrides?: CallOverrides): Promise<[string]>;
+    };
+    balanceOf(account: string, id: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+    balanceOfBatch(accounts: string[], ids: BigNumberish[], overrides?: CallOverrides): Promise<BigNumber[]>;
+    burn(account: string, id: BigNumberish, value: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    burnBatch(account: string, ids: BigNumberish[], values: BigNumberish[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    burnExternalTVL(pool: string, amount: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    exists(id: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
+    externalTVLOfPool(pool: string, overrides?: CallOverrides): Promise<BigNumber>;
+    initialize(baseURI_: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    isApprovedForAll(account: string, operator: string, overrides?: CallOverrides): Promise<boolean>;
+    mintExternalTVL(pool: string, amount: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    onERC1155BatchReceived(arg0: string, arg1: string, arg2: BigNumberish[], arg3: BigNumberish[], arg4: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    onERC1155Received(arg0: string, arg1: string, arg2: BigNumberish, arg3: BigNumberish, arg4: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    poolId(pool: string, overrides?: CallOverrides): Promise<BigNumber>;
+    safeBatchTransferFrom(from: string, to: string, ids: BigNumberish[], values: BigNumberish[], data: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    safeTransferFrom(from: string, to: string, id: BigNumberish, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    setApprovalForAll(operator: string, approved: boolean, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    setExternalTVL(pool: string, targetAmount: BigNumberish, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    setExternalTVLBatch(pools: string[], targetAmounts: BigNumberish[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    setURI(newURI: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<boolean>;
+    "totalSupply()"(overrides?: CallOverrides): Promise<BigNumber>;
+    "totalSupply(uint256)"(id: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+    uri(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        balanceOf(account: string, id: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        balanceOfBatch(accounts: string[], ids: BigNumberish[], overrides?: CallOverrides): Promise<BigNumber[]>;
+        burn(account: string, id: BigNumberish, value: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        burnBatch(account: string, ids: BigNumberish[], values: BigNumberish[], overrides?: CallOverrides): Promise<void>;
+        burnExternalTVL(pool: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        exists(id: BigNumberish, overrides?: CallOverrides): Promise<boolean>;
+        externalTVLOfPool(pool: string, overrides?: CallOverrides): Promise<BigNumber>;
+        initialize(baseURI_: string, overrides?: CallOverrides): Promise<void>;
+        isApprovedForAll(account: string, operator: string, overrides?: CallOverrides): Promise<boolean>;
+        mintExternalTVL(pool: string, amount: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        onERC1155BatchReceived(arg0: string, arg1: string, arg2: BigNumberish[], arg3: BigNumberish[], arg4: BytesLike, overrides?: CallOverrides): Promise<string>;
+        onERC1155Received(arg0: string, arg1: string, arg2: BigNumberish, arg3: BigNumberish, arg4: BytesLike, overrides?: CallOverrides): Promise<string>;
+        poolId(pool: string, overrides?: CallOverrides): Promise<BigNumber>;
+        safeBatchTransferFrom(from: string, to: string, ids: BigNumberish[], values: BigNumberish[], data: BytesLike, overrides?: CallOverrides): Promise<void>;
+        safeTransferFrom(from: string, to: string, id: BigNumberish, value: BigNumberish, data: BytesLike, overrides?: CallOverrides): Promise<void>;
+        setApprovalForAll(operator: string, approved: boolean, overrides?: CallOverrides): Promise<void>;
+        setExternalTVL(pool: string, targetAmount: BigNumberish, overrides?: CallOverrides): Promise<void>;
+        setExternalTVLBatch(pools: string[], targetAmounts: BigNumberish[], overrides?: CallOverrides): Promise<void>;
+        setURI(newURI: string, overrides?: CallOverrides): Promise<void>;
+        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<boolean>;
+        "totalSupply()"(overrides?: CallOverrides): Promise<BigNumber>;
+        "totalSupply(uint256)"(id: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        uri(arg0: BigNumberish, overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {
+        "ApprovalForAll(address,address,bool)"(account?: string | null, operator?: string | null, approved?: null): ApprovalForAllEventFilter;
+        ApprovalForAll(account?: string | null, operator?: string | null, approved?: null): ApprovalForAllEventFilter;
+        "ExternalTVLSet(address,uint256,uint256)"(pool?: string | null, oldAmount?: null, newAmount?: null): ExternalTVLSetEventFilter;
+        ExternalTVLSet(pool?: string | null, oldAmount?: null, newAmount?: null): ExternalTVLSetEventFilter;
+        "Initialized(uint64)"(version?: null): InitializedEventFilter;
+        Initialized(version?: null): InitializedEventFilter;
+        "TransferBatch(address,address,address,uint256[],uint256[])"(operator?: string | null, from?: string | null, to?: string | null, ids?: null, values?: null): TransferBatchEventFilter;
+        TransferBatch(operator?: string | null, from?: string | null, to?: string | null, ids?: null, values?: null): TransferBatchEventFilter;
+        "TransferSingle(address,address,address,uint256,uint256)"(operator?: string | null, from?: string | null, to?: string | null, id?: null, value?: null): TransferSingleEventFilter;
+        TransferSingle(operator?: string | null, from?: string | null, to?: string | null, id?: null, value?: null): TransferSingleEventFilter;
+        "URI(string,uint256)"(value?: null, id?: BigNumberish | null): URIEventFilter;
+        URI(value?: null, id?: BigNumberish | null): URIEventFilter;
+    };
+    estimateGas: {
+        balanceOf(account: string, id: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        balanceOfBatch(accounts: string[], ids: BigNumberish[], overrides?: CallOverrides): Promise<BigNumber>;
+        burn(account: string, id: BigNumberish, value: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        burnBatch(account: string, ids: BigNumberish[], values: BigNumberish[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        burnExternalTVL(pool: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        exists(id: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        externalTVLOfPool(pool: string, overrides?: CallOverrides): Promise<BigNumber>;
+        initialize(baseURI_: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        isApprovedForAll(account: string, operator: string, overrides?: CallOverrides): Promise<BigNumber>;
+        mintExternalTVL(pool: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        onERC1155BatchReceived(arg0: string, arg1: string, arg2: BigNumberish[], arg3: BigNumberish[], arg4: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        onERC1155Received(arg0: string, arg1: string, arg2: BigNumberish, arg3: BigNumberish, arg4: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        poolId(pool: string, overrides?: CallOverrides): Promise<BigNumber>;
+        safeBatchTransferFrom(from: string, to: string, ids: BigNumberish[], values: BigNumberish[], data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        safeTransferFrom(from: string, to: string, id: BigNumberish, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        setApprovalForAll(operator: string, approved: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        setExternalTVL(pool: string, targetAmount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        setExternalTVLBatch(pools: string[], targetAmounts: BigNumberish[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        setURI(newURI: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<BigNumber>;
+        "totalSupply()"(overrides?: CallOverrides): Promise<BigNumber>;
+        "totalSupply(uint256)"(id: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+        uri(arg0: BigNumberish, overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        balanceOf(account: string, id: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        balanceOfBatch(accounts: string[], ids: BigNumberish[], overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        burn(account: string, id: BigNumberish, value: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        burnBatch(account: string, ids: BigNumberish[], values: BigNumberish[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        burnExternalTVL(pool: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        exists(id: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        externalTVLOfPool(pool: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        initialize(baseURI_: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        isApprovedForAll(account: string, operator: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        mintExternalTVL(pool: string, amount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        onERC1155BatchReceived(arg0: string, arg1: string, arg2: BigNumberish[], arg3: BigNumberish[], arg4: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        onERC1155Received(arg0: string, arg1: string, arg2: BigNumberish, arg3: BigNumberish, arg4: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        poolId(pool: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        safeBatchTransferFrom(from: string, to: string, ids: BigNumberish[], values: BigNumberish[], data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        safeTransferFrom(from: string, to: string, id: BigNumberish, value: BigNumberish, data: BytesLike, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        setApprovalForAll(operator: string, approved: boolean, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        setExternalTVL(pool: string, targetAmount: BigNumberish, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        setExternalTVLBatch(pools: string[], targetAmounts: BigNumberish[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        setURI(newURI: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        supportsInterface(interfaceId: BytesLike, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        "totalSupply()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        "totalSupply(uint256)"(id: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        uri(arg0: BigNumberish, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/contracts/KasuPoolExternalTVLAbi.js

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

package/dist/contracts/SwapperAbi.d.ts

@@ -0,0 +1,120 @@
+import type { BaseContract, BigNumber, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent } from "./common";
+export type SwapInfoStruct = {
+    swapTarget: string;
+    token: string;
+    swapCallData: BytesLike;
+};
+export type SwapInfoStructOutput = [string, string, string] & {
+    swapTarget: string;
+    token: string;
+    swapCallData: string;
+};
+export interface SwapperAbiInterface extends utils.Interface {
+    functions: {
+        "isExchangeAllowed(address)": FunctionFragment;
+        "swap(address[],(address,address,bytes)[],address,address)": FunctionFragment;
+        "updateExchangeAllowlist(address[],bool[])": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "isExchangeAllowed" | "swap" | "updateExchangeAllowlist"): FunctionFragment;
+    encodeFunctionData(functionFragment: "isExchangeAllowed", values: [string]): string;
+    encodeFunctionData(functionFragment: "swap", values: [string[], SwapInfoStruct[], string, string]): string;
+    encodeFunctionData(functionFragment: "updateExchangeAllowlist", values: [string[], boolean[]]): string;
+    decodeFunctionResult(functionFragment: "isExchangeAllowed", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "swap", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "updateExchangeAllowlist", data: BytesLike): Result;
+    events: {
+        "ExchangeAllowlistUpdated(address,bool)": EventFragment;
+        "Swapped(address,address[],address,uint256[],uint256)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "ExchangeAllowlistUpdated"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Swapped"): EventFragment;
+}
+export interface ExchangeAllowlistUpdatedEventObject {
+    exchange: string;
+    isAllowed: boolean;
+}
+export type ExchangeAllowlistUpdatedEvent = TypedEvent<[
+    string,
+    boolean
+], ExchangeAllowlistUpdatedEventObject>;
+export type ExchangeAllowlistUpdatedEventFilter = TypedEventFilter<ExchangeAllowlistUpdatedEvent>;
+export interface SwappedEventObject {
+    receiver: string;
+    tokensIn: string[];
+    tokenOut: string;
+    amountsIn: BigNumber[];
+    amountOut: BigNumber;
+}
+export type SwappedEvent = TypedEvent<[
+    string,
+    string[],
+    string,
+    BigNumber[],
+    BigNumber
+], SwappedEventObject>;
+export type SwappedEventFilter = TypedEventFilter<SwappedEvent>;
+export interface SwapperAbi extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: SwapperAbiInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        isExchangeAllowed(exchange: string, overrides?: CallOverrides): Promise<[boolean] & {
+            isAllowed: boolean;
+        }>;
+        swap(tokensIn: string[], swapInfo: SwapInfoStruct[], tokenOut: string, receiver: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+        updateExchangeAllowlist(exchanges: string[], allowed: boolean[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<ContractTransaction>;
+    };
+    isExchangeAllowed(exchange: string, overrides?: CallOverrides): Promise<boolean>;
+    swap(tokensIn: string[], swapInfo: SwapInfoStruct[], tokenOut: string, receiver: string, overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    updateExchangeAllowlist(exchanges: string[], allowed: boolean[], overrides?: Overrides & {
+        from?: string;
+    }): Promise<ContractTransaction>;
+    callStatic: {
+        isExchangeAllowed(exchange: string, overrides?: CallOverrides): Promise<boolean>;
+        swap(tokensIn: string[], swapInfo: SwapInfoStruct[], tokenOut: string, receiver: string, overrides?: CallOverrides): Promise<BigNumber>;
+        updateExchangeAllowlist(exchanges: string[], allowed: boolean[], overrides?: CallOverrides): Promise<void>;
+    };
+    filters: {
+        "ExchangeAllowlistUpdated(address,bool)"(exchange?: string | null, isAllowed?: null): ExchangeAllowlistUpdatedEventFilter;
+        ExchangeAllowlistUpdated(exchange?: string | null, isAllowed?: null): ExchangeAllowlistUpdatedEventFilter;
+        "Swapped(address,address[],address,uint256[],uint256)"(receiver?: string | null, tokensIn?: null, tokenOut?: null, amountsIn?: null, amountOut?: null): SwappedEventFilter;
+        Swapped(receiver?: string | null, tokensIn?: null, tokenOut?: null, amountsIn?: null, amountOut?: null): SwappedEventFilter;
+    };
+    estimateGas: {
+        isExchangeAllowed(exchange: string, overrides?: CallOverrides): Promise<BigNumber>;
+        swap(tokensIn: string[], swapInfo: SwapInfoStruct[], tokenOut: string, receiver: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+        updateExchangeAllowlist(exchanges: string[], allowed: boolean[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        isExchangeAllowed(exchange: string, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        swap(tokensIn: string[], swapInfo: SwapInfoStruct[], tokenOut: string, receiver: string, overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+        updateExchangeAllowlist(exchanges: string[], allowed: boolean[], overrides?: Overrides & {
+            from?: string;
+        }): Promise<PopulatedTransaction>;
+    };
+}

package/dist/contracts/SwapperAbi.js

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

package/dist/contracts/common.d.ts

@@ -0,0 +1,21 @@
+import type { Listener } from "@ethersproject/providers";
+import type { Event, EventFilter } from "ethers";
+export interface TypedEvent<TArgsArray extends Array<any> = any, TArgsObject = any> extends Event {
+    args: TArgsArray & TArgsObject;
+}
+export interface TypedEventFilter<_TEvent extends TypedEvent> extends EventFilter {
+}
+export interface TypedListener<TEvent extends TypedEvent> {
+    (...listenerArg: [...__TypechainArgsArray<TEvent>, TEvent]): void;
+}
+type __TypechainArgsArray<T> = T extends TypedEvent<infer U> ? U : never;
+export interface OnEvent<TRes> {
+    <TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>, listener: TypedListener<TEvent>): TRes;
+    (eventName: string, listener: Listener): TRes;
+}
+export type MinEthersFactory<C, ARGS> = {
+    deploy(...a: ARGS[]): Promise<C>;
+};
+export type GetContractTypeFromFactory<F> = F extends MinEthersFactory<infer C, any> ? C : never;
+export type GetARGsTypeFromFactory<F> = F extends MinEthersFactory<any, any> ? Parameters<F["deploy"]> : never;
+export {};

package/dist/contracts/common.js

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