@xyo-network/core 2.20.41 → 2.20.42

package/dist/esm/Test/testPayload.js

@@ -1,15 +1,15 @@
-const testSchema = 'network.xyo.test';
-const testPayload = {
-    _archive: 'test',
-    _hash: '20e14207f952a09f767ff614a648546c037fe524ace0bfe55db31f818aff1f1c',
-    _timestamp: 1609459255555,
-    numberField: 1,
-    objectField: {
-        numberField: 1,
-        stringField: 'stringValue',
-    },
-    schema: testSchema,
-    stringField: 'stringValue',
-};
-export { testPayload, testSchema };
+const testSchema = 'network.xyo.test';
+const testPayload = {
+    _archive: 'test',
+    _hash: '20e14207f952a09f767ff614a648546c037fe524ace0bfe55db31f818aff1f1c',
+    _timestamp: 1609459255555,
+    numberField: 1,
+    objectField: {
+        numberField: 1,
+        stringField: 'stringValue',
+    },
+    schema: testSchema,
+    stringField: 'stringValue',
+};
+export { testPayload, testSchema };
 //# sourceMappingURL=testPayload.js.map

package/dist/esm/Wallet/Account/Account.d.ts

@@ -1,36 +1,36 @@
-import { XyoData, XyoDataLike, XyoKeyPair, XyoPublicKey } from './Key';
-export declare const ethMessagePrefix = "\u0019Ethereum Signed Message:\n";
-export interface XyoAccountConfig {
-    privateKey?: XyoDataLike;
-    phrase?: string;
-}
-export declare class XyoAccount extends XyoKeyPair {
-    private _isXyoWallet;
-    private _previousHash?;
-    constructor({ privateKey, phrase }?: XyoAccountConfig);
-    /** @deprecated use addressValue instead */
-    get address(): string;
-    get addressValue(): import("./Key").XyoAddressValue;
-    get previousHash(): XyoData | undefined;
-    /** @deprecated use private instead */
-    get privateKey(): import("./Key").XyoPrivateKey;
-    /** @deprecated use public instead */
-    get publicKey(): XyoPublicKey;
-    sign(hash: Uint8Array | string): Uint8Array;
-    verify(msg: Uint8Array | string, signature: Uint8Array | string): boolean;
-    static fromPhrase(phrase: string): XyoAccount;
-    static fromPrivateKey(key: Uint8Array | string): XyoAccount;
-    static random(): XyoAccount;
-    static isXyoWallet(value: unknown): boolean;
-}
-/** @deprecated use XyoWallet instead */
-export declare class XyoAddress extends XyoAccount {
-    get previousHashString(): string | undefined;
-    static fromPhrase(phrase: string): XyoAccount;
-    static fromPrivateKey(key: Uint8Array | string): XyoAccount;
-    static random(): XyoAccount;
-    static verifyAddress(msg: Uint8Array | string, signature: Uint8Array | string, address: XyoDataLike): boolean;
-}
-/** @deprecated use XyoAccount instead */
-export declare class XyoWallet extends XyoAccount {
-}
+import { XyoData, XyoDataLike, XyoKeyPair, XyoPublicKey } from './Key';
+export declare const ethMessagePrefix = "\u0019Ethereum Signed Message:\n";
+export interface XyoAccountConfig {
+    privateKey?: XyoDataLike;
+    phrase?: string;
+}
+export declare class XyoAccount extends XyoKeyPair {
+    private _isXyoWallet;
+    private _previousHash?;
+    constructor({ privateKey, phrase }?: XyoAccountConfig);
+    /** @deprecated use addressValue instead */
+    get address(): string;
+    get addressValue(): import("./Key").XyoAddressValue;
+    get previousHash(): XyoData | undefined;
+    /** @deprecated use private instead */
+    get privateKey(): import("./Key").XyoPrivateKey;
+    /** @deprecated use public instead */
+    get publicKey(): XyoPublicKey;
+    sign(hash: Uint8Array | string): Uint8Array;
+    verify(msg: Uint8Array | string, signature: Uint8Array | string): boolean;
+    static fromPhrase(phrase: string): XyoAccount;
+    static fromPrivateKey(key: Uint8Array | string): XyoAccount;
+    static random(): XyoAccount;
+    static isXyoWallet(value: unknown): boolean;
+}
+/** @deprecated use XyoWallet instead */
+export declare class XyoAddress extends XyoAccount {
+    get previousHashString(): string | undefined;
+    static fromPhrase(phrase: string): XyoAccount;
+    static fromPrivateKey(key: Uint8Array | string): XyoAccount;
+    static random(): XyoAccount;
+    static verifyAddress(msg: Uint8Array | string, signature: Uint8Array | string, address: XyoDataLike): boolean;
+}
+/** @deprecated use XyoAccount instead */
+export declare class XyoWallet extends XyoAccount {
+}

package/dist/esm/Wallet/Account/Account.js

@@ -1,71 +1,71 @@
-import shajs from 'sha.js';
-import { toUint8Array, XyoData, XyoKeyPair, XyoPublicKey } from './Key';
-export const ethMessagePrefix = '\x19Ethereum Signed Message:\n';
-export class XyoAccount extends XyoKeyPair {
-    constructor({ privateKey, phrase } = {}) {
-        const privateKeyToUse = privateKey ? toUint8Array(privateKey) : phrase ? toUint8Array(shajs('sha256').update(phrase).digest('hex')) : undefined;
-        super(privateKeyToUse);
-        this._isXyoWallet = true;
-    }
-    /** @deprecated use addressValue instead */
-    get address() {
-        return this.public.address.hex;
-    }
-    get addressValue() {
-        return this.public.address;
-    }
-    get previousHash() {
-        return this._previousHash;
-    }
-    /** @deprecated use private instead */
-    get privateKey() {
-        return this.private;
-    }
-    /** @deprecated use public instead */
-    get publicKey() {
-        return this.public;
-    }
-    sign(hash) {
-        this._previousHash = new XyoData(32, hash);
-        return this.private.sign(hash);
-    }
-    verify(msg, signature) {
-        return this.public.address.verify(msg, signature);
-    }
-    static fromPhrase(phrase) {
-        const privateKey = shajs('sha256').update(phrase).digest('hex');
-        return XyoAccount.fromPrivateKey(privateKey);
-    }
-    static fromPrivateKey(key) {
-        const privateKey = toUint8Array(key);
-        return new XyoAccount({ privateKey });
-    }
-    static random() {
-        return new XyoAccount();
-    }
-    static isXyoWallet(value) {
-        return value._isXyoWallet;
-    }
-}
-/** @deprecated use XyoWallet instead */
-export class XyoAddress extends XyoAccount {
-    get previousHashString() {
-        return this.previousHash?.hex;
-    }
-    static fromPhrase(phrase) {
-        return XyoAccount.fromPhrase(phrase);
-    }
-    static fromPrivateKey(key) {
-        return XyoAccount.fromPrivateKey(key);
-    }
-    static random() {
-        return XyoAccount.random();
-    }
-    static verifyAddress(msg, signature, address) {
-        return new XyoPublicKey(address).verify(msg, signature);
-    }
-}
-/** @deprecated use XyoAccount instead */
-export class XyoWallet extends XyoAccount {
-}
+import shajs from 'sha.js';
+import { toUint8Array, XyoData, XyoKeyPair, XyoPublicKey } from './Key';
+export const ethMessagePrefix = '\x19Ethereum Signed Message:\n';
+export class XyoAccount extends XyoKeyPair {
+    constructor({ privateKey, phrase } = {}) {
+        const privateKeyToUse = privateKey ? toUint8Array(privateKey) : phrase ? toUint8Array(shajs('sha256').update(phrase).digest('hex')) : undefined;
+        super(privateKeyToUse);
+        this._isXyoWallet = true;
+    }
+    /** @deprecated use addressValue instead */
+    get address() {
+        return this.public.address.hex;
+    }
+    get addressValue() {
+        return this.public.address;
+    }
+    get previousHash() {
+        return this._previousHash;
+    }
+    /** @deprecated use private instead */
+    get privateKey() {
+        return this.private;
+    }
+    /** @deprecated use public instead */
+    get publicKey() {
+        return this.public;
+    }
+    sign(hash) {
+        this._previousHash = new XyoData(32, hash);
+        return this.private.sign(hash);
+    }
+    verify(msg, signature) {
+        return this.public.address.verify(msg, signature);
+    }
+    static fromPhrase(phrase) {
+        const privateKey = shajs('sha256').update(phrase).digest('hex');
+        return XyoAccount.fromPrivateKey(privateKey);
+    }
+    static fromPrivateKey(key) {
+        const privateKey = toUint8Array(key);
+        return new XyoAccount({ privateKey });
+    }
+    static random() {
+        return new XyoAccount();
+    }
+    static isXyoWallet(value) {
+        return value._isXyoWallet;
+    }
+}
+/** @deprecated use XyoWallet instead */
+export class XyoAddress extends XyoAccount {
+    get previousHashString() {
+        return this.previousHash?.hex;
+    }
+    static fromPhrase(phrase) {
+        return XyoAccount.fromPhrase(phrase);
+    }
+    static fromPrivateKey(key) {
+        return XyoAccount.fromPrivateKey(key);
+    }
+    static random() {
+        return XyoAccount.random();
+    }
+    static verifyAddress(msg, signature, address) {
+        return new XyoPublicKey(address).verify(msg, signature);
+    }
+}
+/** @deprecated use XyoAccount instead */
+export class XyoWallet extends XyoAccount {
+}
 //# sourceMappingURL=Account.js.map

package/dist/esm/Wallet/Account/Key/Data/AbstractData.d.ts

@@ -1,12 +1,12 @@
-/// <reference types="bn.js" />
-import { BigNumber, Buffer } from '@xylabs/sdk-js';
-export declare abstract class XyoAbstractData {
-    private _isXyoData;
-    abstract get hex(): string;
-    abstract get buffer(): Buffer;
-    abstract get bn(): BigNumber;
-    abstract get bytes(): Uint8Array;
-    abstract get keccak256(): Buffer;
-    get length(): number;
-    static isXyoData(value: unknown): boolean;
-}
+/// <reference types="bn.js" />
+import { BigNumber, Buffer } from '@xylabs/sdk-js';
+export declare abstract class XyoAbstractData {
+    private _isXyoData;
+    abstract get hex(): string;
+    abstract get buffer(): Buffer;
+    abstract get bn(): BigNumber;
+    abstract get bytes(): Uint8Array;
+    abstract get keccak256(): Buffer;
+    get length(): number;
+    static isXyoData(value: unknown): boolean;
+}

package/dist/esm/Wallet/Account/Key/Data/AbstractData.js

@@ -1,12 +1,12 @@
-export class XyoAbstractData {
-    constructor() {
-        this._isXyoData = true;
-    }
-    get length() {
-        return this.bytes.length;
-    }
-    static isXyoData(value) {
-        return value._isXyoData;
-    }
-}
+export class XyoAbstractData {
+    constructor() {
+        this._isXyoData = true;
+    }
+    get length() {
+        return this.bytes.length;
+    }
+    static isXyoData(value) {
+        return value._isXyoData;
+    }
+}
 //# sourceMappingURL=AbstractData.js.map

package/dist/esm/Wallet/Account/Key/Data/Data.d.ts

@@ -1,15 +1,15 @@
-/// <reference types="bn.js" />
-import { BigNumber, Buffer } from '@xylabs/sdk-js';
-import { XyoAbstractData } from './AbstractData';
-import { XyoDataLike } from './XyoDataLike';
-export declare class XyoData extends XyoAbstractData {
-    private _bytes?;
-    private _length;
-    constructor(length: number, bytes?: XyoDataLike);
-    private checkLength;
-    get hex(): string;
-    get buffer(): Buffer;
-    get bn(): BigNumber;
-    get bytes(): Uint8Array;
-    get keccak256(): Buffer;
-}
+/// <reference types="bn.js" />
+import { BigNumber, Buffer } from '@xylabs/sdk-js';
+import { XyoAbstractData } from './AbstractData';
+import { XyoDataLike } from './XyoDataLike';
+export declare class XyoData extends XyoAbstractData {
+    private _bytes?;
+    private _length;
+    constructor(length: number, bytes?: XyoDataLike);
+    private checkLength;
+    get hex(): string;
+    get buffer(): Buffer;
+    get bn(): BigNumber;
+    get bytes(): Uint8Array;
+    get keccak256(): Buffer;
+}

package/dist/esm/Wallet/Account/Key/Data/Data.js

@@ -1,35 +1,35 @@
-import { assertEx, BigNumber, Buffer, bufferPolyfill } from '@xylabs/sdk-js';
-import keccak256 from 'keccak256';
-import { XyoAbstractData } from './AbstractData';
-import { toUint8ArrayOptional } from './toUint8Array';
-export class XyoData extends XyoAbstractData {
-    constructor(length, bytes) {
-        super();
-        this._bytes = toUint8ArrayOptional(bytes);
-        this._length = length;
-    }
-    checkLength() {
-        assertEx(this.bytes.length === this._length, `Length Mismatch: ${this.bytes.length} !== ${this._length}`);
-    }
-    get hex() {
-        this.checkLength();
-        return Buffer.from(this.bytes).toString('hex').toLowerCase();
-    }
-    get buffer() {
-        this.checkLength();
-        return Buffer.from(this.bytes);
-    }
-    get bn() {
-        this.checkLength();
-        return new BigNumber(this.bytes);
-    }
-    get bytes() {
-        return assertEx(this._bytes, 'XyoData uninitialized');
-    }
-    get keccak256() {
-        bufferPolyfill();
-        this.checkLength();
-        return Buffer.from(keccak256(`0x${this.buffer.toString('hex')}`));
-    }
-}
+import { assertEx, BigNumber, Buffer, bufferPolyfill } from '@xylabs/sdk-js';
+import keccak256 from 'keccak256';
+import { XyoAbstractData } from './AbstractData';
+import { toUint8ArrayOptional } from './toUint8Array';
+export class XyoData extends XyoAbstractData {
+    constructor(length, bytes) {
+        super();
+        this._bytes = toUint8ArrayOptional(bytes);
+        this._length = length;
+    }
+    checkLength() {
+        assertEx(this.bytes.length === this._length, `Length Mismatch: ${this.bytes.length} !== ${this._length}`);
+    }
+    get hex() {
+        this.checkLength();
+        return Buffer.from(this.bytes).toString('hex').toLowerCase();
+    }
+    get buffer() {
+        this.checkLength();
+        return Buffer.from(this.bytes);
+    }
+    get bn() {
+        this.checkLength();
+        return new BigNumber(this.bytes);
+    }
+    get bytes() {
+        return assertEx(this._bytes, 'XyoData uninitialized');
+    }
+    get keccak256() {
+        bufferPolyfill();
+        this.checkLength();
+        return Buffer.from(keccak256(`0x${this.buffer.toString('hex')}`));
+    }
+}
 //# sourceMappingURL=Data.js.map

package/dist/esm/Wallet/Account/Key/Data/XyoDataLike.d.ts

@@ -1,4 +1,4 @@
-/// <reference types="bn.js" />
-import { BigNumber } from '@xylabs/sdk-js';
-import { XyoAbstractData } from './AbstractData';
-export declare type XyoDataLike = string | BigNumber | Uint8Array | XyoAbstractData;
+/// <reference types="bn.js" />
+import { BigNumber } from '@xylabs/sdk-js';
+import { XyoAbstractData } from './AbstractData';
+export declare type XyoDataLike = string | BigNumber | Uint8Array | XyoAbstractData;

package/dist/esm/Wallet/Account/Key/Data/XyoDataLike.js

@@ -1,2 +1,2 @@
-export {};
+export {};
 //# sourceMappingURL=XyoDataLike.js.map

package/dist/esm/Wallet/Account/Key/Data/index.d.ts

@@ -1,4 +1,4 @@
-export * from './AbstractData';
-export * from './Data';
-export * from './toUint8Array';
-export * from './XyoDataLike';
+export * from './AbstractData';
+export * from './Data';
+export * from './toUint8Array';
+export * from './XyoDataLike';

package/dist/esm/Wallet/Account/Key/Data/index.js

@@ -1,5 +1,5 @@
-export * from './AbstractData';
-export * from './Data';
-export * from './toUint8Array';
-export * from './XyoDataLike';
+export * from './AbstractData';
+export * from './Data';
+export * from './toUint8Array';
+export * from './XyoDataLike';
 //# sourceMappingURL=index.js.map

package/dist/esm/Wallet/Account/Key/Data/toUint8Array.d.ts

@@ -1,3 +1,3 @@
-import { XyoDataLike } from './XyoDataLike';
-export declare const toUint8ArrayOptional: (value?: XyoDataLike, padLength?: number) => Uint8Array | undefined;
-export declare const toUint8Array: (value: XyoDataLike, padLength?: number) => Uint8Array;
+import { XyoDataLike } from './XyoDataLike';
+export declare const toUint8ArrayOptional: (value?: XyoDataLike, padLength?: number) => Uint8Array | undefined;
+export declare const toUint8Array: (value: XyoDataLike, padLength?: number) => Uint8Array;

package/dist/esm/Wallet/Account/Key/Data/toUint8Array.js

@@ -1,31 +1,31 @@
-import { assertEx, BigNumber, Buffer } from '@xylabs/sdk-js';
-import { ifTypeOf } from '../../../../lib';
-import { XyoAbstractData } from './AbstractData';
-const stringToUint8Array = (value) => {
-    return bufferToUint8Array(Buffer.from(value.startsWith('0x') ? value.slice(2) : value, 'hex'));
-};
-const bigNumberToUint8Array = (value) => {
-    return bufferToUint8Array(Buffer.from(value.toBuffer()));
-};
-const bufferToUint8Array = (value) => {
-    return Uint8Array.from(value);
-};
-const xyoDataToUint8Array = (value) => {
-    return value.bytes;
-};
-export const toUint8ArrayOptional = (value, padLength) => {
-    return value ? toUint8Array(value, padLength) : undefined;
-};
-export const toUint8Array = (value, padLength) => {
-    let result = ifTypeOf('string', value, stringToUint8Array) ??
-        ifTypeOf('object', value, bigNumberToUint8Array, BigNumber.isBN) ??
-        ifTypeOf('object', value, bufferToUint8Array, Buffer.isBuffer) ??
-        ifTypeOf('object', value, xyoDataToUint8Array, XyoAbstractData.isXyoData) ??
-        value;
-    if (padLength && result.length < padLength) {
-        result = new Uint8Array([...new Uint8Array(padLength - result.length), ...result]);
-        assertEx(result?.length <= padLength, 'Resulting length is greater than padLength');
-    }
-    return result;
-};
+import { assertEx, BigNumber, Buffer } from '@xylabs/sdk-js';
+import { ifTypeOf } from '../../../../lib';
+import { XyoAbstractData } from './AbstractData';
+const stringToUint8Array = (value) => {
+    return bufferToUint8Array(Buffer.from(value.startsWith('0x') ? value.slice(2) : value, 'hex'));
+};
+const bigNumberToUint8Array = (value) => {
+    return bufferToUint8Array(Buffer.from(value.toBuffer()));
+};
+const bufferToUint8Array = (value) => {
+    return Uint8Array.from(value);
+};
+const xyoDataToUint8Array = (value) => {
+    return value.bytes;
+};
+export const toUint8ArrayOptional = (value, padLength) => {
+    return value ? toUint8Array(value, padLength) : undefined;
+};
+export const toUint8Array = (value, padLength) => {
+    let result = ifTypeOf('string', value, stringToUint8Array) ??
+        ifTypeOf('object', value, bigNumberToUint8Array, BigNumber.isBN) ??
+        ifTypeOf('object', value, bufferToUint8Array, Buffer.isBuffer) ??
+        ifTypeOf('object', value, xyoDataToUint8Array, XyoAbstractData.isXyoData) ??
+        value;
+    if (padLength && result.length < padLength) {
+        result = new Uint8Array([...new Uint8Array(padLength - result.length), ...result]);
+        assertEx(result?.length <= padLength, 'Resulting length is greater than padLength');
+    }
+    return result;
+};
 //# sourceMappingURL=toUint8Array.js.map

package/dist/esm/Wallet/Account/Key/XyoAddressValue.d.ts

@@ -1,11 +1,11 @@
-import { XyoDataLike } from './Data';
-import { XyoEllipticKey } from './XyoEllipticKey';
-export declare class XyoAddressValue extends XyoEllipticKey {
-    private _isXyoAddress;
-    constructor(address: XyoDataLike);
-    verify(msg: Uint8Array | string, signature: Uint8Array | string): boolean;
-    static verify(msg: Uint8Array | string, signature: Uint8Array | string, address: XyoDataLike): boolean;
-    static addressFromPublicKey(key: XyoDataLike): string;
-    static addressFromAddressOrPublicKey(bytes: XyoDataLike): string | Uint8Array;
-    static isXyoAddress(value: unknown): boolean;
-}
+import { XyoDataLike } from './Data';
+import { XyoEllipticKey } from './XyoEllipticKey';
+export declare class XyoAddressValue extends XyoEllipticKey {
+    private _isXyoAddress;
+    constructor(address: XyoDataLike);
+    verify(msg: Uint8Array | string, signature: Uint8Array | string): boolean;
+    static verify(msg: Uint8Array | string, signature: Uint8Array | string, address: XyoDataLike): boolean;
+    static addressFromPublicKey(key: XyoDataLike): string;
+    static addressFromAddressOrPublicKey(bytes: XyoDataLike): string | Uint8Array;
+    static isXyoAddress(value: unknown): boolean;
+}

package/dist/esm/Wallet/Account/Key/XyoAddressValue.js

@@ -1,45 +1,45 @@
-import { toUint8Array, XyoData } from './Data';
-import { XyoEllipticKey } from './XyoEllipticKey';
-export class XyoAddressValue extends XyoEllipticKey {
-    constructor(address) {
-        super(20, XyoAddressValue.addressFromAddressOrPublicKey(address));
-        this._isXyoAddress = true;
-    }
-    verify(msg, signature) {
-        return XyoAddressValue.verify(msg, signature, this.bytes);
-    }
-    //there has to be a better way to do this other than trying all four numbers
-    //maybe we can get the number from the address more easily
-    static verify(msg, signature, address) {
-        let valid = false;
-        const sigArray = toUint8Array(signature);
-        const r = sigArray.slice(0, 32);
-        const s = sigArray.slice(32, 64);
-        const expectedAddress = new XyoAddressValue(address).hex;
-        for (let i = 0; i < 4; i++) {
-            try {
-                const publicKey = XyoAddressValue.ecContext
-                    .keyFromPublic(XyoAddressValue.ecContext.recoverPubKey(toUint8Array(msg), { r, s }, i))
-                    .getPublic('hex')
-                    .slice(2);
-                const recoveredAddress = XyoAddressValue.addressFromPublicKey(publicKey);
-                valid = valid || recoveredAddress === expectedAddress;
-            }
-            catch (ex) {
-                null;
-            }
-        }
-        return valid;
-    }
-    static addressFromPublicKey(key) {
-        return new XyoData(64, key).keccak256.slice(12).toString('hex').padStart(40, '0');
-    }
-    static addressFromAddressOrPublicKey(bytes) {
-        const bytesArray = toUint8Array(bytes);
-        return bytesArray.length === 20 ? bytesArray : XyoAddressValue.addressFromPublicKey(bytesArray);
-    }
-    static isXyoAddress(value) {
-        return value._isXyoAddress;
-    }
-}
+import { toUint8Array, XyoData } from './Data';
+import { XyoEllipticKey } from './XyoEllipticKey';
+export class XyoAddressValue extends XyoEllipticKey {
+    constructor(address) {
+        super(20, XyoAddressValue.addressFromAddressOrPublicKey(address));
+        this._isXyoAddress = true;
+    }
+    verify(msg, signature) {
+        return XyoAddressValue.verify(msg, signature, this.bytes);
+    }
+    //there has to be a better way to do this other than trying all four numbers
+    //maybe we can get the number from the address more easily
+    static verify(msg, signature, address) {
+        let valid = false;
+        const sigArray = toUint8Array(signature);
+        const r = sigArray.slice(0, 32);
+        const s = sigArray.slice(32, 64);
+        const expectedAddress = new XyoAddressValue(address).hex;
+        for (let i = 0; i < 4; i++) {
+            try {
+                const publicKey = XyoAddressValue.ecContext
+                    .keyFromPublic(XyoAddressValue.ecContext.recoverPubKey(toUint8Array(msg), { r, s }, i))
+                    .getPublic('hex')
+                    .slice(2);
+                const recoveredAddress = XyoAddressValue.addressFromPublicKey(publicKey);
+                valid = valid || recoveredAddress === expectedAddress;
+            }
+            catch (ex) {
+                null;
+            }
+        }
+        return valid;
+    }
+    static addressFromPublicKey(key) {
+        return new XyoData(64, key).keccak256.slice(12).toString('hex').padStart(40, '0');
+    }
+    static addressFromAddressOrPublicKey(bytes) {
+        const bytesArray = toUint8Array(bytes);
+        return bytesArray.length === 20 ? bytesArray : XyoAddressValue.addressFromPublicKey(bytesArray);
+    }
+    static isXyoAddress(value) {
+        return value._isXyoAddress;
+    }
+}
 //# sourceMappingURL=XyoAddressValue.js.map

package/dist/esm/Wallet/Account/Key/XyoEllipticKey.d.ts

@@ -1,5 +1,5 @@
-import EC from 'elliptic';
-import { XyoData } from './Data';
-export declare class XyoEllipticKey extends XyoData {
-    protected static ecContext: EC.ec;
-}
+import EC from 'elliptic';
+import { XyoData } from './Data';
+export declare class XyoEllipticKey extends XyoData {
+    protected static ecContext: EC.ec;
+}

package/dist/esm/Wallet/Account/Key/XyoEllipticKey.js

@@ -1,8 +1,8 @@
-import EC from 'elliptic';
-import { XyoData } from './Data';
-export class XyoEllipticKey extends XyoData {
-}
-// we do this to allow node to import without problem
-// eslint-disable-next-line import/no-named-as-default-member
-XyoEllipticKey.ecContext = new EC.ec('secp256k1');
+import EC from 'elliptic';
+import { XyoData } from './Data';
+export class XyoEllipticKey extends XyoData {
+}
+// we do this to allow node to import without problem
+// eslint-disable-next-line import/no-named-as-default-member
+XyoEllipticKey.ecContext = new EC.ec('secp256k1');
 //# sourceMappingURL=XyoEllipticKey.js.map