@xyo-network/core 2.20.17

package/src/Wallet/Account/Account.ts

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

package/src/Wallet/Account/Key/Data/AbstractData.ts

@@ -0,0 +1,22 @@
+import { BigNumber, Buffer } from '@xylabs/sdk-js'
+
+export abstract class XyoAbstractData {
+  private _isXyoData = true
+  public abstract get hex(): string
+
+  public abstract get buffer(): Buffer
+
+  public abstract get bn(): BigNumber
+
+  public abstract get bytes(): Uint8Array
+
+  public abstract get keccak256(): Buffer
+
+  public get length() {
+    return this.bytes.length
+  }
+
+  public static isXyoData(value: unknown) {
+    return (value as XyoAbstractData)._isXyoData
+  }
+}

package/src/Wallet/Account/Key/Data/Data.ts

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

package/src/Wallet/Account/Key/Data/XyoDataLike.ts

@@ -0,0 +1,5 @@
+import { BigNumber } from '@xylabs/sdk-js'
+
+import { XyoAbstractData } from './AbstractData'
+
+export type XyoDataLike = string | BigNumber | Uint8Array | XyoAbstractData

package/src/Wallet/Account/Key/Data/index.ts

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

package/src/Wallet/Account/Key/Data/toUint8Array.spec.ts

@@ -0,0 +1,19 @@
+import { Buffer } from 'buffer'
+
+import { toUint8Array } from './toUint8Array'
+
+describe('toUint8Array', () => {
+  test('Uint8Array Round Trip', () => {
+    const testArray = Uint8Array.from([0, 1, 2, 3])
+    const testArrayPrime = toUint8Array(testArray)
+    expect(testArray.length).toBe(testArrayPrime.length)
+    for (let i = 0; i < testArray.length; i++) {
+      expect(testArray[i]).toBe(testArrayPrime[i])
+    }
+  })
+  test('Hex Round Trip', () => {
+    const testHex = '1a2b3c'
+    const testHexPrime = Buffer.from(toUint8Array(testHex)).toString('hex')
+    expect(testHex).toBe(testHexPrime)
+  })
+})

package/src/Wallet/Account/Key/Data/toUint8Array.ts

@@ -0,0 +1,41 @@
+import { assertEx, BigNumber, Buffer } from '@xylabs/sdk-js'
+
+import { ifTypeOf } from '../../../../lib'
+import { XyoAbstractData } from './AbstractData'
+import { XyoDataLike } from './XyoDataLike'
+
+const stringToUint8Array = (value: string) => {
+  return bufferToUint8Array(Buffer.from(value.startsWith('0x') ? value.slice(2) : value, 'hex'))
+}
+
+const bigNumberToUint8Array = (value: BigNumber) => {
+  return bufferToUint8Array(Buffer.from(value.toBuffer()))
+}
+
+const bufferToUint8Array = (value: Buffer) => {
+  return Uint8Array.from(value)
+}
+
+const xyoDataToUint8Array = (value: XyoAbstractData) => {
+  return value.bytes
+}
+
+export const toUint8ArrayOptional = (value?: XyoDataLike, padLength?: number): Uint8Array | undefined => {
+  return value ? toUint8Array(value, padLength) : undefined
+}
+
+export const toUint8Array = (value: XyoDataLike, padLength?: number): Uint8Array => {
+  let result: Uint8Array | undefined =
+    ifTypeOf<string, Uint8Array>('string', value as string, stringToUint8Array) ??
+    ifTypeOf<BigNumber, Uint8Array | undefined>('object', value as BigNumber, bigNumberToUint8Array, BigNumber.isBN) ??
+    ifTypeOf<Buffer, Uint8Array | undefined>('object', value as Buffer, bufferToUint8Array, Buffer.isBuffer) ??
+    ifTypeOf<XyoAbstractData, Uint8Array | undefined>('object', value as Buffer, xyoDataToUint8Array, XyoAbstractData.isXyoData) ??
+    (value as Uint8Array)
+
+  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
+}

package/src/Wallet/Account/Key/XyoAddressValue.ts

@@ -0,0 +1,51 @@
+import { toUint8Array, XyoData, XyoDataLike } from './Data'
+import { XyoEllipticKey } from './XyoEllipticKey'
+
+export class XyoAddressValue extends XyoEllipticKey {
+  private _isXyoAddress = true
+  constructor(address: XyoDataLike) {
+    super(20, XyoAddressValue.addressFromAddressOrPublicKey(address))
+  }
+
+  public verify(msg: Uint8Array | string, signature: Uint8Array | string) {
+    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
+  public static verify(msg: Uint8Array | string, signature: Uint8Array | string, address: XyoDataLike) {
+    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
+  }
+
+  public static addressFromPublicKey(key: XyoDataLike) {
+    return new XyoData(64, key).keccak256.slice(12).toString('hex').padStart(40, '0')
+  }
+
+  public static addressFromAddressOrPublicKey(bytes: XyoDataLike) {
+    const bytesArray = toUint8Array(bytes)
+    return bytesArray.length === 20 ? bytesArray : XyoAddressValue.addressFromPublicKey(bytesArray)
+  }
+
+  public static isXyoAddress(value: unknown) {
+    return (value as XyoAddressValue)._isXyoAddress
+  }
+}

package/src/Wallet/Account/Key/XyoEllipticKey.ts

@@ -0,0 +1,9 @@
+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
+  protected static ecContext = new EC.ec('secp256k1')
+}

package/src/Wallet/Account/Key/XyoKeyPair.ts

@@ -0,0 +1,23 @@
+import { XyoDataLike } from './Data'
+import { XyoPrivateKey } from './XyoPrivateKey'
+
+export class XyoKeyPair {
+  private _private?: XyoPrivateKey
+  private _isXyoKeyPair = true
+  constructor(privateKeyData?: XyoDataLike) {
+    this._private = new XyoPrivateKey(privateKeyData)
+  }
+
+  public get private() {
+    this._private = this._private ?? new XyoPrivateKey()
+    return this._private
+  }
+
+  public get public() {
+    return this.private.public
+  }
+
+  public static isXyoKeyPair(value: unknown) {
+    return (value as XyoKeyPair)._isXyoKeyPair
+  }
+}

package/src/Wallet/Account/Key/XyoPrivateKey.ts

@@ -0,0 +1,60 @@
+import EC from 'elliptic'
+
+import { toUint8Array, XyoDataLike } from './Data'
+import { XyoEllipticKey } from './XyoEllipticKey'
+import { XyoPublicKey } from './XyoPublicKey'
+
+export class XyoPrivateKey extends XyoEllipticKey {
+  private _isXyoPrivateKey = true
+  private _keyPair: EC.ec.KeyPair
+  private _public?: XyoPublicKey
+
+  constructor(value?: XyoDataLike) {
+    super(32)
+    if (value) {
+      this._keyPair = XyoPrivateKey.ecContext.keyFromPrivate(toUint8Array(value))
+    } else {
+      this._keyPair = XyoPrivateKey.ecContext.genKeyPair()
+    }
+  }
+
+  public override get bytes() {
+    return toUint8Array(this._keyPair?.getPrivate())
+  }
+
+  public get public() {
+    this._public = this._public ?? new XyoPublicKey(this._keyPair.getPublic('hex').slice(2))
+    return this._public
+  }
+
+  public sign(hash: XyoDataLike) {
+    const arrayHash = toUint8Array(hash)
+    const signature = this._keyPair.sign(arrayHash)
+    return toUint8Array(signature.r.toString('hex', 64) + signature.s.toString('hex', 64))
+  }
+
+  public verify(msg: Uint8Array | string, signature: Uint8Array | string) {
+    return this.public.address.verify(msg, signature)
+  }
+
+  /*
+  public signKeccakMessage(message: string) {
+    const prefixBuffer = Buffer.from(messagePrefix)
+    const messageLengthBuffer = Buffer.from([0x20])
+    const messageBuffer = Buffer.from(message)
+    const signingBuffer = keccak256(
+      Buffer.concat([
+        prefixBuffer,
+        messageLengthBuffer,
+        keccak256(Buffer.concat([messageBuffer, Buffer.from(toUint8Array(this.address))])),
+      ])
+    )
+    const signature = this._key.sign(signingBuffer)
+    return signature.toDER('hex').substring(2)
+  }
+  */
+
+  public static isXyoPrivateKey(value: unknown) {
+    return (value as XyoPrivateKey)._isXyoPrivateKey
+  }
+}

package/src/Wallet/Account/Key/XyoPublicKey.ts

@@ -0,0 +1,21 @@
+import { XyoDataLike } from './Data'
+import { XyoAddressValue } from './XyoAddressValue'
+import { XyoEllipticKey } from './XyoEllipticKey'
+
+export class XyoPublicKey extends XyoEllipticKey {
+  private _isXyoPublicKey = true
+  constructor(bytes: XyoDataLike) {
+    super(64, bytes)
+  }
+  public get address() {
+    return new XyoAddressValue(this.keccak256.slice(12).toString('hex').padStart(40, '0'))
+  }
+
+  public verify(msg: Uint8Array | string, signature: Uint8Array | string) {
+    return this.address.verify(msg, signature)
+  }
+
+  public static isXyoPublicKey(value: unknown) {
+    return (value as XyoPublicKey)._isXyoPublicKey
+  }
+}

package/src/Wallet/Account/Key/index.ts

@@ -0,0 +1,5 @@
+export * from './Data'
+export * from './XyoAddressValue'
+export * from './XyoKeyPair'
+export * from './XyoPrivateKey'
+export * from './XyoPublicKey'

package/src/Wallet/Account/index.ts

@@ -0,0 +1,2 @@
+export * from './Account'
+export * from './Key'

package/src/Wallet/Base/Base.spec.ts

@@ -0,0 +1,10 @@
+import { XyoWalletBase } from './Base'
+
+test('all', () => {
+  const wallet = new XyoWalletBase('test phrase')
+  const account = wallet.getAccount(10)
+
+  expect(account).toBeDefined()
+  expect(account.addressValue.length).toBe(20)
+  expect(account.public.address.hex).toBe('8ce36d609316943d9825501eb88b1af1fe4586a0')
+})

package/src/Wallet/Base/Base.ts

@@ -0,0 +1,35 @@
+import { delay } from '@xylabs/sdk-js'
+import shajs from 'sha.js'
+
+import { XyoAccount } from '../Account'
+import { Words } from './Words'
+
+export class XyoWalletBase {
+  protected _phrase: string
+  protected _name: string
+  constructor(phrase: string, name = 'xyoWallet') {
+    this._name = name
+    this._phrase = phrase
+  }
+
+  public getAccount(index: number) {
+    let counter = index
+    let hash = shajs('sha256').update(this._phrase).digest().toString('hex')
+    while (counter) {
+      hash = shajs('sha256').update(hash).digest().toString('hex')
+      counter--
+    }
+    return new XyoAccount({ privateKey: hash })
+  }
+
+  public static async generate() {
+    //delay is here to prep for archivist load
+    await delay(0)
+    const wordList: string[] = []
+    while (wordList.length < 16) {
+      const index = Math.floor(Math.random() * Words.words.length)
+      wordList.push(Words.words[index])
+    }
+    return new XyoWalletBase(wordList.join(' '))
+  }
+}