web3-domain-resolver/lib/resolvers/resolved-resource/resolved-resource.js

Web3 Library that enable with just one function to resolve domains on multiple web3 providers such as ENS, UnstoppableDomains and Freename

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.ResolvedResource = void 0;
const lodash_clonedeep_1 = __importDefault(require("lodash.clonedeep"));
class ResolvedResource {
    constructor(input) {
        this._fullname = input.fullname;
        this._tld = input.tld;
        this._type = input.type;
        this._tokenId = input.tokenId;
        this._resolverName = input.resolverName;
        this._resolverProvider = input.resolverProvider;
        this._network = input.network;
        this._proxyReaderAddress = input.proxyReaderAddress;
        this._proxyWriterAddress = input.proxyWriterAddress;
        this._ownerAddress = input.ownerAddress;
        this._metadataUri = input.metadataUri;
        this._imageUrl = input.imageUrl;
        this._metadata = input.metadata;
        this._records = input.records;
    }
    get metadata() {
        return this._metadata;
    }
    set metadata(value) {
        this._metadata = value;
    }
    get fullname() {
        return this._fullname;
    }
    set fullname(value) {
        this._fullname = value;
    }
    get tld() {
        return this._tld;
    }
    set tld(value) {
        this._tld = value;
    }
    get domain() {
        return this._domain;
    }
    set domain(value) {
        this._domain = value;
    }
    get type() {
        return this._type;
    }
    set type(value) {
        this._type = value;
    }
    get tokenId() {
        return this._tokenId;
    }
    set tokenId(value) {
        this._tokenId = value;
    }
    get providerName() {
        return this._resolverName;
    }
    set providerName(value) {
        this._resolverName = value;
    }
    get resolverProvider() {
        return this._resolverProvider;
    }
    set resolverProvider(value) {
        this._resolverProvider = value;
    }
    get network() {
        return this._network;
    }
    set network(value) {
        this._network = value;
    }
    get proxyReaderAddress() {
        return this._proxyReaderAddress;
    }
    set proxyReaderAddress(value) {
        this._proxyReaderAddress = value;
    }
    get proxyWriterAddress() {
        return this._proxyWriterAddress;
    }
    set proxyWriterAddress(value) {
        this._proxyWriterAddress = value;
    }
    get ownerAddress() {
        return this._ownerAddress;
    }
    set ownerAddress(value) {
        this._ownerAddress = value;
    }
    get uri() {
        return this._metadataUri;
    }
    set uri(value) {
        this._metadataUri = value;
    }
    get imageUrl() {
        return this._imageUrl;
    }
    set imageUrl(value) {
        this._imageUrl = value;
    }
    get records() {
        return this._records;
    }
    async getRecord(key) {
        return await this.resolverProvider.getRecord(this._tokenId, key, this._network);
    }
    async getManyRecords(keys) {
        return await this.resolverProvider.getManyRecords(this._tokenId, keys, this._network);
    }
    async isApprovedOrOwner(address) {
        return await this.resolverProvider.isApprovedOrOwner(this._tokenId, address, this._network);
    }
    async transfer(addressTo, signer) {
        return await this._resolverProvider.transfer(this, addressTo, signer);
    }
    async setApproved(addessToApprove, signer) {
        return await this._resolverProvider.setApproved(this, addessToApprove, signer);
    }
    async setRecord(key, value, signer) {
        return await this._resolverProvider.setRecord(this, key, value, signer);
    }
    async setRecords(keys, values, signer) {
        return await this._resolverProvider.setRecords(this, keys, values, signer);
    }
    async setReverse(signer) {
        return await this._resolverProvider.setReverse(this, signer);
    }
    async refresh() {
        let resolvedResource = await this.resolverProvider.resolve(this._fullname);
        if (resolvedResource) {
            this._fullname = resolvedResource.fullname;
            this._tld = resolvedResource.tld;
            this._type = resolvedResource.type;
            this._tokenId = resolvedResource.tokenId;
            this._resolverName = resolvedResource.providerName;
            this._network = resolvedResource.network;
            this._proxyReaderAddress = resolvedResource.proxyReaderAddress;
            this._proxyWriterAddress = resolvedResource.proxyWriterAddress;
            this._ownerAddress = resolvedResource.ownerAddress;
            this._metadataUri = resolvedResource.uri;
            this._imageUrl = resolvedResource.imageUrl;
            this._metadata = (0, lodash_clonedeep_1.default)(resolvedResource.metadata);
            this._records = (0, lodash_clonedeep_1.default)(resolvedResource.records);
            resolvedResource = undefined;
        }
        else {
            return undefined;
        }
        return this;
    }
}
exports.ResolvedResource = ResolvedResource;