namicorn/build/Namicorn.test.js

"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
var __generator = (this && this.__generator) || function (thisArg, body) {
    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
    function verb(n) { return function (v) { return step([n, v]); }; }
    function step(op) {
        if (f) throw new TypeError("Generator is already executing.");
        while (_) try {
            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
            if (y = 0, t) op = [op[0] & 2, t.value];
            switch (op[0]) {
                case 0: case 1: t = op; break;
                case 4: _.label++; return { value: op[1], done: false };
                case 5: _.label++; y = op[1]; op = [0]; continue;
                case 7: op = _.ops.pop(); _.trys.pop(); continue;
                default:
                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
                    if (t[2]) _.ops.pop();
                    _.trys.pop(); continue;
            }
            op = body.call(thisArg, _);
        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
    }
};
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
    result["default"] = mod;
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
var nock_1 = __importDefault(require("nock"));
var _1 = __importStar(require("."));
var mockData_json_1 = __importDefault(require("./testData/mockData.json"));
var ens_1 = __importDefault(require("./ens"));
var types_1 = require("./types");
var DefaultUrl = 'https://unstoppabledomains.com/api/v1';
var MainnetUrl = 'https://mainnet.infura.io';
var ZilliqaUrl = 'https://api.zilliqa.com';
var mockAsyncMethod = function (object, method, value) {
    if (!process.env.LIVE)
        return jest.spyOn(object, method).mockResolvedValue(value);
    else
        return jest.spyOn(object, method);
};
var mockAsyncMethods = function (object, methods) {
    return Object.entries(methods).map(function (method) {
        return mockAsyncMethod(object, method[0], method[1]);
    });
};
var expectSpyToBeCalled = function (spies) {
    if (!process.env.LIVE) {
        spies.forEach(function (spy) { return expect(spy).toBeCalled(); });
    }
};
var mockAPICalls = function (testName, url) {
    if (url === void 0) { url = MainnetUrl; }
    if (process.env.LIVE) {
        return;
    }
    var mcdt = mockData_json_1.default;
    var mockCall = mcdt[testName];
    mockCall.forEach(function (_a) {
        var METHOD = _a.METHOD, REQUEST = _a.REQUEST, RESPONSE = _a.RESPONSE;
        switch (METHOD) {
            case 'POST': {
                nock_1.default(url)
                    // .log()
                    .post('/', JSON.stringify(REQUEST))
                    .reply(200, JSON.stringify(RESPONSE));
            }
            default: {
                nock_1.default(url)
                    // .log()
                    .get(REQUEST)
                    .reply(200, RESPONSE);
            }
        }
    });
};
var expectResolutionErrorCode = function (callback, code) { return __awaiter(void 0, void 0, void 0, function () {
    var error_1;
    return __generator(this, function (_a) {
        switch (_a.label) {
            case 0:
                _a.trys.push([0, 4, , 5]);
                if (!(callback instanceof Promise)) return [3 /*break*/, 2];
                return [4 /*yield*/, callback];
            case 1:
                _a.sent();
                return [3 /*break*/, 3];
            case 2:
                callback();
                _a.label = 3;
            case 3: return [3 /*break*/, 5];
            case 4:
                error_1 = _a.sent();
                if (error_1 instanceof _1.ResolutionError) {
                    return [2 /*return*/, expect(error_1.code).toEqual(code)];
                }
                else {
                    throw error_1;
                }
                return [3 /*break*/, 5];
            case 5:
                expect(true).toBeFalsy();
                return [2 /*return*/];
        }
    });
}); };
beforeEach(function () {
    nock_1.default.cleanAll();
    jest.restoreAllMocks();
});
describe('Unstoppable API', function () {
    it('resolves a domain', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, result;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    mockAPICalls('ud_api_generic_test', DefaultUrl);
                    namicorn = new _1.default({ blockchain: false });
                    return [4 /*yield*/, namicorn.address('cofounding.zil', 'eth')];
                case 1:
                    result = _a.sent();
                    expect(result).toEqual('0xaa91734f90795e80751c96e682a321bb3c1a4186');
                    return [2 /*return*/];
            }
        });
    }); });
    it('namehashes zil domain', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({ blockchain: false });
            expect(namicorn.namehash('cofounding.zil')).toEqual('0x1cc365ffd60bb50538e01d24c1f1e26c887c36f26a0de250660b8a1465c60667');
            return [2 /*return*/];
        });
    }); });
    it('supports zil and eth domains', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({ blockchain: false });
            expect(namicorn.isSupportedDomain('cofounding.zil')).toEqual(true);
            expect(namicorn.isSupportedDomain('cofounding.eth')).toEqual(true);
            expect(namicorn.isSupportedDomain('cofounding.unknown')).toEqual(false);
            return [2 /*return*/];
        });
    }); });
    it('throws NamingServiceDown on FetchError', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, error;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default({ blockchain: false });
                    error = new Error();
                    error.name = 'FetchError';
                    jest.spyOn(namicorn.api, 'fetch').mockRejectedValue(error);
                    return [4 /*yield*/, expectResolutionErrorCode(namicorn.resolve('hello.zil'), _1.ResolutionErrorCode.NamingServiceDown)];
                case 1:
                    _a.sent();
                    return [2 /*return*/];
            }
        });
    }); });
    it('returns owner of the domain', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, _a;
        return __generator(this, function (_b) {
            switch (_b.label) {
                case 0:
                    namicorn = new _1.default({ blockchain: false });
                    mockAPICalls('ud_api_generic_test', DefaultUrl);
                    _a = expect;
                    return [4 /*yield*/, namicorn.owner('cofounding.zil')];
                case 1:
                    _a.apply(void 0, [_b.sent()]).toEqual('zil1ye72zl5t8wl5n3f2fsa5w0x7hja0jqj7mhct23');
                    return [2 /*return*/];
            }
        });
    }); });
});
describe('ZNS', function () {
    it('resolves .zil name using blockchain', function () { return __awaiter(void 0, void 0, void 0, function () {
        var testName, namicorn, result;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    testName = 'resolves .zil name using blockchain';
                    mockAPICalls('zil_using_blockchain', ZilliqaUrl);
                    namicorn = new _1.default({ blockchain: { zns: ZilliqaUrl } });
                    return [4 /*yield*/, namicorn.resolve('cofounding.zil')];
                case 1:
                    result = _a.sent();
                    expect(result).toBeDefined();
                    expect(result.addresses.ETH).toEqual('0xaa91734f90795e80751c96e682a321bb3c1a4186');
                    expect(result.meta.owner).toEqual('zil1ye72zl5t8wl5n3f2fsa5w0x7hja0jqj7mhct23');
                    expect(result.meta.type).toEqual('zns');
                    expect(result.meta.ttl).toEqual(0);
                    return [2 /*return*/];
            }
        });
    }); });
    it('supports root "zil" domain', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default();
            expect(namicorn.namehash('zil')).toEqual('0x9915d0456b878862e822e2361da37232f626a2e47505c8795134a95d36138ed3');
            return [2 /*return*/];
        });
    }); });
    it('resolves unclaimed domain using blockchain', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, result, _a, _b;
        return __generator(this, function (_c) {
            switch (_c.label) {
                case 0:
                    namicorn = new _1.default({ blockchain: true });
                    return [4 /*yield*/, namicorn.resolve('test.zil')];
                case 1:
                    result = _c.sent();
                    _a = expect;
                    return [4 /*yield*/, namicorn.address('test.zil', 'ETH')];
                case 2:
                    _a.apply(void 0, [_c.sent()]).toEqual(null);
                    _b = expect;
                    return [4 /*yield*/, namicorn.owner('test.zil')];
                case 3:
                    _b.apply(void 0, [_c.sent()]).toEqual(null);
                    return [2 /*return*/];
            }
        });
    }); });
    it('resolves domain using blockchain #2', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, result;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default({ blockchain: true });
                    return [4 /*yield*/, namicorn.resolve('test-manage-one.zil')];
                case 1:
                    result = _a.sent();
                    expect(result.addresses).toEqual({ BURST: 'BURST-R7KK-SBSY-FENX-AWYMW' });
                    expect(result.meta).toEqual({
                        owner: 'zil1zzpjwyp2nu29pcv3sh04qxq9x5l45vke0hrwec',
                        type: 'zns',
                        ttl: 0,
                    });
                    return [2 /*return*/];
            }
        });
    }); });
    it("doesn't support zil domain when zns is disabled", function () {
        var namicorn = new _1.default({ blockchain: { zns: false } });
        expect(namicorn.zns).toBeUndefined();
        expect(namicorn.isSupportedDomain('hello.zil')).toBeFalsy();
    });
    it('checks normalizeSource zns (boolean)', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({ blockchain: { zns: true } });
            expect(namicorn.zns.network).toBe('mainnet');
            expect(namicorn.zns.url).toBe('https://api.zilliqa.com');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource zns (boolean - false)', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({ blockchain: { zns: false } });
            expect(namicorn.zns).toBeUndefined();
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource zns (string)', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: { zns: 'https://api.zilliqa.com' },
            });
            expect(namicorn.zns.network).toBe('mainnet');
            expect(namicorn.zns.url).toBe('https://api.zilliqa.com');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource zns wrong string', function () { return __awaiter(void 0, void 0, void 0, function () {
        return __generator(this, function (_a) {
            expect(function () { return new _1.default({ blockchain: { zns: 'https://wrongurl.com' } }); }).toThrowError('Unspecified network in Namicorn ZNS configuration');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource zns (object) #1', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: { zns: { url: 'https://api.zilliqa.com' } },
            });
            expect(namicorn.zns.network).toBe('mainnet');
            expect(namicorn.zns.url).toBe('https://api.zilliqa.com');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource zns (object) #2', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({ blockchain: { zns: { network: 333 } } });
            expect(namicorn.zns.url).toBe('https://dev-api.zilliqa.com');
            expect(namicorn.zns.network).toBe('testnet');
            expect(namicorn.zns.registryAddress).toBeUndefined();
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource zns (object) #3', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: { zns: { url: 'https://api.zilliqa.com' } },
            });
            expect(namicorn.zns.network).toBe('mainnet');
            expect(namicorn.zns.url).toBe('https://api.zilliqa.com');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource zns (object) #4', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: { zns: { url: 'https://api.zilliqa.com', network: 1 } },
            });
            expect(namicorn.zns.network).toBe('mainnet');
            expect(namicorn.zns.url).toBe('https://api.zilliqa.com');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource zns (object) #5', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: { zns: { url: 'https://api.zilliqa.com', network: 333 } },
            });
            expect(namicorn.zns.url).toBe('https://api.zilliqa.com');
            expect(namicorn.zns.network).toBe('testnet');
            expect(namicorn.zns.registryAddress).toBeUndefined();
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource zns (object) #6', function () { return __awaiter(void 0, void 0, void 0, function () {
        return __generator(this, function (_a) {
            expect(function () { return new _1.default({ blockchain: { zns: { network: 42 } } }); }).toThrowError('Unspecified network in Namicorn ZNS configuration');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource zns (object) #7', function () { return __awaiter(void 0, void 0, void 0, function () {
        return __generator(this, function (_a) {
            expect(function () { return new _1.default({ blockchain: { zns: { network: 'invalid' } } }); }).toThrowError('Unspecified url in Namicorn ZNS configuration');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource zns (object) #8', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: { zns: { network: 'mainnet' } },
            });
            expect(namicorn.zns.network).toBe('mainnet');
            expect(namicorn.zns.url).toBe('https://api.zilliqa.com');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource zns (object) #9', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: { zns: { network: 'testnet' } },
            });
            expect(namicorn.zns.network).toBe('testnet');
            expect(namicorn.zns.url).toBe('https://dev-api.zilliqa.com');
            expect(namicorn.zns.registryAddress).toBeUndefined();
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource zns (object) #10', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: {
                    zns: { registry: 'zil1jcgu2wlx6xejqk9jw3aaankw6lsjzeunx2j0jz' },
                },
            });
            expect(namicorn.zns.network).toBe('mainnet');
            expect(namicorn.zns.registryAddress).toBe('zil1jcgu2wlx6xejqk9jw3aaankw6lsjzeunx2j0jz');
            expect(namicorn.zns.url).toBe('https://api.zilliqa.com');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource zns (object) #11', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: {
                    zns: { registry: '0xabcffff1231586348194fcabbeff1231240234fc' },
                },
            });
            expect(namicorn.zns.network).toBe('mainnet');
            expect(namicorn.zns.url).toBe('https://api.zilliqa.com');
            expect(namicorn.zns.registryAddress).toBe('zil1408llufrzkrrfqv5lj4malcjxyjqyd8urd7xz6');
            return [2 /*return*/];
        });
    }); });
    it('should resolve with resolution key setuped', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, eye, secondEye, result;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default();
                    eye = mockAsyncMethod(namicorn.zns, 'getRecordsAddresses', [
                        'zil194qcjskuuxh6qtg8xw3qqrr3kdc6dtq8ct6j9s',
                        '0xdac22230adfe4601f00631eae92df6d77f054891',
                    ]);
                    secondEye = mockAsyncMethod(namicorn.zns, 'getResolverRecords', {
                        'crypto.BCH.address': 'qrq4sk49ayvepqz7j7ep8x4km2qp8lauvcnzhveyu6',
                        'crypto.BTC.address': '1EVt92qQnaLDcmVFtHivRJaunG2mf2C3mB',
                        'crypto.DASH.address': 'XnixreEBqFuSLnDSLNbfqMH1GsZk7cgW4j',
                        'crypto.ETH.address': '0x45b31e01AA6f42F0549aD482BE81635ED3149abb',
                        'crypto.LTC.address': 'LetmswTW3b7dgJ46mXuiXMUY17XbK29UmL',
                        'crypto.XMR.address': '447d7TVFkoQ57k3jm3wGKoEAkfEym59mK96Xw5yWamDNFGaLKW5wL2qK5RMTDKGSvYfQYVN7dLSrLdkwtKH3hwbSCQCu26d',
                        'crypto.ZEC.address': 't1h7ttmQvWCSH1wfrcmvT4mZJfGw2DgCSqV',
                        'crypto.ZIL.address': 'zil1yu5u4hegy9v3xgluweg4en54zm8f8auwxu0xxj',
                        'ipfs.html.value': 'QmVaAtQbi3EtsfpKoLzALm6vXphdi2KjMgxEDKeGg6wHuK',
                        'ipfs.redirect_domain.value': 'www.unstoppabledomains.com',
                    });
                    return [4 /*yield*/, namicorn.zns.resolution('brad.zil')];
                case 1:
                    result = _a.sent();
                    expectSpyToBeCalled([eye, secondEye]);
                    expect(result).toEqual({
                        crypto: {
                            BCH: { address: 'qrq4sk49ayvepqz7j7ep8x4km2qp8lauvcnzhveyu6' },
                            BTC: { address: '1EVt92qQnaLDcmVFtHivRJaunG2mf2C3mB' },
                            DASH: { address: 'XnixreEBqFuSLnDSLNbfqMH1GsZk7cgW4j' },
                            ETH: { address: '0x45b31e01AA6f42F0549aD482BE81635ED3149abb' },
                            LTC: { address: 'LetmswTW3b7dgJ46mXuiXMUY17XbK29UmL' },
                            XMR: {
                                address: '447d7TVFkoQ57k3jm3wGKoEAkfEym59mK96Xw5yWamDNFGaLKW5wL2qK5RMTDKGSvYfQYVN7dLSrLdkwtKH3hwbSCQCu26d',
                            },
                            ZEC: { address: 't1h7ttmQvWCSH1wfrcmvT4mZJfGw2DgCSqV' },
                            ZIL: { address: 'zil1yu5u4hegy9v3xgluweg4en54zm8f8auwxu0xxj' },
                        },
                        ipfs: {
                            html: { value: 'QmVaAtQbi3EtsfpKoLzALm6vXphdi2KjMgxEDKeGg6wHuK' },
                            redirect_domain: { value: 'www.unstoppabledomains.com' },
                        },
                    });
                    return [2 /*return*/];
            }
        });
    }); });
    it('should resolve with resolution key setuped #2', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, eye, secondEye, result;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default();
                    eye = mockAsyncMethod(namicorn.zns, 'getRecordsAddresses', [
                        'zil1f6vyj5hgvll3xtx5kuxd8ucn66x9zxmkp34agy',
                        '0xa9b1d3647e4deb9ce4e601c2c9e0a2fdf2d7415a',
                    ]);
                    secondEye = mockAsyncMethod(namicorn.zns, 'getResolverRecords', {
                        'ipfs.html.hash': 'QmefehFs5n8yQcGCVJnBMY3Hr6aMRHtsoniAhsM1KsHMSe',
                        'ipfs.html.value': 'QmVaAtQbi3EtsfpKoLzALm6vXphdi2KjMgxEDKeGg6wHu',
                        'ipfs.redirect_domain.value': 'www.unstoppabledomains.com',
                        'whois.email.value': 'matt+test@unstoppabledomains.com',
                        'whois.for_sale.value': 'true',
                    });
                    return [4 /*yield*/, namicorn.zns.resolution('ergergergerg.zil')];
                case 1:
                    result = _a.sent();
                    expectSpyToBeCalled([eye, secondEye]);
                    expect(result).toEqual({
                        ipfs: {
                            html: {
                                hash: 'QmefehFs5n8yQcGCVJnBMY3Hr6aMRHtsoniAhsM1KsHMSe',
                                value: 'QmVaAtQbi3EtsfpKoLzALm6vXphdi2KjMgxEDKeGg6wHu',
                            },
                            redirect_domain: { value: 'www.unstoppabledomains.com' },
                        },
                        whois: {
                            email: { value: 'matt+test@unstoppabledomains.com' },
                            for_sale: { value: 'true' },
                        },
                    });
                    return [2 /*return*/];
            }
        });
    }); });
    it('should resolve with resolution key setuped #3', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, zns, result;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default();
                    zns = namicorn.zns;
                    expect(zns).toBeDefined();
                    return [4 /*yield*/, zns.resolution('invalid.domain')];
                case 1:
                    result = _a.sent();
                    expect(result).toEqual({});
                    return [2 /*return*/];
            }
        });
    }); });
    it('should resolve with resolution key setuped #4', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, zns, result;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default();
                    zns = namicorn.zns;
                    expect(zns).toBeDefined();
                    return [4 /*yield*/, zns.resolution('mcafee2020.zil')];
                case 1:
                    result = _a.sent();
                    expect(result).toEqual({
                        crypto: {
                            BTC: { address: '17LV6fxL8b1pJomn5zoDR3ZCnbt88ehGBf' },
                            ETH: { address: '0x0ed6180ef7c638064b9b17ff53ba76ec7077dd95' },
                            LTC: { address: 'MTbeoMfWqEZaaZVG1yE1ENoxVGNmMAxoEj' },
                        },
                        whois: {
                            email: { value: 'jordanb_970@hotmail.com' },
                            for_sale: { value: 'true' },
                        },
                    });
                    return [2 /*return*/];
            }
        });
    }); });
    // BREAKS RANDOMLY...
    // it('should check for wrong interface on zns', async () => {
    //   const namicorn = new Namicorn();
    //   const zilliqa = new Zilliqa('https://api.zilliqa.com');
    //   const { zns } = namicorn as any;
    //   expect(zns).toBeDefined();
    //   const resolver = zilliqa.contracts.at(
    //     toChecksumAddress('0xdac22230adfe4601f00631eae92df6d77f054891'),
    //   );
    //   expectResolutionErrorCode(
    //     zns.getContractField(resolver, 'unknownField'),
    //     'IncorrectResolverInterface'
    //   );
    // })
});
describe('ENS', function () {
    it('allows ens network specified as string', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: { ens: { network: 'mainnet' } },
            });
            expect(namicorn.ens.url).toBe('https://mainnet.infura.io');
            expect(namicorn.ens.network).toEqual('mainnet');
            return [2 /*return*/];
        });
    }); });
    it('resolves .eth name using blockchain', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, eyes, _a, _b;
        return __generator(this, function (_c) {
            switch (_c.label) {
                case 0:
                    namicorn = new _1.default({
                        blockchain: { ens: true },
                    });
                    expect(namicorn.ens.url).toBe('https://mainnet.infura.io');
                    expect(namicorn.ens.network).toEqual('mainnet');
                    eyes = mockAsyncMethods(namicorn.ens, {
                        getOwner: '0x825ef33943d925731FBB89C99aF5780D888bD217',
                        getResolver: '0x5FfC014343cd971B7eb70732021E26C35B744cc4',
                        fetchAddress: '0x714ef33943d925731FBB89C99aF5780D888bD106',
                    });
                    _a = expect;
                    return [4 /*yield*/, namicorn.address('matthewgould.eth', 'ETH')];
                case 1:
                    _a.apply(void 0, [_c.sent()]).toEqual('0x714ef33943d925731FBB89C99aF5780D888bD106');
                    _b = expect;
                    return [4 /*yield*/, namicorn.owner('matthewgould.eth')];
                case 2:
                    _b.apply(void 0, [_c.sent()]).toEqual('0x825ef33943d925731FBB89C99aF5780D888bD217');
                    expectSpyToBeCalled(eyes);
                    return [2 /*return*/];
            }
        });
    }); });
    it('reverses address to ENS domain', function () { return __awaiter(void 0, void 0, void 0, function () {
        var ens, eyes, result;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    ens = new ens_1.default(MainnetUrl);
                    eyes = mockAsyncMethods(ens, {
                        resolverCallToName: 'adrian.argent.xyz',
                        getResolver: '0xDa1756Bb923Af5d1a05E277CB1E54f1D0A127890',
                    });
                    return [4 /*yield*/, ens.reverse('0xb0E7a465D255aE83eb7F8a50504F3867B945164C', 'ETH')];
                case 1:
                    result = _a.sent();
                    expectSpyToBeCalled(eyes);
                    expect(result).toEqual('adrian.argent.xyz');
                    return [2 /*return*/];
            }
        });
    }); });
    it('reverses address to ENS domain null', function () { return __awaiter(void 0, void 0, void 0, function () {
        var ens, spy, result;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    ens = new ens_1.default(MainnetUrl);
                    spy = mockAsyncMethod(ens, 'getResolver', types_1.NullAddress);
                    return [4 /*yield*/, ens.reverse('0x112234455c3a32fd11230c42e7bccd4a84e02010', 'ETH')];
                case 1:
                    result = _a.sent();
                    expectSpyToBeCalled([spy]);
                    expect(result).toEqual(null);
                    return [2 /*return*/];
            }
        });
    }); });
    it('resolves .xyz name using ENS blockchain', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, eyes, result;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default({
                        blockchain: { ens: MainnetUrl },
                    });
                    eyes = mockAsyncMethods(namicorn.ens, {
                        getOwner: '0xb0E7a465D255aE83eb7F8a50504F3867B945164C',
                        getResolver: '0xDa1756Bb923Af5d1a05E277CB1E54f1D0A127890',
                        fetchAddress: '0xb0E7a465D255aE83eb7F8a50504F3867B945164C',
                    });
                    return [4 /*yield*/, namicorn.address('adrian.argent.xyz', 'ETH')];
                case 1:
                    result = _a.sent();
                    expectSpyToBeCalled(eyes);
                    expect(result).toEqual('0xb0E7a465D255aE83eb7F8a50504F3867B945164C');
                    return [2 /*return*/];
            }
        });
    }); });
    it('resolves .luxe name using ENS blockchain', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, eyes, result;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default({
                        blockchain: { ens: MainnetUrl },
                    });
                    eyes = mockAsyncMethods(namicorn.ens, {
                        getOwner: '0xf3dE750A73C11a6a2863761E930BF5fE979d5663',
                        getResolver: '0xBD5F5ec7ed5f19b53726344540296C02584A5237',
                        fetchAddress: '0xf3dE750A73C11a6a2863761E930BF5fE979d5663',
                    });
                    return [4 /*yield*/, namicorn.address('john.luxe', 'ETH')];
                case 1:
                    result = _a.sent();
                    expectSpyToBeCalled(eyes);
                    expect(result).toEqual('0xf3dE750A73C11a6a2863761E930BF5fE979d5663');
                    return [2 /*return*/];
            }
        });
    }); });
    it('resolves .luxe name using ENS blockchain with safe null return', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, ownerEye, result;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default({
                        blockchain: { ens: MainnetUrl },
                    });
                    ownerEye = mockAsyncMethod(namicorn.ens, 'getOwner', types_1.NullAddress);
                    return [4 /*yield*/, namicorn.address('something.luxe', 'ETH')];
                case 1:
                    result = _a.sent();
                    expectSpyToBeCalled([ownerEye]);
                    expect(result).toEqual(null);
                    return [2 /*return*/];
            }
        });
    }); });
    it('resolves .luxe name using ENS blockchain with thrown error', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default({
                        blockchain: { ens: MainnetUrl },
                    });
                    return [4 /*yield*/, expectResolutionErrorCode(namicorn.addressOrThrow('something.luxe', 'ETH'), _1.ResolutionErrorCode.UnregisteredDomain)];
                case 1:
                    _a.sent();
                    return [2 /*return*/];
            }
        });
    }); });
    it('resolves name with resolver but without an owner', function () { return __awaiter(void 0, void 0, void 0, function () {
        var ens, eyes, doge;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    ens = new ens_1.default();
                    eyes = mockAsyncMethods(ens, {
                        getOwner: types_1.NullAddress,
                        getResolver: '0x226159d592E2b063810a10Ebf6dcbADA94Ed68b8',
                        callMethod: '0x76a9144620b70031f0e9437e374a2100934fba4911046088ac',
                    });
                    return [4 /*yield*/, ens.address('testthing.eth', 'DOGE')];
                case 1:
                    doge = _a.sent();
                    expectSpyToBeCalled(eyes);
                    expect(doge).toBe('DBXu2kgc3xtvCUWFcxFE3r9hEYgmuaaCyD');
                    return [2 /*return*/];
            }
        });
    }); });
    it('checks if the network is supported(true)', function () { return __awaiter(void 0, void 0, void 0, function () {
        var ens, answer;
        return __generator(this, function (_a) {
            ens = new ens_1.default({ network: 1 });
            answer = ens.isSupportedNetwork();
            expect(answer).toBe(true);
            return [2 /*return*/];
        });
    }); });
    it('checks if the network is supported(false)', function () { return __awaiter(void 0, void 0, void 0, function () {
        var ens, answer;
        return __generator(this, function (_a) {
            ens = new ens_1.default({ network: 5 });
            answer = ens.isSupportedNetwork();
            expect(answer).toBe(false);
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource ens (boolean)', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({ blockchain: { ens: true } });
            expect(namicorn.ens.network).toBe('mainnet');
            expect(namicorn.ens.url).toBe('https://mainnet.infura.io');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource ens (boolean - false)', function () { return __awaiter(void 0, void 0, void 0, function () {
        var ens;
        return __generator(this, function (_a) {
            ens = new ens_1.default({ network: 5 });
            expect(ens.network).toBe('goerli');
            expect(ens.url).toBe('https://goerli.infura.io');
            expect(ens.isSupportedNetwork()).toBeFalsy();
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource ens (object) #1', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: { ens: { url: 'https://mainnet.infura.io' } },
            });
            expect(namicorn.ens.network).toBe('mainnet');
            expect(namicorn.ens.url).toBe('https://mainnet.infura.io');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource ens (object) #2', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({ blockchain: { ens: { network: 3 } } });
            expect(namicorn.ens.network).toBe('ropsten');
            expect(namicorn.ens.url).toBe('https://ropsten.infura.io');
            expect(namicorn.ens.registryAddress).toBe('0x112234455c3a32fd11230c42e7bccd4a84e02010');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource ens (object) #3', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: { ens: { url: 'https://rinkeby.infura.io' } },
            });
            expect(namicorn.ens.network).toBe('rinkeby');
            expect(namicorn.ens.url).toBe('https://rinkeby.infura.io');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource ens (object) #4', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: { ens: { url: 'https://goerli.infura.io', network: 5 } },
            });
            expect(namicorn.ens.network).toBe('goerli');
            expect(namicorn.ens.url).toBe('https://goerli.infura.io');
            expect(namicorn.ens.registryAddress).toBeUndefined();
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource ens (object) #6', function () { return __awaiter(void 0, void 0, void 0, function () {
        return __generator(this, function (_a) {
            expect(function () { return new _1.default({ blockchain: { ens: { network: 7543 } } }); }).toThrowError('Unspecified network in Namicorn ENS configuration');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource ens (object) #7', function () { return __awaiter(void 0, void 0, void 0, function () {
        return __generator(this, function (_a) {
            expect(function () { return new _1.default({ blockchain: { ens: { network: 'invalid' } } }); }).toThrowError('Unspecified url in Namicorn ENS configuration');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource ens (object) #8', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: { ens: { network: 'mainnet' } },
            });
            expect(namicorn.ens.network).toBe('mainnet');
            expect(namicorn.ens.url).toBe('https://mainnet.infura.io');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource ens (object) #9', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: { ens: { network: 'kovan' } },
            });
            expect(namicorn.ens.network).toBe('kovan');
            expect(namicorn.ens.url).toBe('https://kovan.infura.io');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource ens (object) #10', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: {
                    ens: { registry: '0x314159265dd8dbb310642f98f50c066173c1259b' },
                },
            });
            expect(namicorn.ens.network).toBe('mainnet');
            expect(namicorn.ens.url).toBe('https://mainnet.infura.io');
            expect(namicorn.ens.registryAddress).toBe('0x314159265dd8dbb310642f98f50c066173c1259b');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource ens (object) #11', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: {
                    ens: {
                        network: 'ropsten',
                        registry: '0x112234455c3a32fd11230c42e7bccd4a84e02010',
                    },
                },
            });
            expect(namicorn.ens.network).toBe('ropsten');
            expect(namicorn.ens.url).toBe('https://ropsten.infura.io');
            expect(namicorn.ens.registryAddress).toBe('0x112234455c3a32fd11230c42e7bccd4a84e02010');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource ens (object) #12', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: {
                    ens: { registry: '0xabcffff1231586348194fcabbeff1231240234fc' },
                },
            });
            expect(namicorn.ens.network).toBe('mainnet');
            expect(namicorn.ens.url).toBe('https://mainnet.infura.io');
            expect(namicorn.ens.registryAddress).toBe('0xabcffff1231586348194fcabbeff1231240234fc');
            return [2 /*return*/];
        });
    }); });
    it('checks normalizeSource ens (object) #13', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            namicorn = new _1.default({
                blockchain: {
                    ens: { network: 'custom', url: 'https://custom.notinfura.io' },
                },
            });
            expect(namicorn.ens.network).toBe('custom');
            expect(namicorn.ens.url).toBe('https://custom.notinfura.io');
            expect(namicorn.ens.registryAddress).toBeUndefined();
            return [2 /*return*/];
        });
    }); });
    it('checks ens multicoin support #1', function () { return __awaiter(void 0, void 0, void 0, function () {
        var ens, eyes, doge;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    ens = new ens_1.default();
                    eyes = mockAsyncMethods(ens, {
                        getOwner: '0x0904Dac3347eA47d208F3Fd67402D039a3b99859',
                        getResolver: '0x226159d592E2b063810a10Ebf6dcbADA94Ed68b8',
                        callMethod: '0x76a9144620b70031f0e9437e374a2100934fba4911046088ac',
                    });
                    return [4 /*yield*/, ens.address('testthing.eth', 'DOGE')];
                case 1:
                    doge = _a.sent();
                    expectSpyToBeCalled(eyes);
                    expect(doge).toBe('DBXu2kgc3xtvCUWFcxFE3r9hEYgmuaaCyD');
                    return [2 /*return*/];
            }
        });
    }); });
    it('checks ens multicoin support #2', function () { return __awaiter(void 0, void 0, void 0, function () {
        var ens, eyes, ltc;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    ens = new ens_1.default();
                    eyes = mockAsyncMethods(ens, {
                        getOwner: '0x0904Dac3347eA47d208F3Fd67402D039a3b99859',
                        getResolver: '0x226159d592E2b063810a10Ebf6dcbADA94Ed68b8',
                        callMethod: '0xa914e8604d28ef5d2a7caafe8741e5dd4816b7cb19ea87',
                    });
                    return [4 /*yield*/, ens.address('testthing.eth', 'LTC')];
                case 1:
                    ltc = _a.sent();
                    expectSpyToBeCalled(eyes);
                    expect(ltc).toBe('MV5rN5EcX1imDS2gEh5jPJXeiW5QN8YrK3');
                    return [2 /*return*/];
            }
        });
    }); });
    it('checks ens multicoin support #3', function () { return __awaiter(void 0, void 0, void 0, function () {
        var ens, eyes, eth;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    ens = new ens_1.default();
                    eyes = mockAsyncMethods(ens, {
                        getOwner: '0x0904Dac3347eA47d208F3Fd67402D039a3b99859',
                        getResolver: '0x226159d592E2b063810a10Ebf6dcbADA94Ed68b8',
                        callMethod: '0x314159265dd8dbb310642f98f50c066173c1259b',
                    });
                    return [4 /*yield*/, ens.address('testthing.eth', 'ETH')];
                case 1:
                    eth = _a.sent();
                    expectSpyToBeCalled(eyes);
                    expect(eth).toBe('0x314159265dD8dbb310642f98f50C066173C1259b');
                    return [2 /*return*/];
            }
        });
    }); });
    it('checks ens multicoin support #4', function () { return __awaiter(void 0, void 0, void 0, function () {
        var ens, eyes, etc;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    ens = new ens_1.default();
                    eyes = mockAsyncMethods(ens, {
                        getOwner: '0x0904Dac3347eA47d208F3Fd67402D039a3b99859',
                        getResolver: '0x226159d592E2b063810a10Ebf6dcbADA94Ed68b8',
                        callMethod: '0x314159265dd8dbb310642f98f50c066173c1259b',
                    });
                    return [4 /*yield*/, ens.address('testthing.eth', 'etc')];
                case 1:
                    etc = _a.sent();
                    expectSpyToBeCalled(eyes);
                    expect(etc).toBe('0x314159265dD8dbb310642f98f50C066173C1259b');
                    return [2 /*return*/];
            }
        });
    }); });
    it('checks ens multicoin support #5', function () { return __awaiter(void 0, void 0, void 0, function () {
        var ens, eyes, rsk;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    ens = new ens_1.default();
                    eyes = mockAsyncMethods(ens, {
                        getOwner: '0x0904Dac3347eA47d208F3Fd67402D039a3b99859',
                        getResolver: '0x226159d592E2b063810a10Ebf6dcbADA94Ed68b8',
                        callMethod: '0x314159265dd8dbb310642f98f50c066173c1259b',
                    });
                    return [4 /*yield*/, ens.address('testthing.eth', 'rsk')];
                case 1:
                    rsk = _a.sent();
                    expectSpyToBeCalled(eyes);
                    expect(rsk).toBe('0x314159265dD8DbB310642F98f50C066173c1259B');
                    return [2 /*return*/];
            }
        });
    }); });
    it('checks ens multicoin support #6', function () { return __awaiter(void 0, void 0, void 0, function () {
        var ens, eyes, xrp;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    ens = new ens_1.default();
                    eyes = mockAsyncMethods(ens, {
                        getOwner: '0x0904Dac3347eA47d208F3Fd67402D039a3b99859',
                        getResolver: '0x226159d592E2b063810a10Ebf6dcbADA94Ed68b8',
                        callMethod: '0x05444b4e9c06f24296074f7bc48f92a97916c6dc5ea9000000000000000000',
                    });
                    return [4 /*yield*/, ens.address('testthing.eth', 'xrp')];
                case 1:
                    xrp = _a.sent();
                    expectSpyToBeCalled(eyes);
                    expect(xrp).toBe('X7qvLs7gSnNoKvZzNWUT2e8st17QPY64PPe7zriLNuJszeg');
                    return [2 /*return*/];
            }
        });
    }); });
    it('checks ens multicoin support #7', function () { return __awaiter(void 0, void 0, void 0, function () {
        var ens, eyes, bch;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    ens = new ens_1.default();
                    eyes = mockAsyncMethods(ens, {
                        getOwner: '0x0904Dac3347eA47d208F3Fd67402D039a3b99859',
                        getResolver: '0x226159d592E2b063810a10Ebf6dcbADA94Ed68b8',
                        callMethod: '0x76a91476a04053bda0a88bda5177b86a15c3b29f55987388ac',
                    });
                    return [4 /*yield*/, ens.address('testthing.eth', 'bch')];
                case 1:
                    bch = _a.sent();
                    expectSpyToBeCalled(eyes);
                    expect(bch).toBe('bitcoincash:qpm2qsznhks23z7629mms6s4cwef74vcwvy22gdx6a');
                    return [2 /*return*/];
            }
        });
    }); });
    it('checks ens multicoin support #8', function () { return __awaiter(void 0, void 0, void 0, function () {
        var ens, eyes, btc;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    ens = new ens_1.default();
                    eyes = mockAsyncMethods(ens, {
                        getOwner: '0x0904Dac3347eA47d208F3Fd67402D039a3b99859',
                        getResolver: '0x226159d592E2b063810a10Ebf6dcbADA94Ed68b8',
                        callMethod: '0x5128751e76e8199196d454941c45d1b3a323f1433bd6751e76e8199196d454941c45d1b3a323f1433bd6',
                    });
                    return [4 /*yield*/, ens.address('testthing.eth', 'BTC')];
                case 1:
                    btc = _a.sent();
                    expectSpyToBeCalled(eyes);
                    expect(btc).toBe('bc1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7k7grplx');
                    return [2 /*return*/];
            }
        });
    }); });
    it('checks UnsupportedCurrency error', function () { return __awaiter(void 0, void 0, void 0, function () {
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0: return [4 /*yield*/, expectResolutionErrorCode(new _1.default().addressOrThrow('testthing.eth', 'bnb'), _1.ResolutionErrorCode.UnsupportedCurrency)];
                case 1:
                    _a.sent();
                    return [2 /*return*/];
            }
        });
    }); });
    it('checks UnsupportedCurrency error', function () { return __awaiter(void 0, void 0, void 0, function () {
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0: return [4 /*yield*/, expectResolutionErrorCode(new _1.default().addressOrThrow('testthing.eth', 'UNREALTICKER'), _1.ResolutionErrorCode.UnsupportedCurrency)];
                case 1:
                    _a.sent();
                    return [2 /*return*/];
            }
        });
    }); });
});
describe('Namicorn', function () {
    it('checks Namicorn#addressOrThrow error #1', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default();
                    return [4 /*yield*/, expectResolutionErrorCode(namicorn.addressOrThrow('sdncdoncvdinvcsdncs.zil', 'ZIL'), _1.ResolutionErrorCode.UnregisteredDomain)];
                case 1:
                    _a.sent();
                    return [2 /*return*/];
            }
        });
    }); });
    it('checks Namicorn#addressOrThrow error #2', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default();
                    return [4 /*yield*/, expectResolutionErrorCode(namicorn.addressOrThrow('brad.zil', 'INVALID_CURRENCY_SYMBOL'), _1.ResolutionErrorCode.UnspecifiedCurrency)];
                case 1:
                    _a.sent();
                    return [2 /*return*/];
            }
        });
    }); });
    it('resolves non-existing domain zone with throw', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default({ blockchain: true });
                    return [4 /*yield*/, expectResolutionErrorCode(namicorn.addressOrThrow('bogdangusiev.qq', 'ZIL'), _1.ResolutionErrorCode.UnsupportedDomain)];
                case 1:
                    _a.sent();
                    return [2 /*return*/];
            }
        });
    }); });
    it('resolves non-existing domain zone via safe address', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, result;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default({ blockchain: true });
                    return [4 /*yield*/, namicorn.address('bogdangusiev.qq', 'ZIL')];
                case 1:
                    result = _a.sent();
                    expect(result).toEqual(null);
                    return [2 /*return*/];
            }
        });
    }); });
    it('provides empty response constant', function () { return __awaiter(void 0, void 0, void 0, function () {
        var response;
        return __generator(this, function (_a) {
            response = types_1.UnclaimedDomainResponse;
            expect(response.addresses).toEqual({});
            expect(response.meta.owner).toEqual(null);
            return [2 /*return*/];
        });
    }); });
    it('checks the isSupportedDomainInNetwork', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, result;
        return __generator(this, function (_a) {
            namicorn = new _1.default();
            result = namicorn.isSupportedDomainInNetwork('brad.zil');
            expect(result).toBe(true);
            return [2 /*return*/];
        });
    }); });
    it('checks namehash for unsupported domain', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default();
                    return [4 /*yield*/, expectResolutionErrorCode(function () { return namicorn.namehash('something.hello.com'); }, _1.ResolutionErrorCode.UnsupportedDomain)];
                case 1:
                    _a.sent();
                    return [2 /*return*/];
            }
        });
    }); });
    it('checks return of ipfs hash for brad.zil', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, hash;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default();
                    return [4 /*yield*/, namicorn.ipfsHash('brad.zil')];
                case 1:
                    hash = _a.sent();
                    expect(hash).toBe('QmVaAtQbi3EtsfpKoLzALm6vXphdi2KjMgxEDKeGg6wHuK');
                    return [2 /*return*/];
            }
        });
    }); });
    it('checks return of email for ergergergerg.zil', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn, email;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default();
                    return [4 /*yield*/, namicorn.email('ergergergerg.zil')];
                case 1:
                    email = _a.sent();
                    expect(email).toBe('matt+test@unstoppabledomains.com');
                    return [2 /*return*/];
            }
        });
    }); });
    it('checks error for  email on brad.zil', function () { return __awaiter(void 0, void 0, void 0, function () {
        var namicorn;
        return __generator(this, function (_a) {
            switch (_a.label) {
                case 0:
                    namicorn = new _1.default();
                    return [4 /*yield*/, expectResolutionErrorCode(namicorn.email('brad.zil'), _1.ResolutionErrorCode.RecordNotFound)];
                case 1:
                    _a.sent();
                    return [2 /*return*/];
            }
        });
    }); });
});