opensea-js 4.0.21 → 4.0.22

package/lib/typechain/contracts/UniswapExchangeAbi.d.ts

@@ -0,0 +1,132 @@
+/// <reference types="node" />
+import BN from "bn.js";
+import { ContractOptions } from "web3-eth-contract";
+import { EventLog } from "web3-core";
+import { EventEmitter } from "events";
+import { Callback, PayableTransactionObject, NonPayableTransactionObject, BlockType, ContractEventLog, BaseContract } from "./types";
+export interface EventOptions {
+    filter?: object;
+    fromBlock?: BlockType;
+    topics?: string[];
+}
+export declare type TokenPurchase = ContractEventLog<{
+    buyer: string;
+    eth_sold: string;
+    tokens_bought: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export declare type EthPurchase = ContractEventLog<{
+    buyer: string;
+    tokens_sold: string;
+    eth_bought: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export declare type AddLiquidity = ContractEventLog<{
+    provider: string;
+    eth_amount: string;
+    token_amount: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export declare type RemoveLiquidity = ContractEventLog<{
+    provider: string;
+    eth_amount: string;
+    token_amount: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export declare type Transfer = ContractEventLog<{
+    _from: string;
+    _to: string;
+    _value: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export declare type Approval = ContractEventLog<{
+    _owner: string;
+    _spender: string;
+    _value: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export interface UniswapExchangeAbi extends BaseContract {
+    constructor(jsonInterface: any[], address?: string, options?: ContractOptions): UniswapExchangeAbi;
+    clone(): UniswapExchangeAbi;
+    methods: {
+        setup(token_addr: string): NonPayableTransactionObject<void>;
+        addLiquidity(min_liquidity: number | string | BN, max_tokens: number | string | BN, deadline: number | string | BN): PayableTransactionObject<string>;
+        removeLiquidity(amount: number | string | BN, min_eth: number | string | BN, min_tokens: number | string | BN, deadline: number | string | BN): NonPayableTransactionObject<{
+            out_a: string;
+            out_b: string;
+            0: string;
+            1: string;
+        }>;
+        __default__(): PayableTransactionObject<void>;
+        ethToTokenSwapInput(min_tokens: number | string | BN, deadline: number | string | BN): PayableTransactionObject<string>;
+        ethToTokenTransferInput(min_tokens: number | string | BN, deadline: number | string | BN, recipient: string): PayableTransactionObject<string>;
+        ethToTokenSwapOutput(tokens_bought: number | string | BN, deadline: number | string | BN): PayableTransactionObject<string>;
+        ethToTokenTransferOutput(tokens_bought: number | string | BN, deadline: number | string | BN, recipient: string): PayableTransactionObject<string>;
+        tokenToEthSwapInput(tokens_sold: number | string | BN, min_eth: number | string | BN, deadline: number | string | BN): NonPayableTransactionObject<string>;
+        tokenToEthTransferInput(tokens_sold: number | string | BN, min_eth: number | string | BN, deadline: number | string | BN, recipient: string): NonPayableTransactionObject<string>;
+        tokenToEthSwapOutput(eth_bought: number | string | BN, max_tokens: number | string | BN, deadline: number | string | BN): NonPayableTransactionObject<string>;
+        tokenToEthTransferOutput(eth_bought: number | string | BN, max_tokens: number | string | BN, deadline: number | string | BN, recipient: string): NonPayableTransactionObject<string>;
+        tokenToTokenSwapInput(tokens_sold: number | string | BN, min_tokens_bought: number | string | BN, min_eth_bought: number | string | BN, deadline: number | string | BN, token_addr: string): NonPayableTransactionObject<string>;
+        tokenToTokenTransferInput(tokens_sold: number | string | BN, min_tokens_bought: number | string | BN, min_eth_bought: number | string | BN, deadline: number | string | BN, recipient: string, token_addr: string): NonPayableTransactionObject<string>;
+        tokenToTokenSwapOutput(tokens_bought: number | string | BN, max_tokens_sold: number | string | BN, max_eth_sold: number | string | BN, deadline: number | string | BN, token_addr: string): NonPayableTransactionObject<string>;
+        tokenToTokenTransferOutput(tokens_bought: number | string | BN, max_tokens_sold: number | string | BN, max_eth_sold: number | string | BN, deadline: number | string | BN, recipient: string, token_addr: string): NonPayableTransactionObject<string>;
+        tokenToExchangeSwapInput(tokens_sold: number | string | BN, min_tokens_bought: number | string | BN, min_eth_bought: number | string | BN, deadline: number | string | BN, exchange_addr: string): NonPayableTransactionObject<string>;
+        tokenToExchangeTransferInput(tokens_sold: number | string | BN, min_tokens_bought: number | string | BN, min_eth_bought: number | string | BN, deadline: number | string | BN, recipient: string, exchange_addr: string): NonPayableTransactionObject<string>;
+        tokenToExchangeSwapOutput(tokens_bought: number | string | BN, max_tokens_sold: number | string | BN, max_eth_sold: number | string | BN, deadline: number | string | BN, exchange_addr: string): NonPayableTransactionObject<string>;
+        tokenToExchangeTransferOutput(tokens_bought: number | string | BN, max_tokens_sold: number | string | BN, max_eth_sold: number | string | BN, deadline: number | string | BN, recipient: string, exchange_addr: string): NonPayableTransactionObject<string>;
+        getEthToTokenInputPrice(eth_sold: number | string | BN): NonPayableTransactionObject<string>;
+        getEthToTokenOutputPrice(tokens_bought: number | string | BN): NonPayableTransactionObject<string>;
+        getTokenToEthInputPrice(tokens_sold: number | string | BN): NonPayableTransactionObject<string>;
+        getTokenToEthOutputPrice(eth_bought: number | string | BN): NonPayableTransactionObject<string>;
+        tokenAddress(): NonPayableTransactionObject<string>;
+        factoryAddress(): NonPayableTransactionObject<string>;
+        balanceOf(_owner: string): NonPayableTransactionObject<string>;
+        transfer(_to: string, _value: number | string | BN): NonPayableTransactionObject<boolean>;
+        transferFrom(_from: string, _to: string, _value: number | string | BN): NonPayableTransactionObject<boolean>;
+        approve(_spender: string, _value: number | string | BN): NonPayableTransactionObject<boolean>;
+        allowance(_owner: string, _spender: string): NonPayableTransactionObject<string>;
+        name(): NonPayableTransactionObject<string>;
+        symbol(): NonPayableTransactionObject<string>;
+        decimals(): NonPayableTransactionObject<string>;
+        totalSupply(): NonPayableTransactionObject<string>;
+    };
+    events: {
+        TokenPurchase(cb?: Callback<TokenPurchase>): EventEmitter;
+        TokenPurchase(options?: EventOptions, cb?: Callback<TokenPurchase>): EventEmitter;
+        EthPurchase(cb?: Callback<EthPurchase>): EventEmitter;
+        EthPurchase(options?: EventOptions, cb?: Callback<EthPurchase>): EventEmitter;
+        AddLiquidity(cb?: Callback<AddLiquidity>): EventEmitter;
+        AddLiquidity(options?: EventOptions, cb?: Callback<AddLiquidity>): EventEmitter;
+        RemoveLiquidity(cb?: Callback<RemoveLiquidity>): EventEmitter;
+        RemoveLiquidity(options?: EventOptions, cb?: Callback<RemoveLiquidity>): EventEmitter;
+        Transfer(cb?: Callback<Transfer>): EventEmitter;
+        Transfer(options?: EventOptions, cb?: Callback<Transfer>): EventEmitter;
+        Approval(cb?: Callback<Approval>): EventEmitter;
+        Approval(options?: EventOptions, cb?: Callback<Approval>): EventEmitter;
+        allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+    };
+    once(event: "TokenPurchase", cb: Callback<TokenPurchase>): void;
+    once(event: "TokenPurchase", options: EventOptions, cb: Callback<TokenPurchase>): void;
+    once(event: "EthPurchase", cb: Callback<EthPurchase>): void;
+    once(event: "EthPurchase", options: EventOptions, cb: Callback<EthPurchase>): void;
+    once(event: "AddLiquidity", cb: Callback<AddLiquidity>): void;
+    once(event: "AddLiquidity", options: EventOptions, cb: Callback<AddLiquidity>): void;
+    once(event: "RemoveLiquidity", cb: Callback<RemoveLiquidity>): void;
+    once(event: "RemoveLiquidity", options: EventOptions, cb: Callback<RemoveLiquidity>): void;
+    once(event: "Transfer", cb: Callback<Transfer>): void;
+    once(event: "Transfer", options: EventOptions, cb: Callback<Transfer>): void;
+    once(event: "Approval", cb: Callback<Approval>): void;
+    once(event: "Approval", options: EventOptions, cb: Callback<Approval>): void;
+}

package/lib/typechain/contracts/UniswapExchangeAbi.js

@@ -0,0 +1,6 @@
+"use strict";
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=UniswapExchangeAbi.js.map

package/lib/typechain/contracts/UniswapExchangeAbi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniswapExchangeAbi.js","sourceRoot":"","sources":["../../../src/typechain/contracts/UniswapExchangeAbi.ts"],"names":[],"mappings":";AAAA,+CAA+C;AAC/C,oBAAoB;AACpB,oBAAoB"}

package/lib/typechain/contracts/UniswapFactoryAbi.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import BN from "bn.js";
+import { ContractOptions } from "web3-eth-contract";
+import { EventLog } from "web3-core";
+import { EventEmitter } from "events";
+import { Callback, NonPayableTransactionObject, BlockType, ContractEventLog, BaseContract } from "./types";
+export interface EventOptions {
+    filter?: object;
+    fromBlock?: BlockType;
+    topics?: string[];
+}
+export declare type NewExchange = ContractEventLog<{
+    token: string;
+    exchange: string;
+    0: string;
+    1: string;
+}>;
+export interface UniswapFactoryAbi extends BaseContract {
+    constructor(jsonInterface: any[], address?: string, options?: ContractOptions): UniswapFactoryAbi;
+    clone(): UniswapFactoryAbi;
+    methods: {
+        initializeFactory(template: string): NonPayableTransactionObject<void>;
+        createExchange(token: string): NonPayableTransactionObject<string>;
+        getExchange(token: string): NonPayableTransactionObject<string>;
+        getToken(exchange: string): NonPayableTransactionObject<string>;
+        getTokenWithId(token_id: number | string | BN): NonPayableTransactionObject<string>;
+        exchangeTemplate(): NonPayableTransactionObject<string>;
+        tokenCount(): NonPayableTransactionObject<string>;
+    };
+    events: {
+        NewExchange(cb?: Callback<NewExchange>): EventEmitter;
+        NewExchange(options?: EventOptions, cb?: Callback<NewExchange>): EventEmitter;
+        allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+    };
+    once(event: "NewExchange", cb: Callback<NewExchange>): void;
+    once(event: "NewExchange", options: EventOptions, cb: Callback<NewExchange>): void;
+}

package/lib/typechain/contracts/UniswapFactoryAbi.js

@@ -0,0 +1,6 @@
+"use strict";
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=UniswapFactoryAbi.js.map

package/lib/typechain/contracts/UniswapFactoryAbi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UniswapFactoryAbi.js","sourceRoot":"","sources":["../../../src/typechain/contracts/UniswapFactoryAbi.ts"],"names":[],"mappings":";AAAA,+CAA+C;AAC/C,oBAAoB;AACpB,oBAAoB"}

package/lib/typechain/contracts/WrappedNFTAbi.d.ts

@@ -0,0 +1,80 @@
+/// <reference types="node" />
+import BN from "bn.js";
+import { ContractOptions } from "web3-eth-contract";
+import { EventLog } from "web3-core";
+import { EventEmitter } from "events";
+import { Callback, NonPayableTransactionObject, BlockType, ContractEventLog, BaseContract } from "./types";
+export interface EventOptions {
+    filter?: object;
+    fromBlock?: BlockType;
+    topics?: string[];
+}
+export declare type DepositNFTAndMintToken = ContractEventLog<{
+    nftId: string;
+    0: string;
+}>;
+export declare type BurnTokenAndWithdrawNFT = ContractEventLog<{
+    nftId: string;
+    0: string;
+}>;
+export declare type Transfer = ContractEventLog<{
+    from: string;
+    to: string;
+    value: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export declare type Approval = ContractEventLog<{
+    owner: string;
+    spender: string;
+    value: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export interface WrappedNFTAbi extends BaseContract {
+    constructor(jsonInterface: any[], address?: string, options?: ContractOptions): WrappedNFTAbi;
+    clone(): WrappedNFTAbi;
+    methods: {
+        burnTokensAndWithdrawNfts(_nftIds: (number | string | BN)[], _destinationAddresses: string[]): NonPayableTransactionObject<void>;
+        name(): NonPayableTransactionObject<string>;
+        approve(spender: string, value: number | string | BN): NonPayableTransactionObject<boolean>;
+        onERC721Received(_operator: string, _from: string, _tokenId: number | string | BN, _data: string | number[]): NonPayableTransactionObject<string>;
+        totalSupply(): NonPayableTransactionObject<string>;
+        batchRemoveWithdrawnNFTsFromStorage(_numSlotsToCheck: number | string | BN): NonPayableTransactionObject<void>;
+        transferFrom(from: string, to: string, value: number | string | BN): NonPayableTransactionObject<boolean>;
+        decimals(): NonPayableTransactionObject<string>;
+        wyvernTokenTransferProxyAddress(): NonPayableTransactionObject<string>;
+        uniswapFactoryAddress(): NonPayableTransactionObject<string>;
+        increaseAllowance(spender: string, addedValue: number | string | BN): NonPayableTransactionObject<boolean>;
+        balanceOf(owner: string): NonPayableTransactionObject<string>;
+        nftIsDepositedInContract(arg0: number | string | BN): NonPayableTransactionObject<boolean>;
+        symbol(): NonPayableTransactionObject<string>;
+        depositNftsAndMintTokens(_nftIds: (number | string | BN)[]): NonPayableTransactionObject<void>;
+        decreaseAllowance(spender: string, subtractedValue: number | string | BN): NonPayableTransactionObject<boolean>;
+        transfer(to: string, value: number | string | BN): NonPayableTransactionObject<boolean>;
+        allowance(owner: string, spender: string): NonPayableTransactionObject<string>;
+        nftCoreAddress(): NonPayableTransactionObject<string>;
+        wrappedNFTLiquidationProxyAddress(): NonPayableTransactionObject<string>;
+    };
+    events: {
+        DepositNFTAndMintToken(cb?: Callback<DepositNFTAndMintToken>): EventEmitter;
+        DepositNFTAndMintToken(options?: EventOptions, cb?: Callback<DepositNFTAndMintToken>): EventEmitter;
+        BurnTokenAndWithdrawNFT(cb?: Callback<BurnTokenAndWithdrawNFT>): EventEmitter;
+        BurnTokenAndWithdrawNFT(options?: EventOptions, cb?: Callback<BurnTokenAndWithdrawNFT>): EventEmitter;
+        Transfer(cb?: Callback<Transfer>): EventEmitter;
+        Transfer(options?: EventOptions, cb?: Callback<Transfer>): EventEmitter;
+        Approval(cb?: Callback<Approval>): EventEmitter;
+        Approval(options?: EventOptions, cb?: Callback<Approval>): EventEmitter;
+        allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+    };
+    once(event: "DepositNFTAndMintToken", cb: Callback<DepositNFTAndMintToken>): void;
+    once(event: "DepositNFTAndMintToken", options: EventOptions, cb: Callback<DepositNFTAndMintToken>): void;
+    once(event: "BurnTokenAndWithdrawNFT", cb: Callback<BurnTokenAndWithdrawNFT>): void;
+    once(event: "BurnTokenAndWithdrawNFT", options: EventOptions, cb: Callback<BurnTokenAndWithdrawNFT>): void;
+    once(event: "Transfer", cb: Callback<Transfer>): void;
+    once(event: "Transfer", options: EventOptions, cb: Callback<Transfer>): void;
+    once(event: "Approval", cb: Callback<Approval>): void;
+    once(event: "Approval", options: EventOptions, cb: Callback<Approval>): void;
+}

package/lib/typechain/contracts/WrappedNFTAbi.js

@@ -0,0 +1,6 @@
+"use strict";
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=WrappedNFTAbi.js.map

package/lib/typechain/contracts/WrappedNFTAbi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WrappedNFTAbi.js","sourceRoot":"","sources":["../../../src/typechain/contracts/WrappedNFTAbi.ts"],"names":[],"mappings":";AAAA,+CAA+C;AAC/C,oBAAoB;AACpB,oBAAoB"}

package/lib/typechain/contracts/WrappedNFTFactoryAbi.d.ts

@@ -0,0 +1,57 @@
+/// <reference types="node" />
+import BN from "bn.js";
+import { ContractOptions } from "web3-eth-contract";
+import { EventLog } from "web3-core";
+import { EventEmitter } from "events";
+import { Callback, NonPayableTransactionObject, BlockType, ContractEventLog, BaseContract } from "./types";
+export interface EventOptions {
+    filter?: object;
+    fromBlock?: BlockType;
+    topics?: string[];
+}
+export declare type NewWrapperContractCreated = ContractEventLog<{
+    nftContract: string;
+    wrapperContract: string;
+    0: string;
+    1: string;
+}>;
+export declare type OwnershipTransferred = ContractEventLog<{
+    previousOwner: string;
+    newOwner: string;
+    0: string;
+    1: string;
+}>;
+export interface WrappedNFTFactoryAbi extends BaseContract {
+    constructor(jsonInterface: any[], address?: string, options?: ContractOptions): WrappedNFTFactoryAbi;
+    clone(): WrappedNFTFactoryAbi;
+    methods: {
+        wyvernTokenTransferProxyAddress(): NonPayableTransactionObject<string>;
+        uniswapFactoryAddress(): NonPayableTransactionObject<string>;
+        importMappingsFromPreviousFactory(_startIndex: number | string | BN, _endIndex: number | string | BN, _previousFactoryAddress: string): NonPayableTransactionObject<void>;
+        idToNftContract(arg0: number | string | BN): NonPayableTransactionObject<string>;
+        wrapperContractsCreated(): NonPayableTransactionObject<string>;
+        wrapperContractToNftContract(arg0: string): NonPayableTransactionObject<string>;
+        renounceOwnership(): NonPayableTransactionObject<void>;
+        createWrapperContract(_nftContractAddress: string): NonPayableTransactionObject<void>;
+        owner(): NonPayableTransactionObject<string>;
+        isOwner(): NonPayableTransactionObject<boolean>;
+        updateWyvernTokenTransferProxyAddress(_newWyvernTokenTransferProxyAddress: string): NonPayableTransactionObject<void>;
+        updateWrappedNFTLiquidationProxyAddress(_newWrappedNFTLiquidationProxyAddress: string): NonPayableTransactionObject<void>;
+        nftContractToWrapperContract(arg0: string): NonPayableTransactionObject<string>;
+        getWrapperContractForNFTContractAddress(_nftContractAddress: string): NonPayableTransactionObject<string>;
+        updateUniswapFactoryContractAddress(_newUniswapFactoryAddress: string): NonPayableTransactionObject<void>;
+        transferOwnership(newOwner: string): NonPayableTransactionObject<void>;
+        wrappedNFTLiquidationProxyAddress(): NonPayableTransactionObject<string>;
+    };
+    events: {
+        NewWrapperContractCreated(cb?: Callback<NewWrapperContractCreated>): EventEmitter;
+        NewWrapperContractCreated(options?: EventOptions, cb?: Callback<NewWrapperContractCreated>): EventEmitter;
+        OwnershipTransferred(cb?: Callback<OwnershipTransferred>): EventEmitter;
+        OwnershipTransferred(options?: EventOptions, cb?: Callback<OwnershipTransferred>): EventEmitter;
+        allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+    };
+    once(event: "NewWrapperContractCreated", cb: Callback<NewWrapperContractCreated>): void;
+    once(event: "NewWrapperContractCreated", options: EventOptions, cb: Callback<NewWrapperContractCreated>): void;
+    once(event: "OwnershipTransferred", cb: Callback<OwnershipTransferred>): void;
+    once(event: "OwnershipTransferred", options: EventOptions, cb: Callback<OwnershipTransferred>): void;
+}

package/lib/typechain/contracts/WrappedNFTFactoryAbi.js

@@ -0,0 +1,6 @@
+"use strict";
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=WrappedNFTFactoryAbi.js.map

package/lib/typechain/contracts/WrappedNFTFactoryAbi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WrappedNFTFactoryAbi.js","sourceRoot":"","sources":["../../../src/typechain/contracts/WrappedNFTFactoryAbi.ts"],"names":[],"mappings":";AAAA,+CAA+C;AAC/C,oBAAoB;AACpB,oBAAoB"}

package/lib/typechain/contracts/types.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="node" />
+import BN from "bn.js";
+import { EventEmitter } from "events";
+import { EventLog, PromiEvent, TransactionReceipt } from "web3-core/types";
+import { Contract } from "web3-eth-contract";
+export interface EstimateGasOptions {
+    from?: string;
+    gas?: number;
+    value?: number | string | BN;
+}
+export interface EventOptions {
+    filter?: object;
+    fromBlock?: BlockType;
+    topics?: string[];
+}
+export declare type Callback<T> = (error: Error, result: T) => void;
+export interface ContractEventLog<T> extends EventLog {
+    returnValues: T;
+}
+export interface ContractEventEmitter<T> extends EventEmitter {
+    on(event: "connected", listener: (subscriptionId: string) => void): this;
+    on(event: "data" | "changed", listener: (event: ContractEventLog<T>) => void): this;
+    on(event: "error", listener: (error: Error) => void): this;
+}
+export interface NonPayableTx {
+    nonce?: string | number | BN;
+    chainId?: string | number | BN;
+    from?: string;
+    to?: string;
+    data?: string;
+    gas?: string | number | BN;
+    maxPriorityFeePerGas?: string | number | BN;
+    maxFeePerGas?: string | number | BN;
+    gasPrice?: string | number | BN;
+}
+export interface PayableTx extends NonPayableTx {
+    value?: string | number | BN;
+}
+export interface NonPayableTransactionObject<T> {
+    arguments: any[];
+    call(tx?: NonPayableTx, block?: BlockType): Promise<T>;
+    send(tx?: NonPayableTx): PromiEvent<TransactionReceipt>;
+    estimateGas(tx?: NonPayableTx): Promise<number>;
+    encodeABI(): string;
+}
+export interface PayableTransactionObject<T> {
+    arguments: any[];
+    call(tx?: PayableTx, block?: BlockType): Promise<T>;
+    send(tx?: PayableTx): PromiEvent<TransactionReceipt>;
+    estimateGas(tx?: PayableTx): Promise<number>;
+    encodeABI(): string;
+}
+export declare type BlockType = "latest" | "pending" | "genesis" | "earliest" | number | BN;
+export declare type BaseContract = Omit<Contract, "clone" | "once">;

package/lib/typechain/contracts/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/lib/typechain/contracts/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/typechain/contracts/types.ts"],"names":[],"mappings":""}