@dioxide-js/silas/dist/esm/utils/address/ecdsa.mjs

RPC utility for Silas

import { __awaiter } from '../../node_modules/tslib/tslib.es6.mjs';
import { dataview } from '../../node_modules/@dioxide-js/misc/dist/misc.es5.mjs';
import { getPublicKey, verify, sign } from '../../node_modules/@noble/ed25519/lib/esm/index.mjs';
import base32Encode from '../../_virtual/index2.mjs';
import sha256 from '../../_virtual/nodecrypto.mjs';
import crc32c from '../../_virtual/crc32c.mjs';
import crypto from 'crypto';
import { formatedSalt, encodeMnemonic } from './base.mjs';

class ECDSA {
    constructor(options) {
        this.privateKeyU8 = new Uint8Array();
        this.encryptMethod = 'sm2';
        this.encryptOrderNum = 4;
        this.saltRef = 1;
        this.salt = new Uint8Array();
        this.seed = new Uint8Array();
        this.alias = 'Address1';
        this.words = [];
        if (options === null || options === void 0 ? void 0 : options.privateKey) {
            const { privateKey } = options;
            if (!(privateKey instanceof Uint8Array)) {
                throw `Illegal privatekey, expect Uint8Array`;
            }
            this.salt = formatedSalt(this.saltRef);
            this.seed = this.generateSeed();
            this.privateKeyU8 = this.get32bPrivateKey(options.privateKey);
            this.privateKey = dataview.u8ToHex(this.privateKeyU8);
        }
    }
    generateSeed(seed) {
        let seedU8 = [];
        if (!seed) {
            const tableContainer = new Uint8Array(27);
            const randomData = crypto.getRandomValues(tableContainer);
            seedU8 = randomData;
        }
        else {
            seedU8 = seed;
        }
        this.words = encodeMnemonic(seedU8);
        return new Uint8Array(seedU8);
    }
    generate() {
        return __awaiter(this, void 0, void 0, function* () {
            const [pku8, sku8] = yield this.keyPaires();
            const address = this.pkToAddress(pku8, true);
            const sk = dataview.u8ToHex(sku8);
            const pk = dataview.u8ToHex(pku8);
            return { publickey: pk, privatekey: sk, pku8, sku8, address };
        });
    }
    pkToAddrU8(publickey) {
        if (publickey.length !== 32) {
            throw 'expect 32 bytes publick key';
        }
        const o = this.pkToDIOStruct(publickey);
        return o.address;
    }
    pkToAddress(publickey, postfix = true) {
        const u8 = this.pkToAddrU8(publickey);
        const address = base32Encode(u8, 'Crockford').toLowerCase();
        return postfix ? address + ':' + this.encryptMethod : address;
    }
    getPubicKeyFromPrivateKey(privateKey) {
        if (typeof privateKey === 'string') {
            privateKey = dataview.hexToU8(privateKey);
        }
        return getPublicKey(privateKey);
    }
    pkToDIOStruct(publicKey, salt = 1, alias) {
        const order = this.encryptOrderNum;
        const method = this.encryptMethod;
        let errorCorrectingCode = crc32c.buf(publicKey, order);
        errorCorrectingCode = (errorCorrectingCode & 0xfffffff0) | order;
        errorCorrectingCode = errorCorrectingCode >>> 0;
        const buffer = new Int32Array([errorCorrectingCode]).buffer;
        const errorCorrectingCodeBuffer = new Uint8Array(buffer);
        const mergedBuffer = dataview.concat(publicKey, errorCorrectingCodeBuffer);
        const address = {
            currency: 'DIO',
            address: mergedBuffer,
            encryptMethod: method,
            encryptMethodOrderNumber: order,
            salt: salt || 1,
            alias: alias || `Address${salt}`,
        };
        return address;
    }
    keyPaires() {
        return __awaiter(this, void 0, void 0, function* () {
            let publicKey;
            let privateKey;
            if (this.privateKey && this.privateKeyU8) {
                privateKey = this.privateKeyU8;
                publicKey = yield getPublicKey(privateKey);
            }
            else {
                const [pk, sk] = yield seed2PairOfKey(this.seed, this.salt);
                publicKey = pk;
                privateKey = sk;
            }
            return [publicKey, privateKey];
        });
    }
    sign(content, privateKey) {
        return __awaiter(this, void 0, void 0, function* () {
            if (Array.isArray(content)) {
                const message = Uint8Array.from(content);
                return sign(message, privateKey);
            }
            privateKey = this.get32bPrivateKey(privateKey);
            return sign(content, privateKey);
        });
    }
    get32bPrivateKey(sk) {
        const l = sk.length;
        if (!(l === 64 || l === 32)) {
            throw `Illegal PrivateKey format, expect 32 bytes 64 bytes`;
        }
        return sk.length === 64 ? sk.slice(0, 32) : sk;
    }
    verify(msg, sigValueHex, publicKey) {
        const pk = dataview.u8ToHex(publicKey);
        if (Array.isArray(msg)) {
            msg = Uint8Array.from(msg);
            msg = dataview.u8ToHex(msg);
        }
        return verify(sigValueHex, msg, pk);
    }
}
function seed2PairOfKey(seed_1) {
    return __awaiter(this, arguments, void 0, function* (seed, salt = new Uint8Array()) {
        const formatedSeed = dataview.concat(seed, salt);
        const privateKeyStr = sha256(formatedSeed, { asBytes: true });
        const privateKey = new Uint8Array(privateKeyStr);
        const publicKey = yield getPublicKey(privateKey);
        return [publicKey, privateKey];
    });
}

export { ECDSA as default };
//# sourceMappingURL=ecdsa.mjs.map