@kynesyslabs/demosdk 1.0.21 → 1.0.23

package/src/encryption/PQC/index.ts

@@ -1,260 +0,0 @@
-/* INFO Enigma - An experimental wrapper for Post Quantum Cryptography in Typescript designed with ease of use in mind
-
-    LICENSE
-
-    © 2023 by KyneSys Labs, licensed under CC BY-NC-ND 4.0
-
-    Full license text: https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode
-    Human readable license: https://creativecommons.org/licenses/by-nc-nd/4.0/
-
-    KyneSys Labs: https://www.kynesys.xyz/
-
-    This module incorporates two Post Quantum Cryptography methods:
-    - Rijndael: symmetric encryption algorithm considered the state of the art of its category
-    - Argon2: quantum-safe hashing algorithm
-    - McEliece: post-quantum cryptography algorithm that uses a keypair to share secrets between two parties.
-    - Dilithium: post-quantum cryptography algorithm that uses a keypair to sign and verify messages.
-
-    The Rijdael algorithm is a symmetric encryption algorithm and as many of the most used symmetric encryption algorithms 
-    is considered to be quantum-safe. While even standard AES-256 is considered to be quantum-safe, the Rijndael algorithm
-    is considered to improve robustness, performance, and security when compared to standard AES-256 as AES specification
-    is a subset of Rijdael algorithm itself.
-
-    The Argon2 algorithm is a quantum-safe hashing algorithm that is designed to protect against various dehashing attacks.
-    It is used to replace less secure hashing algorithms such as SHA-1, SHA-256, and so on.
-
-    The McEliece algorithm is used to encrypt and decrypt messages, much like a symmetric classic encryption algorithm.
-    Thanks to its post-quantum security, however, it is not possible to retrieve the secrets as easily as with a classic algorithm.
-    We use McEliece to exchange a long-term secret between two parties. This secret will be the base to generate one-time secrets
-    encrypted with McEliece itself that will be used to generate one-time symmetric keys.
-
-    The Dilithium algorithm is used to sign and verify messages, much like algorithms like ed25519.
-    Apart from providing post quantum security, the Dilithium algorithm is also capable of generating combined signed messages
-    that can be used to verify signatures without sharing the initial message, as proofs of authenticity.
-
-    Credits:
-    - https://github.com/Snack-X for https://github.com/Snack-X/rijndael-js
-    - https://github.com/ranisalt for https://github.com/ranisalt/node-argon2
-    - https://github.com/cyph for its https://github.com/cyph/pqcrypto.js library (superdilithium, supersphincs and a lot of knowledge)
-    - https://github.com/tniessen for its https://github.com/tniessen/node-mceliece-nist library (mceliece and a lot of knowledge too)
-    - I can't find the ntru library developer unfortunately, feel free to contact me if its you
-
-*/
-import argon2 from "argon2"
-// import { superSphincs } from "supersphincs" // Same as above, just replace the two strings
-import { McEliece } from "mceliece-nist"
-import Rijndael from "rijndael-js"
-import { superDilithium } from "superdilithium"
-
-// import {ntru} from "ntru" // Interchangeable with McEliece
-
-// INFO Interface to happily work with almost any keypair
-export interface IKeypair {
-    privateKey: Uint8Array
-    publicKey: Uint8Array
-}
-
-// INFO Main class
-export default class Enigma {
-    signingKeyPair: IKeypair = null
-    mcelieceKeypair: IKeypair = null
-
-    private kem: McEliece = new McEliece("mceliece8192128")
-
-    constructor() {}
-
-    async init() {
-        this.signingKeyPair = await superDilithium.keyPair()
-        this.mcelieceKeypair = this.kem.keypair()
-    }
-
-    /* SECTION Signatures with superDilithium */
-
-    async combinedSign(
-        message: string,
-        additionalData: string = null,
-    ): Promise<Uint8Array> {
-        let bufMessage = Buffer.from(message, "utf8")
-        let signed: Uint8Array
-        if (additionalData) {
-            let bufAdditionalData = Buffer.from(additionalData, "utf8")
-            signed = await superDilithium.sign(
-                bufMessage,
-                this.signingKeyPair.privateKey,
-                bufAdditionalData,
-            )
-        } else {
-            signed = await superDilithium.sign(
-                bufMessage,
-                this.signingKeyPair.privateKey,
-            )
-        }
-        return signed
-    }
-
-    async combinedVerify(
-        signed: Uint8Array,
-        publicKey: Uint8Array,
-        additionalData: string = null,
-    ): Promise<Uint8Array> {
-        let verifyData: Uint8Array
-        if (additionalData) {
-            let bufAdditionalData = Buffer.from(additionalData, "utf8")
-            verifyData = await superDilithium.open(
-                signed,
-                publicKey,
-                bufAdditionalData,
-            )
-        } else {
-            verifyData = await superDilithium.open(signed, publicKey)
-        }
-        return verifyData
-    }
-
-    async sign(
-        message: string | Uint8Array,
-        additionalData: string | Uint8Array = null,
-    ) {
-        if (typeof message === "string") {
-            message = Buffer.from(message, "utf8")
-        }
-        if (typeof additionalData === "string") {
-            additionalData = Buffer.from(additionalData, "utf8")
-        }
-        // Signing
-        let signed: Uint8Array
-        if (additionalData) {
-            signed = await superDilithium.signDetached(
-                message,
-                this.signingKeyPair.privateKey,
-                additionalData,
-            )
-        } else {
-            signed = await superDilithium.signDetached(
-                message,
-                this.signingKeyPair.privateKey,
-            )
-        }
-        return signed
-    }
-
-    async verify(
-        signature: Uint8Array,
-        message: string | Uint8Array,
-        publicKey: Uint8Array,
-        additionalData: string | Uint8Array = null,
-    ) {
-        if (typeof message === "string") {
-            message = Buffer.from(message, "utf8")
-        }
-        if (typeof additionalData === "string") {
-            additionalData = Buffer.from(additionalData, "utf8")
-        }
-        // Verifying
-        let verified: boolean
-        if (additionalData) {
-            verified = await superDilithium.verifyDetached(
-                signature,
-                message,
-                publicKey,
-                additionalData,
-            )
-        } else {
-            verified = await superDilithium.verifyDetached(
-                signature,
-                message,
-                publicKey,
-            )
-        }
-        return verified
-    }
-
-    async exportSigningKeys(passphrase: string = null): Promise<any> {
-        let storage: any
-        if (passphrase) {
-            storage = await superDilithium.exportKeys(
-                this.signingKeyPair,
-                passphrase,
-            )
-        } else {
-            storage = await superDilithium.exportKeys(this.signingKeyPair)
-        }
-        return storage
-    }
-
-    async importSigningKeys(
-        storage: any,
-        passphrase: string = null,
-    ): Promise<any> {
-        if (passphrase) {
-            this.signingKeyPair = await superDilithium.importKeys(
-                storage,
-                passphrase,
-            )
-        } else {
-            this.signingKeyPair = await superDilithium.importKeys(storage)
-        }
-        return this.signingKeyPair
-    }
-
-    /* SECTION Keys generation and incapsulation with McEliece */
-
-    // Incapsulate a secret with a public key
-    async generateSecrets(peerPublicKey: any) {
-        let { key, encryptedKey } = await this.kem.generateKey(peerPublicKey)
-        let normalizedResult = {
-            secret: key,
-            shared: encryptedKey,
-        }
-        return normalizedResult
-    }
-
-    // Decapsulate a secret from a shared secret
-    async deriveSharedSecret(shared: any) {
-        let secret = await this.kem.decryptKey(
-            this.mcelieceKeypair.privateKey,
-            shared,
-        )
-        return secret
-    }
-
-    /* SECTION Hashing with Argon2 */
-
-    async hash(input: string | Buffer): Promise<string> {
-        if (typeof input === "string") {
-            input = Buffer.from(input, "utf8")
-        }
-        let hash = await argon2.hash(input)
-        return hash
-    }
-
-    async checkHash(input: string | Buffer, hash: string): Promise<boolean> {
-        if (typeof input === "string") {
-            input = Buffer.from(input, "utf8")
-        }
-        if (await argon2.verify(hash, input)) {
-            return true
-        } else {
-            return false
-        }
-    }
-
-    /* SECTION Symmetric encryption and decryption with Rijndael */
-
-    async encrypt(input: string, key: string): Promise<Buffer> {
-        // Key can be 16/24/32 bytes long (128/192/256 bit)
-        let cipher = new Rijndael(key, "cbc")
-        let ciphertext = Buffer.from(
-            cipher.encrypt(input, "256", "Ut enim ad minim veniam, quis no"),
-        ) // TODO Custom iv same block size
-        return ciphertext
-    }
-
-    async decrypt(input: Buffer, key: string): Promise<Buffer> {
-        let cipher = new Rijndael(key, "cbc")
-        let plainbuffer = Buffer.from(
-            cipher.decrypt(input, "256", "Ut enim ad minim veniam, quis no"),
-        )
-        return plainbuffer
-    }
-}

package/src/encryption/index.ts

@@ -1,5 +0,0 @@
-export * as FHE from './FHE'
-export * as PQC from './PQC'
-export * as zK from './zK'
-export * as Cryptography from './Cryptography'
-export * as Hashing from './Hashing'

package/src/encryption/zK/index.ts

@@ -1 +0,0 @@
-export * as interactive from './interactive' // interactive.Prover and interactive.Verifier

package/src/encryption/zK/interactive/index.ts

@@ -1,47 +0,0 @@
-import bigInt from "big-integer"
-import generateLargePrime from "@/encryption/zK/primer"
-
-export class Prover {
-    private secret: bigInt.BigInteger
-    public modulus: any
-    private randomValue: any
-
-    constructor(prime1: any, prime2: any, secret: bigInt.BigInteger) {
-        this.modulus = prime1.multiply(prime2)
-        this.secret = secret
-    }
-
-    generateCommitment(): any {
-        this.randomValue = bigInt.randBetween(2, this.modulus.subtract(2))
-        return this.randomValue.modPow(2, this.modulus)
-    }
-
-    respondToChallenge(challenge: number): any {
-        return challenge === 0
-            ? this.randomValue
-            : this.randomValue.multiply(this.secret).mod(this.modulus)
-    }
-}
-
-export class Verifier {
-    private modulus: any
-    private commitment: any
-
-    constructor(modulus: any) {
-        this.modulus = modulus
-    }
-
-    generateChallenge(commitment: any): number {
-        this.commitment = commitment
-        return Math.round(Math.random())
-    }
-
-    verifyResponse(response: any, challenge: number): boolean {
-        const responseSquared = response.modPow(2, this.modulus)
-        if (challenge === 0) {
-            return responseSquared.equals(this.commitment)
-        } else {
-            return !responseSquared.equals(this.commitment)
-        }
-    }
-}

package/src/encryption/zK/primer.ts

@@ -1,71 +0,0 @@
-import bigInt, { BigInteger } from "big-integer"
-
-function isSmallPrimeDivisorPresent(n: BigInteger): boolean {
-    const smallPrimes = [
-        2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67,
-        71, 73, 79, 83, 89, 97,
-    ]
-    for (const prime of smallPrimes) {
-        if (n.mod(prime).isZero()) {
-            return true
-        }
-    }
-    return false
-}
-
-function millerRabinTest(n: BigInteger, k: number): boolean {
-    if (n.leq(1) || n.equals(2)) return n.equals(2)
-    if (n.isEven()) return false
-
-    // Optimization: Check for small prime divisors first
-    if (isSmallPrimeDivisorPresent(n)) return false
-
-    let r = 0
-    let d = n.minus(1)
-    const two = bigInt(2)
-
-    // Precompute values
-    const nMinusOne = n.minus(1)
-    const nMinusTwo = n.minus(2)
-
-    while (d.isEven()) {
-        r++
-        d = d.divide(two)
-    }
-
-    for (let i = 0; i < k; i++) {
-        const a = bigInt.randBetween(two, nMinusTwo)
-        let x = a.modPow(d, n)
-        if (x.equals(1) || x.equals(nMinusOne)) continue
-
-        let continueLoop = false
-        for (let j = 0; j < r - 1; j++) {
-            x = x.modPow(two, n)
-            if (x.equals(nMinusOne)) {
-                continueLoop = true
-                break
-            }
-        }
-        if (continueLoop) continue
-        return false
-    }
-    return true
-}
-
-export default function generateLargePrime(
-    bits: number,
-    testRounds: number,
-): BigInteger {
-    if (bits < 2) throw new Error("Bit-length must be >= 2")
-
-    // Precompute powers of two
-    const twoPowBitsMinusOne = bigInt(2).pow(bits - 1)
-    const twoPowBits = bigInt(2).pow(bits)
-
-    let prime: BigInteger
-    do {
-        prime = bigInt.randBetween(twoPowBitsMinusOne, twoPowBits.subtract(1))
-    } while (!millerRabinTest(prime, testRounds))
-
-    return prime
-}

package/src/index.ts

@@ -1,8 +0,0 @@
-// Common types and constants
-export * as types from './types'
-// Basic cryptographic and data manipulation functions
-export * as encryption from './encryption'
-export * as utils from './utils'
-//  Specific features of the SDK
-export * as xmlocalsdk from './multichain/localsdk'
-export * as xmwebsdk from './multichain/websdk'

package/src/multichain/archive/btc.ts

@@ -1,72 +0,0 @@
-import BIP32Factory, { BIP32Interface } from "bip32"
-import * as bip39 from "bip39"
-import * as bitcoin from "bitcoinjs-lib"
-import * as ecc from "tiny-secp256k1"
-
-import defaultChainAsync from "./types/defaultChainAsync"
-
-const bip32 = BIP32Factory(ecc)
-
-// NOTE BIP32 implementation follows:
-// LINK https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/test/integration/bip32.spec.ts
-
-export default class BTC extends defaultChainAsync {
-    constructor(rpc_url: string) {
-        super(rpc_url)
-        this.name = "BTC"
-    }
-
-    async connect(rpc_url: string): Promise<boolean> {
-        throw new Error("Method not implemented.")
-    }
-    async disconnect(): Promise<any> {
-        throw new Error("Method not implemented.")
-    }
-    async getBalance(address: string): Promise<string> {
-        const response = await fetch(
-            `https://blockchain.info/q/addressbalance/${address}`,
-        )
-        const balance = await response.text()
-        return balance
-    }
-
-    pay(receiver: string, amount: string): Promise<any> {
-        throw new Error("Method not implemented.")
-    }
-    async info(account: BIP32Interface): Promise<string> {
-        let address = bitcoin.payments.p2pkh({
-            pubkey: account.publicKey,
-        }).address!
-        return JSON.stringify(address)
-    }
-
-    createWallet(): any {
-        // TODO Generate mnemonic
-        let mnemonic
-        let path = "m/0'/0/0"
-        let seed = bip39.mnemonicToSeedSync(mnemonic)
-        let root = bip32.fromSeed(seed)
-        this.wallet = root.derivePath(path) // REVIEW is this right?
-    }
-
-    // INFO Accepting base58 encoded private keys like:
-    // tprv8ZgxMBicQKsPd7Uf69XL1XwhmjHopUGep8GuEiJDZmbQz6o58LninorQAfcKZWARbtRtfnLcJ5MQ2AtHcQJCCRUcMRvmDUjyEmNUWwx8UbK
-    // NOTE Alternatively you can pass in a mnemonic phrase to generate the private key.
-    connectWallet(privateKey: string, mnemonic: boolean = false) {
-        if (!mnemonic) {
-            this.wallet = bip32.fromBase58(privateKey)
-        } else {
-            // Generating the seed and the private key from the mnemonic
-            let seed = bip39.mnemonicToSeedSync(privateKey)
-            let node = bip32.fromSeed(seed)
-            let strng = node.toBase58()
-            this.wallet = bip32.fromBase58(strng)
-        }
-    }
-    signTransaction(raw_transaction: any): Promise<any> {
-        throw new Error("Method not implemented.")
-    }
-    sendTransaction(signed_transaction: any) {
-        throw new Error("Method not implemented.")
-    }
-}

package/src/multichain/archive/demos.ts

@@ -1,51 +0,0 @@
-import DefaultChainAsync from "./types/defaultChainAsync";
-
-export default class DEMOS extends DefaultChainAsync {
-
-    provider = null
-    wallet = null
-    rpc_url = null
-    connected = false
-
-    constructor(rpc_url = null) {
-        super(rpc_url)
-        this.provider = null
-        this.wallet = null
-        if (rpc_url) {
-            this.setRPC(rpc_url)
-        }
-    }
-
-    // SECTION Unimplemented methods
-
-    connect(rpc_url: string): Promise<any> {
-        throw new Error("Method not implemented.");
-    }
-
-    async setRPC(rpc_url: string) {
-        throw new Error("Method not implemented.");
-    }
-
-    getBalance(address: string): Promise<string> {
-        throw new Error("Method not implemented.");
-    }
-    prepareTransfer(receiver: string, amount: string): Promise<any> {
-        throw new Error("Method not implemented.");
-    }
-    preparePay(receiver: string, amount: string): Promise<any> {
-        throw new Error("Method not implemented.");
-    }
-    getEmptyTransaction() {
-        throw new Error("Method not implemented.");
-    }
-    getAddress(): string {
-        throw new Error("Method not implemented.");
-    }
-    connectWallet(privateKey: string) {
-        throw new Error("Method not implemented.");
-    }
-    signTransaction(raw_transaction: any): Promise<any> {
-        throw new Error("Method not implemented.");
-    }
-
-}

package/src/multichain/archive/tron.ts

@@ -1,86 +0,0 @@
-import required from '../../utils/required'
-const TronWeb = require('tronweb')
-import DefaultChainAsync from './types/defaultChainAsync'
-
-export default class TRON extends DefaultChainAsync {
-
-  provider = null
-  wallet = null
-  rpc_url = null
-  connected = false
-
-  // NOTE We init TRON with await TRON.create(rpc_url)
-  // This is necessary to ensure that the provider is connected
-  // if the user specifies the rpc_url in the constructor,
-  // as we cannot use await in the constructor
-  constructor (rpc_url = null) {
-    super(rpc_url)
-    if (rpc_url) {
-      this.setRPC(rpc_url)
-    }
-    this.wallet = null
-    this.provider = null
-  }
-
-  // INFO Set of methods for connecting to an RPC while
-  // retaining a granular control over the instance status
-  async setRPC (rpc_url: string) {
-    this.rpc_url = rpc_url
-    this.provider = new TronWeb({
-      fullHost: this.rpc_url
-		  })
-  }
-
-  async connect () {
-    return this.provider
-  }
-
-  static async create (rpc_url = null) {
-    const instance = new TRON(rpc_url)
-    if (rpc_url) { await instance.connect() }
-    return instance
-  }
-
-  // INFO Connecting a wallet through a private key (string)
-  async connectWallet (privateKey: string, api_key = '') {
-    required(this.provider, true)
-
-    this.wallet = new TronWeb({
-      fullHost: 'https://api.shasta.trongrid.io',
-      privateKey,
-      headers: { 'TRON-PRO-API-KEY': api_key }
-    })
-  }
-
-  // INFO Signing a transaction
-  // with a private key or by using our stored wallet
-  async signTransaction (transaction: Transaction, privateKey = null) {
-    // TODO
-  }
-
-  // SECTION Specific methods
-
-  // INFO transfer and pay are the same
-  async prepareTransfer (address: any, amount: any) {
-    await this.preparePay(address, amount)
-  }
-
-  async preparePay (address: string, amount: string) {
-    required(this.wallet, true)
-    // TODO
-  }
-
-  // INFO Generic empty tx skeleton for this chain
-  async getEmptyTransaction () {
-    // TODO
-  }
-
-  // SECTION Unimplemented methods
-
-  getBalance(address: string): Promise<string> {
-    throw new Error('Method not implemented.')
-  }
-  getAddress(): string {
-    throw new Error('Method not implemented.')
-  }
-}

package/src/multichain/archive/xlm.ts

@@ -1,65 +0,0 @@
-/* LICENSE
-
-© 2023 by KyneSys Labs, licensed under CC BY-NC-ND 4.0
-
-Full license text: https://creativecommons.org/licenses/by-nc-nd/4.0/legalcode
-Human readable license: https://creativecommons.org/licenses/by-nc-nd/4.0/
-
-KyneSys Labs: https://www.kynesys.xyz/
-
-*/
-
-// LINK https://github.com/stellar/js-stellar-sdk/tree/master/docs/reference
-
-import required from "src/utilities/required"
-import * as StellarSdk from "stellar-sdk"
-
-import Server from "../../../src/libs/network/server"
-import defaultChainAsync from "./types/defaultChainAsync"
-
-// TODO Find a way to make things in the next link much more unified
-// LINK https://github.com/stellar/js-stellar-base/blob/master/docs/reference/building-transactions.md
-export default class XLM extends defaultChainAsync {
-    constructor(rpcURL: string) {
-        super(rpcURL)
-        this.name = "xlm"
-    }
-
-    public async connect(rpcURL: string): Promise<boolean> {
-        console.log("stellar not yet implemented. check the code")
-        process.exit(0)
-        // this.provider = new StellarSdk(rpcURL) // 'https://horizon-testnet.stellar.org' // FIXME
-        return true
-    }
-
-    public async disconnect(): Promise<any> {
-        throw new Error("Method not implemented.")
-    }
-
-    createWallet(): any {}
-
-    // INFO Loading a keypair from a private key string
-    connectWallet(privateKey: string) {
-        this.wallet = StellarSdk.Keypair.fromSecret(privateKey)
-    }
-    getBalance(address: string): Promise<string> {
-        throw new Error("Method not implemented.")
-    }
-    pay(receiver: string, amount: string): Promise<any> {
-        throw new Error("Method not implemented.")
-    }
-    info(): Promise<string> {
-        throw new Error("Method not implemented.")
-    }
-
-    // REVIEW Signing a pre built transaction
-    async signTransaction(raw_transaction: any): Promise<any> {
-        required(this.wallet, "Wallet not connected")
-        let signed_tx = await raw_transaction.sign(this.wallet)
-        return signed_tx
-    }
-
-    sendTransaction(transactions: any) {
-        throw new Error("Method not implemented.")
-    }
-}

package/src/multichain/core/README.md

@@ -1 +0,0 @@
-# Multichain SDKs Core