opensea-js 2.0.1-beta.2 → 2.0.2-beta.1

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

@@ -0,0 +1,232 @@
+/// <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 DuelStart = ContractEventLog<{
+    duelId: string;
+    wizardId1: string;
+    wizardId2: string;
+    timeoutBlock: string;
+    isAscensionBattle: boolean;
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    4: boolean;
+}>;
+export declare type DuelEnd = ContractEventLog<{
+    duelId: string;
+    wizardId1: string;
+    wizardId2: string;
+    moveSet1: string;
+    moveSet2: string;
+    power1: string;
+    power2: string;
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+    5: string;
+    6: string;
+}>;
+export declare type DuelTimeOut = ContractEventLog<{
+    duelId: string;
+    wizardId1: string;
+    wizardId2: string;
+    power1: string;
+    power2: string;
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+    4: string;
+}>;
+export declare type WizardElimination = ContractEventLog<{
+    wizardId: string;
+    0: string;
+}>;
+export declare type AscensionStart = ContractEventLog<{
+    wizardId: string;
+    0: string;
+}>;
+export declare type AscensionPairUp = ContractEventLog<{
+    wizardId1: string;
+    wizardId2: string;
+    0: string;
+    1: string;
+}>;
+export declare type AscensionComplete = ContractEventLog<{
+    wizardId: string;
+    power: string;
+    0: string;
+    1: string;
+}>;
+export declare type Revive = ContractEventLog<{
+    wizId: string;
+    power: string;
+    0: string;
+    1: string;
+}>;
+export declare type PowerGifted = ContractEventLog<{
+    givingWizId: string;
+    receivingWizId: string;
+    amountGifted: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export declare type PrizeClaimed = ContractEventLog<{
+    claimingWinnerId: string;
+    prizeAmount: string;
+    0: string;
+    1: string;
+}>;
+export declare type Paused = ContractEventLog<{
+    pauseEndingBlock: string;
+    0: string;
+}>;
+export declare type CEOTransferred = ContractEventLog<{
+    previousCeo: string;
+    newCeo: string;
+    0: string;
+    1: string;
+}>;
+export declare type COOTransferred = ContractEventLog<{
+    previousCoo: string;
+    newCoo: string;
+    0: string;
+    1: string;
+}>;
+export declare type CFOTransferred = ContractEventLog<{
+    previousCfo: string;
+    newCfo: string;
+    0: string;
+    1: string;
+}>;
+export interface CheezeWizardsBasicTournamentAbi extends BaseContract {
+    constructor(jsonInterface: any[], address?: string, options?: ContractOptions): CheezeWizardsBasicTournamentAbi;
+    clone(): CheezeWizardsBasicTournamentAbi;
+    methods: {
+        cfoAddress(): NonPayableTransactionObject<string>;
+        ceoAddress(): NonPayableTransactionObject<string>;
+        pause(pauseDuration: number | string | BN): NonPayableTransactionObject<void>;
+        setCfo(newCfo: string): NonPayableTransactionObject<void>;
+        duelResolver(): NonPayableTransactionObject<string>;
+        setCeo(newCeo: string): NonPayableTransactionObject<void>;
+        setCoo(newCoo: string): NonPayableTransactionObject<void>;
+        powerScale(): NonPayableTransactionObject<string>;
+        cooAddress(): NonPayableTransactionObject<string>;
+        isPaused(): NonPayableTransactionObject<boolean>;
+        supportsInterface(interfaceId: string | number[]): NonPayableTransactionObject<boolean>;
+        isActive(): NonPayableTransactionObject<boolean>;
+        getWizard(wizardId: number | string | BN): NonPayableTransactionObject<{
+            affinity: string;
+            power: string;
+            maxPower: string;
+            nonce: string;
+            currentDuel: string;
+            ascending: boolean;
+            ascensionOpponent: string;
+            molded: boolean;
+            ready: boolean;
+            0: string;
+            1: string;
+            2: string;
+            3: string;
+            4: string;
+            5: boolean;
+            6: string;
+            7: boolean;
+            8: boolean;
+        }>;
+        wizardFingerprint(wizardId: number | string | BN): NonPayableTransactionObject<string>;
+        isReady(wizardId: number | string | BN): NonPayableTransactionObject<boolean>;
+        enterWizards(wizardIds: (number | string | BN)[], powers: (number | string | BN)[]): PayableTransactionObject<void>;
+        revive(wizardId: number | string | BN): PayableTransactionObject<void>;
+        updateAffinity(wizardId: number | string | BN): NonPayableTransactionObject<void>;
+        startAscension(wizardId: number | string | BN): NonPayableTransactionObject<void>;
+        challengeAscending(wizardId: number | string | BN, commitment: string | number[]): NonPayableTransactionObject<void>;
+        acceptAscensionChallenge(commitment: string | number[]): NonPayableTransactionObject<void>;
+        completeAscension(): NonPayableTransactionObject<void>;
+        oneSidedCommit(committingWizardId: number | string | BN, otherWizardId: number | string | BN, commitment: string | number[]): NonPayableTransactionObject<void>;
+        cancelCommitment(wizardId: number | string | BN): NonPayableTransactionObject<void>;
+        doubleCommit(wizardId1: number | string | BN, wizardId2: number | string | BN, commit1: string | number[], commit2: string | number[], sig1: string | number[], sig2: string | number[]): NonPayableTransactionObject<string>;
+        oneSidedReveal(committingWizardId: number | string | BN, commit: string | number[], moveSet: string | number[], salt: string | number[], otherWizardId: number | string | BN, otherCommit: string | number[]): NonPayableTransactionObject<void>;
+        doubleReveal(wizardId1: number | string | BN, wizardId2: number | string | BN, commit1: string | number[], commit2: string | number[], moveSet1: string | number[], moveSet2: string | number[], salt1: string | number[], salt2: string | number[]): NonPayableTransactionObject<void>;
+        resolveTimedOutDuel(wizardId1: number | string | BN, wizardId2: number | string | BN): NonPayableTransactionObject<void>;
+        giftPower(sendingWizardId: number | string | BN, receivingWizardId: number | string | BN): NonPayableTransactionObject<void>;
+        cullMoldedWithSurvivor(wizardIds: (number | string | BN)[], survivor: number | string | BN): NonPayableTransactionObject<void>;
+        cullMoldedWithMolded(moldyWizardIds: (number | string | BN)[]): NonPayableTransactionObject<void>;
+        cullTiredWizards(wizardIds: (number | string | BN)[]): NonPayableTransactionObject<void>;
+        claimTheBigCheeze(claimingWinnerId: number | string | BN): NonPayableTransactionObject<void>;
+        claimSharedWinnings(claimingWinnerId: number | string | BN, allWinners: (number | string | BN)[]): NonPayableTransactionObject<void>;
+        destroy(): NonPayableTransactionObject<void>;
+    };
+    events: {
+        DuelStart(cb?: Callback<DuelStart>): EventEmitter;
+        DuelStart(options?: EventOptions, cb?: Callback<DuelStart>): EventEmitter;
+        DuelEnd(cb?: Callback<DuelEnd>): EventEmitter;
+        DuelEnd(options?: EventOptions, cb?: Callback<DuelEnd>): EventEmitter;
+        DuelTimeOut(cb?: Callback<DuelTimeOut>): EventEmitter;
+        DuelTimeOut(options?: EventOptions, cb?: Callback<DuelTimeOut>): EventEmitter;
+        WizardElimination(cb?: Callback<WizardElimination>): EventEmitter;
+        WizardElimination(options?: EventOptions, cb?: Callback<WizardElimination>): EventEmitter;
+        AscensionStart(cb?: Callback<AscensionStart>): EventEmitter;
+        AscensionStart(options?: EventOptions, cb?: Callback<AscensionStart>): EventEmitter;
+        AscensionPairUp(cb?: Callback<AscensionPairUp>): EventEmitter;
+        AscensionPairUp(options?: EventOptions, cb?: Callback<AscensionPairUp>): EventEmitter;
+        AscensionComplete(cb?: Callback<AscensionComplete>): EventEmitter;
+        AscensionComplete(options?: EventOptions, cb?: Callback<AscensionComplete>): EventEmitter;
+        Revive(cb?: Callback<Revive>): EventEmitter;
+        Revive(options?: EventOptions, cb?: Callback<Revive>): EventEmitter;
+        PowerGifted(cb?: Callback<PowerGifted>): EventEmitter;
+        PowerGifted(options?: EventOptions, cb?: Callback<PowerGifted>): EventEmitter;
+        PrizeClaimed(cb?: Callback<PrizeClaimed>): EventEmitter;
+        PrizeClaimed(options?: EventOptions, cb?: Callback<PrizeClaimed>): EventEmitter;
+        Paused(cb?: Callback<Paused>): EventEmitter;
+        Paused(options?: EventOptions, cb?: Callback<Paused>): EventEmitter;
+        CEOTransferred(cb?: Callback<CEOTransferred>): EventEmitter;
+        CEOTransferred(options?: EventOptions, cb?: Callback<CEOTransferred>): EventEmitter;
+        COOTransferred(cb?: Callback<COOTransferred>): EventEmitter;
+        COOTransferred(options?: EventOptions, cb?: Callback<COOTransferred>): EventEmitter;
+        CFOTransferred(cb?: Callback<CFOTransferred>): EventEmitter;
+        CFOTransferred(options?: EventOptions, cb?: Callback<CFOTransferred>): EventEmitter;
+        allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+    };
+    once(event: "DuelStart", cb: Callback<DuelStart>): void;
+    once(event: "DuelStart", options: EventOptions, cb: Callback<DuelStart>): void;
+    once(event: "DuelEnd", cb: Callback<DuelEnd>): void;
+    once(event: "DuelEnd", options: EventOptions, cb: Callback<DuelEnd>): void;
+    once(event: "DuelTimeOut", cb: Callback<DuelTimeOut>): void;
+    once(event: "DuelTimeOut", options: EventOptions, cb: Callback<DuelTimeOut>): void;
+    once(event: "WizardElimination", cb: Callback<WizardElimination>): void;
+    once(event: "WizardElimination", options: EventOptions, cb: Callback<WizardElimination>): void;
+    once(event: "AscensionStart", cb: Callback<AscensionStart>): void;
+    once(event: "AscensionStart", options: EventOptions, cb: Callback<AscensionStart>): void;
+    once(event: "AscensionPairUp", cb: Callback<AscensionPairUp>): void;
+    once(event: "AscensionPairUp", options: EventOptions, cb: Callback<AscensionPairUp>): void;
+    once(event: "AscensionComplete", cb: Callback<AscensionComplete>): void;
+    once(event: "AscensionComplete", options: EventOptions, cb: Callback<AscensionComplete>): void;
+    once(event: "Revive", cb: Callback<Revive>): void;
+    once(event: "Revive", options: EventOptions, cb: Callback<Revive>): void;
+    once(event: "PowerGifted", cb: Callback<PowerGifted>): void;
+    once(event: "PowerGifted", options: EventOptions, cb: Callback<PowerGifted>): void;
+    once(event: "PrizeClaimed", cb: Callback<PrizeClaimed>): void;
+    once(event: "PrizeClaimed", options: EventOptions, cb: Callback<PrizeClaimed>): void;
+    once(event: "Paused", cb: Callback<Paused>): void;
+    once(event: "Paused", options: EventOptions, cb: Callback<Paused>): void;
+    once(event: "CEOTransferred", cb: Callback<CEOTransferred>): void;
+    once(event: "CEOTransferred", options: EventOptions, cb: Callback<CEOTransferred>): void;
+    once(event: "COOTransferred", cb: Callback<COOTransferred>): void;
+    once(event: "COOTransferred", options: EventOptions, cb: Callback<COOTransferred>): void;
+    once(event: "CFOTransferred", cb: Callback<CFOTransferred>): void;
+    once(event: "CFOTransferred", options: EventOptions, cb: Callback<CFOTransferred>): void;
+}

package/lib/typechain/contracts/CheezeWizardsBasicTournamentAbi.js

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

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

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

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

@@ -0,0 +1,189 @@
+/// <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 OwnershipTransferred = ContractEventLog<{
+    previousOwner: string;
+    newOwner: string;
+    0: string;
+    1: string;
+}>;
+export declare type Transfer = ContractEventLog<{
+    _from: string;
+    _to: string;
+    _tokenId: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export declare type Approval = ContractEventLog<{
+    _owner: string;
+    _approved: string;
+    _tokenId: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export declare type ApprovalForAll = ContractEventLog<{
+    _owner: string;
+    _operator: string;
+    _approved: boolean;
+    0: string;
+    1: string;
+    2: boolean;
+}>;
+export declare type CreateEstate = ContractEventLog<{
+    _owner: string;
+    _estateId: string;
+    _data: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export declare type AddLand = ContractEventLog<{
+    _estateId: string;
+    _landId: string;
+    0: string;
+    1: string;
+}>;
+export declare type RemoveLand = ContractEventLog<{
+    _estateId: string;
+    _landId: string;
+    _destinatary: string;
+    0: string;
+    1: string;
+    2: string;
+}>;
+export declare type Update = ContractEventLog<{
+    _assetId: string;
+    _holder: string;
+    _operator: string;
+    _data: string;
+    0: string;
+    1: string;
+    2: string;
+    3: string;
+}>;
+export declare type UpdateOperator = ContractEventLog<{
+    _estateId: string;
+    _operator: string;
+    0: string;
+    1: string;
+}>;
+export declare type SetLANDRegistry = ContractEventLog<{
+    _registry: string;
+    0: string;
+}>;
+export declare type Migrated = ContractEventLog<{
+    contractName: string;
+    migrationId: string;
+    0: string;
+    1: string;
+}>;
+export interface DecentralandEstatesAbi extends BaseContract {
+    constructor(jsonInterface: any[], address?: string, options?: ContractOptions): DecentralandEstatesAbi;
+    clone(): DecentralandEstatesAbi;
+    methods: {
+        supportsInterface(_interfaceId: string | number[]): NonPayableTransactionObject<boolean>;
+        name(): NonPayableTransactionObject<string>;
+        "initialize(string,string,address)"(_name: string, _symbol: string, _registry: string): NonPayableTransactionObject<void>;
+        "initialize(string,string)"(_name: string, _symbol: string): NonPayableTransactionObject<void>;
+        "initialize()"(): NonPayableTransactionObject<void>;
+        "initialize(address)"(_sender: string): NonPayableTransactionObject<void>;
+        getApproved(_tokenId: number | string | BN): NonPayableTransactionObject<string>;
+        approve(_to: string, _tokenId: number | string | BN): NonPayableTransactionObject<void>;
+        landIdEstate(arg0: number | string | BN): NonPayableTransactionObject<string>;
+        onERC721Received(_operator: string, _from: string, _tokenId: number | string | BN, _data: string | number[]): NonPayableTransactionObject<string>;
+        getFingerprint(estateId: number | string | BN): NonPayableTransactionObject<string>;
+        totalSupply(): NonPayableTransactionObject<string>;
+        transferFrom(_from: string, _to: string, _tokenId: number | string | BN): NonPayableTransactionObject<void>;
+        updateLandData(estateId: number | string | BN, landId: number | string | BN, data: string): NonPayableTransactionObject<void>;
+        tokenOfOwnerByIndex(_owner: string, _index: number | string | BN): NonPayableTransactionObject<string>;
+        estateLandIds(arg0: number | string | BN, arg1: number | string | BN): NonPayableTransactionObject<string>;
+        transferManyLands(estateId: number | string | BN, landIds: (number | string | BN)[], destinatary: string): NonPayableTransactionObject<void>;
+        updateManyLandData(estateId: number | string | BN, landIds: (number | string | BN)[], data: string): NonPayableTransactionObject<void>;
+        "safeTransferFrom(address,address,uint256)"(_from: string, _to: string, _tokenId: number | string | BN): NonPayableTransactionObject<void>;
+        "safeTransferFrom(address,address,uint256,bytes)"(_from: string, _to: string, _tokenId: number | string | BN, _data: string | number[]): NonPayableTransactionObject<void>;
+        exists(_tokenId: number | string | BN): NonPayableTransactionObject<boolean>;
+        tokenByIndex(_index: number | string | BN): NonPayableTransactionObject<string>;
+        setLANDRegistry(_registry: string): NonPayableTransactionObject<void>;
+        updateMetadata(estateId: number | string | BN, metadata: string): NonPayableTransactionObject<void>;
+        ping(): NonPayableTransactionObject<void>;
+        ownerOf(_tokenId: number | string | BN): NonPayableTransactionObject<string>;
+        isUpdateAuthorized(operator: string, estateId: number | string | BN): NonPayableTransactionObject<boolean>;
+        balanceOf(_owner: string): NonPayableTransactionObject<string>;
+        "safeTransferManyFrom(address,address,uint256[])"(from: string, to: string, estateIds: (number | string | BN)[]): NonPayableTransactionObject<void>;
+        "safeTransferManyFrom(address,address,uint256[],bytes)"(from: string, to: string, estateIds: (number | string | BN)[], data: string | number[]): NonPayableTransactionObject<void>;
+        registry(): NonPayableTransactionObject<string>;
+        owner(): NonPayableTransactionObject<string>;
+        verifyFingerprint(estateId: number | string | BN, fingerprint: string | number[]): NonPayableTransactionObject<boolean>;
+        symbol(): NonPayableTransactionObject<string>;
+        updateOperator(arg0: number | string | BN): NonPayableTransactionObject<string>;
+        estateLandIndex(arg0: number | string | BN, arg1: number | string | BN): NonPayableTransactionObject<string>;
+        setApprovalForAll(_to: string, _approved: boolean): NonPayableTransactionObject<void>;
+        transferLand(estateId: number | string | BN, landId: number | string | BN, destinatary: string): NonPayableTransactionObject<void>;
+        getMetadata(estateId: number | string | BN): NonPayableTransactionObject<string>;
+        setUpdateOperator(estateId: number | string | BN, operator: string): NonPayableTransactionObject<void>;
+        getLandEstateId(landId: number | string | BN): NonPayableTransactionObject<string>;
+        isMigrated(contractName: string, migrationId: string): NonPayableTransactionObject<boolean>;
+        tokenURI(_tokenId: number | string | BN): NonPayableTransactionObject<string>;
+        mint(to: string, metadata: string): NonPayableTransactionObject<string>;
+        isApprovedForAll(_owner: string, _operator: string): NonPayableTransactionObject<boolean>;
+        transferOwnership(newOwner: string): NonPayableTransactionObject<void>;
+        getEstateSize(estateId: number | string | BN): NonPayableTransactionObject<string>;
+    };
+    events: {
+        OwnershipTransferred(cb?: Callback<OwnershipTransferred>): EventEmitter;
+        OwnershipTransferred(options?: EventOptions, cb?: Callback<OwnershipTransferred>): 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;
+        ApprovalForAll(cb?: Callback<ApprovalForAll>): EventEmitter;
+        ApprovalForAll(options?: EventOptions, cb?: Callback<ApprovalForAll>): EventEmitter;
+        CreateEstate(cb?: Callback<CreateEstate>): EventEmitter;
+        CreateEstate(options?: EventOptions, cb?: Callback<CreateEstate>): EventEmitter;
+        AddLand(cb?: Callback<AddLand>): EventEmitter;
+        AddLand(options?: EventOptions, cb?: Callback<AddLand>): EventEmitter;
+        RemoveLand(cb?: Callback<RemoveLand>): EventEmitter;
+        RemoveLand(options?: EventOptions, cb?: Callback<RemoveLand>): EventEmitter;
+        Update(cb?: Callback<Update>): EventEmitter;
+        Update(options?: EventOptions, cb?: Callback<Update>): EventEmitter;
+        UpdateOperator(cb?: Callback<UpdateOperator>): EventEmitter;
+        UpdateOperator(options?: EventOptions, cb?: Callback<UpdateOperator>): EventEmitter;
+        SetLANDRegistry(cb?: Callback<SetLANDRegistry>): EventEmitter;
+        SetLANDRegistry(options?: EventOptions, cb?: Callback<SetLANDRegistry>): EventEmitter;
+        Migrated(cb?: Callback<Migrated>): EventEmitter;
+        Migrated(options?: EventOptions, cb?: Callback<Migrated>): EventEmitter;
+        allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+    };
+    once(event: "OwnershipTransferred", cb: Callback<OwnershipTransferred>): void;
+    once(event: "OwnershipTransferred", options: EventOptions, cb: Callback<OwnershipTransferred>): 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;
+    once(event: "ApprovalForAll", cb: Callback<ApprovalForAll>): void;
+    once(event: "ApprovalForAll", options: EventOptions, cb: Callback<ApprovalForAll>): void;
+    once(event: "CreateEstate", cb: Callback<CreateEstate>): void;
+    once(event: "CreateEstate", options: EventOptions, cb: Callback<CreateEstate>): void;
+    once(event: "AddLand", cb: Callback<AddLand>): void;
+    once(event: "AddLand", options: EventOptions, cb: Callback<AddLand>): void;
+    once(event: "RemoveLand", cb: Callback<RemoveLand>): void;
+    once(event: "RemoveLand", options: EventOptions, cb: Callback<RemoveLand>): void;
+    once(event: "Update", cb: Callback<Update>): void;
+    once(event: "Update", options: EventOptions, cb: Callback<Update>): void;
+    once(event: "UpdateOperator", cb: Callback<UpdateOperator>): void;
+    once(event: "UpdateOperator", options: EventOptions, cb: Callback<UpdateOperator>): void;
+    once(event: "SetLANDRegistry", cb: Callback<SetLANDRegistry>): void;
+    once(event: "SetLANDRegistry", options: EventOptions, cb: Callback<SetLANDRegistry>): void;
+    once(event: "Migrated", cb: Callback<Migrated>): void;
+    once(event: "Migrated", options: EventOptions, cb: Callback<Migrated>): void;
+}

package/lib/typechain/contracts/DecentralandEstatesAbi.js

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

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

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