@btc-vision/wallet-sdk 1.0.0

package/lib/message/deterministic-ecdsa.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.signMessageOfDeterministicECDSA = void 0;
+const hmac = __importStar(require("@noble/hashes/hmac"));
+const sha256 = __importStar(require("@noble/hashes/sha256"));
+const noble_secp256k1 = __importStar(require("@noble/secp256k1"));
+const bitcoin_core_1 = require("../bitcoin-core");
+noble_secp256k1.utils.hmacSha256Sync = (key, ...msgs) => hmac.hmac(sha256.sha256, key, noble_secp256k1.utils.concatBytes(...msgs));
+const MAGIC_BYTES = Buffer.from('Bitcoin Signed Message:\n');
+function varintBufNum(n) {
+    let buf;
+    if (n < 253) {
+        buf = Buffer.alloc(1);
+        buf.writeUInt8(n, 0);
+    }
+    else if (n < 0x10000) {
+        buf = Buffer.alloc(1 + 2);
+        buf.writeUInt8(253, 0);
+        buf.writeUInt16LE(n, 1);
+    }
+    else if (n < 0x100000000) {
+        buf = Buffer.alloc(1 + 4);
+        buf.writeUInt8(254, 0);
+        buf.writeUInt32LE(n, 1);
+    }
+    else {
+        buf = Buffer.alloc(1 + 8);
+        buf.writeUInt8(255, 0);
+        buf.writeInt32LE(n & -1, 1);
+        buf.writeUInt32LE(Math.floor(n / 0x100000000), 5);
+    }
+    return buf;
+}
+function magicHash(message) {
+    const prefix1 = varintBufNum(MAGIC_BYTES.length);
+    const messageBuffer = Buffer.from(message);
+    const prefix2 = varintBufNum(messageBuffer.length);
+    const buf = Buffer.concat([prefix1, MAGIC_BYTES, prefix2, messageBuffer]);
+    return bitcoin_core_1.bitcoin.crypto.hash256(buf);
+}
+function toCompact(i, signature, compressed) {
+    if (!(i === 0 || i === 1 || i === 2 || i === 3)) {
+        throw new Error('i must be equal to 0, 1, 2, or 3');
+    }
+    let val = i + 27 + 4;
+    if (!compressed) {
+        val = val - 4;
+    }
+    return Buffer.concat([Uint8Array.of(val), Uint8Array.from(signature)]);
+}
+function signMessageOfDeterministicECDSA(ecpair, message) {
+    const hash = magicHash(message);
+    const [signature, i] = noble_secp256k1.signSync(Buffer.from(hash), ecpair.privateKey.toString('hex'), {
+        canonical: true,
+        recovered: true,
+        der: false
+    });
+    return toCompact(i, signature, true).toString('base64');
+}
+exports.signMessageOfDeterministicECDSA = signMessageOfDeterministicECDSA;

package/lib/message/ecdsa.d.ts

@@ -0,0 +1,3 @@
+import { ECPairInterface } from 'ecpair';
+export declare function signMessageOfECDSA(privateKey: ECPairInterface, text: string): string;
+export declare function verifyMessageOfECDSA(publicKey: string, text: string, sig: string): boolean;

package/lib/message/ecdsa.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyMessageOfECDSA = exports.signMessageOfECDSA = void 0;
+const bitcore_lib_1 = __importDefault(require("bitcore-lib"));
+function signMessageOfECDSA(privateKey, text) {
+    const keyPair = privateKey;
+    const message = new bitcore_lib_1.default.Message(text);
+    // @ts-ignore
+    return message.sign(new bitcore_lib_1.default.PrivateKey(keyPair.privateKey));
+}
+exports.signMessageOfECDSA = signMessageOfECDSA;
+function verifyMessageOfECDSA(publicKey, text, sig) {
+    const message = new bitcore_lib_1.default.Message(text);
+    // @ts-ignore
+    const signature = bitcore_lib_1.default.crypto.Signature.fromCompact(Buffer.from(sig, 'base64'));
+    const hash = message.magicHash();
+    // recover the public key
+    // @ts-ignore
+    const ecdsa = new bitcore_lib_1.default.crypto.ECDSA();
+    ecdsa.hashbuf = hash;
+    ecdsa.sig = signature;
+    const pubkeyInSig = ecdsa.toPublicKey();
+    const pubkeyInSigString = new bitcore_lib_1.default.PublicKey(Object.assign({}, pubkeyInSig.toObject(), { compressed: true })).toString();
+    if (pubkeyInSigString != publicKey) {
+        return false;
+    }
+    return bitcore_lib_1.default.crypto.ECDSA.verify(hash, signature, pubkeyInSig);
+}
+exports.verifyMessageOfECDSA = verifyMessageOfECDSA;

package/lib/message/index.d.ts

@@ -0,0 +1,3 @@
+export * from './bip322-simple';
+export * from './deterministic-ecdsa';
+export * from './ecdsa';

package/lib/message/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bip322-simple"), exports);
+__exportStar(require("./deterministic-ecdsa"), exports);
+__exportStar(require("./ecdsa"), exports);

package/lib/network/index.d.ts

@@ -0,0 +1,14 @@
+import { bitcoin } from '../bitcoin-core';
+export declare enum NetworkType {
+    MAINNET = 0,
+    TESTNET = 1,
+    REGTEST = 2
+}
+/**
+ * Convert network type to bitcoinjs-lib network.
+ */
+export declare function toPsbtNetwork(networkType: NetworkType): bitcoin.networks.Network;
+/**
+ * Convert bitcoinjs-lib network to network type.
+ */
+export declare function toNetworkType(network: bitcoin.Network): NetworkType;

package/lib/network/index.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toNetworkType = exports.toPsbtNetwork = exports.NetworkType = void 0;
+const bitcoin_core_1 = require("../bitcoin-core");
+var NetworkType;
+(function (NetworkType) {
+    NetworkType[NetworkType["MAINNET"] = 0] = "MAINNET";
+    NetworkType[NetworkType["TESTNET"] = 1] = "TESTNET";
+    NetworkType[NetworkType["REGTEST"] = 2] = "REGTEST";
+})(NetworkType = exports.NetworkType || (exports.NetworkType = {}));
+/**
+ * Convert network type to bitcoinjs-lib network.
+ */
+function toPsbtNetwork(networkType) {
+    if (networkType === NetworkType.MAINNET) {
+        return bitcoin_core_1.bitcoin.networks.bitcoin;
+    }
+    else if (networkType === NetworkType.TESTNET) {
+        return bitcoin_core_1.bitcoin.networks.testnet;
+    }
+    else {
+        return bitcoin_core_1.bitcoin.networks.regtest;
+    }
+}
+exports.toPsbtNetwork = toPsbtNetwork;
+/**
+ * Convert bitcoinjs-lib network to network type.
+ */
+function toNetworkType(network) {
+    if (network.bech32 == bitcoin_core_1.bitcoin.networks.bitcoin.bech32) {
+        return NetworkType.MAINNET;
+    }
+    else if (network.bech32 == bitcoin_core_1.bitcoin.networks.testnet.bech32) {
+        return NetworkType.TESTNET;
+    }
+    else {
+        return NetworkType.REGTEST;
+    }
+}
+exports.toNetworkType = toNetworkType;

package/lib/runes/index.d.ts

@@ -0,0 +1 @@
+export * from './varint';

package/lib/runes/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./varint"), exports);

package/lib/runes/rund_id.d.ts

@@ -0,0 +1,11 @@
+export declare class RuneId {
+    block: number;
+    tx: number;
+    constructor({ block, tx }: {
+        block: number;
+        tx: number;
+    });
+    static fromBigInt(n: any): RuneId;
+    toString(): string;
+    static fromString(s: string): RuneId;
+}

package/lib/runes/rund_id.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RuneId = void 0;
+const big_integer_1 = __importDefault(require("big-integer"));
+class RuneId {
+    constructor({ block, tx }) {
+        this.block = block;
+        this.tx = tx;
+    }
+    static fromBigInt(n) {
+        const bigN = (0, big_integer_1.default)(n);
+        const block = bigN.shiftRight(16);
+        const tx = bigN.and(0xffff);
+        if (block.greater(Number.MAX_SAFE_INTEGER) || tx.greater(Number.MAX_SAFE_INTEGER)) {
+            throw new Error('Integer overflow');
+        }
+        return new RuneId({ block: block.toJSNumber(), tx: tx.toJSNumber() });
+    }
+    toString() {
+        return `${this.block}:${this.tx}`;
+    }
+    static fromString(s) {
+        const [block, tx] = s.split(':').map(Number);
+        return new RuneId({ block, tx });
+    }
+}
+exports.RuneId = RuneId;

package/lib/runes/varint.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+declare function try_decode(buf: any): (string | number)[];
+declare function encodeToVec(n: any, v: any): void;
+declare function decode(buffer: any): {
+    num: string | number;
+    index: string | number;
+};
+declare function encode(n: any): Buffer;
+export declare const varint: {
+    encode: typeof encode;
+    decode: typeof decode;
+    try_decode: typeof try_decode;
+    encodeToVec: typeof encodeToVec;
+};
+export {};

package/lib/runes/varint.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.varint = void 0;
+const big_integer_1 = __importDefault(require("big-integer"));
+function try_decode(buf) {
+    let n = (0, big_integer_1.default)(0);
+    let m = (0, big_integer_1.default)(1);
+    for (let i = 0;; i++) {
+        if (i >= buf.length) {
+            throw new Error('Buffer too short');
+        }
+        let byte = (0, big_integer_1.default)(buf.readUInt8(i));
+        n = n.plus(byte.and(0x7f).multiply(m));
+        if (byte.and(0x80).equals(0)) {
+            return [n.toString(), i + 1];
+        }
+        m = m.shiftLeft(7);
+    }
+}
+function encodeToVec(n, v) {
+    n = (0, big_integer_1.default)(n);
+    while (n.shiftRight(7).greater(0)) {
+        v.push(n.and(0b01111111).or(0b10000000).toJSNumber());
+        n = n.shiftRight(7);
+    }
+    v.push(n.toJSNumber());
+}
+function decode(buffer) {
+    const ret = try_decode(buffer);
+    return { num: ret[0], index: ret[1] };
+}
+function encode(n) {
+    let v = [];
+    encodeToVec(n, v);
+    return Buffer.from(new Uint8Array(v));
+}
+exports.varint = {
+    encode,
+    decode,
+    try_decode,
+    encodeToVec
+};

package/lib/src/address/index.d.ts

@@ -0,0 +1,37 @@
+/// <reference types="node" />
+import { NetworkType } from '../network';
+import { AddressType } from '../types';
+import * as bitcoin from 'bitcoinjs-lib';
+/**
+ * Convert public key to bitcoin payment object.
+ */
+export declare function publicKeyToPayment(publicKey: string, type: AddressType, networkType: NetworkType): bitcoin.payments.Payment;
+/**
+ * Convert public key to bitcoin address.
+ */
+export declare function publicKeyToAddress(publicKey: string, type: AddressType, networkType: NetworkType): string;
+/**
+ * Convert public key to bitcoin scriptPk.
+ */
+export declare function publicKeyToScriptPk(publicKey: string, type: AddressType, networkType: NetworkType): string;
+/**
+ * Convert bitcoin address to scriptPk.
+ */
+export declare function addressToScriptPk(address: string, networkType: NetworkType): Buffer;
+/**
+ * Check if the address is valid.
+ */
+export declare function isValidAddress(address: string, networkType?: NetworkType): boolean;
+export declare function decodeAddress(address: string): {
+    networkType: NetworkType;
+    addressType: AddressType;
+    dust: number;
+};
+/**
+ * Get address type.
+ */
+export declare function getAddressType(address: string, networkType?: NetworkType): AddressType;
+/**
+ * Convert scriptPk to address.
+ */
+export declare function scriptPkToAddress(scriptPk: string | Buffer, networkType?: NetworkType): string;

package/lib/src/bitcoin-core.d.ts

@@ -0,0 +1,5 @@
+import * as ecc from '@bitcoinerlab/secp256k1';
+import * as bitcoin from 'bitcoinjs-lib';
+export declare const ECPair: import("ecpair").ECPairAPI;
+export { ECPairInterface } from 'ecpair';
+export { ecc, bitcoin };

package/lib/src/constants.d.ts

@@ -0,0 +1 @@
+export declare const UTXO_DUST = 546;

package/lib/src/error.d.ts

@@ -0,0 +1,20 @@
+export declare enum ErrorCodes {
+    UNKNOWN = -1,
+    INSUFFICIENT_BTC_UTXO = -2,
+    INSUFFICIENT_ASSET_UTXO = -3,
+    NOT_SAFE_UTXOS = -4,
+    ASSET_MAYBE_LOST = -5,
+    ONLY_ONE_ARC20_CAN_BE_SENT = -6
+}
+export declare const ErrorMessages: {
+    [-1]: string;
+    [-2]: string;
+    [-3]: string;
+    [-4]: string;
+    [-5]: string;
+    [-6]: string;
+};
+export declare class WalletUtilsError extends Error {
+    code: ErrorCodes;
+    constructor(code: ErrorCodes, message?: string);
+}

package/lib/src/index.d.ts

@@ -0,0 +1,14 @@
+export * as address from './address';
+export * as core from './bitcoin-core';
+export * from './constants';
+export * as keyring from './keyring';
+export * as message from './message';
+export * as transaction from './transaction';
+export * as txHelpers from './tx-helpers';
+export * from './types';
+export * as utils from './utils';
+export * as wallet from './wallet';
+export * from './keyring/interfaces/SimpleKeyringOptions';
+export * from './keyring/hd-keyring';
+export * from './keyring/keystone-keyring';
+export * from './keyring/simple-keyring';

package/lib/src/keyring/hd-keyring.d.ts

@@ -0,0 +1,50 @@
+import bitcore from 'bitcore-lib';
+import { ECPairInterface } from '../bitcoin-core';
+import { DeserializeOption, IKeyringBase } from './interfaces/SimpleKeyringOptions';
+export declare class HdKeyring extends IKeyringBase<DeserializeOption> {
+    static type: string;
+    type: string;
+    mnemonic: string;
+    xpriv: string;
+    passphrase: string;
+    hdPath: string;
+    root: bitcore.HDPrivateKey;
+    hdWallet?: any;
+    wallets: ECPairInterface[];
+    activeIndexes: number[];
+    page: number;
+    perPage: number;
+    private _index2wallet;
+    constructor(opts?: DeserializeOption);
+    serialize(): DeserializeOption;
+    deserialize(_opts?: DeserializeOption): void;
+    initFromXpriv(xpriv: string): void;
+    initFromMnemonic(mnemonic: string): void;
+    changeHdPath(hdPath: string): void;
+    getAccountByHdPath(hdPath: string, index: number): string;
+    addAccounts(numberOfAccounts?: number): string[];
+    activeAccounts(indexes: number[]): string[];
+    getFirstPage(): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    getNextPage(): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    getPreviousPage(): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    getAddresses(start: number, end: number): {
+        address: string;
+        index: number;
+    }[];
+    __getPage(increment: number): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    getAccounts(): string[];
+    getIndexByAddress(address: string): number;
+    private _addressFromIndex;
+}

package/lib/src/keyring/index.d.ts

@@ -0,0 +1,4 @@
+export * from './hd-keyring';
+export * from './keystone-keyring';
+export * from './simple-keyring';
+export * from './interfaces/SimpleKeyringOptions';

package/lib/src/keyring/interfaces/SimpleKeyringOptions.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="node" />
+import { Network, Psbt } from 'bitcoinjs-lib';
+import { EventEmitter } from 'events';
+import { ECPairInterface } from 'ecpair';
+interface BaseKeyringOptions {
+    readonly network?: Network;
+}
+export interface SimpleKeyringOptions extends BaseKeyringOptions {
+    readonly privateKeys?: string[];
+}
+export interface DeserializeOptionBase extends BaseKeyringOptions {
+    readonly hdPath?: string;
+    readonly activeIndexes?: number[];
+}
+export interface DeserializeOption extends DeserializeOptionBase {
+    readonly mnemonic?: string;
+    readonly xpriv?: string;
+    readonly passphrase?: string;
+}
+export interface KeystoneKey {
+    readonly path: string;
+    readonly extendedPublicKey: string;
+}
+export interface DeserializeOptionKeystone extends DeserializeOptionBase {
+    readonly mfp: string;
+    readonly keys: KeystoneKey[];
+}
+export type KeyringOptions = SimpleKeyringOptions | DeserializeOption | DeserializeOptionKeystone;
+export declare abstract class IKeyringBase<T extends BaseKeyringOptions> extends EventEmitter {
+    readonly network: Network;
+    static type: string;
+    type: string;
+    protected wallets: ECPairInterface[];
+    protected constructor(network?: Network);
+    abstract serialize(): T;
+    abstract addAccounts(numberOfAccounts: number): string[];
+    abstract deserialize(opts?: T): unknown;
+    removeAccount(publicKey: string): void;
+    verifyMessage(publicKey: string, text: string, sig: string): Promise<boolean>;
+    signData(publicKey: string, data: string, type?: 'ecdsa' | 'schnorr'): string;
+    abstract getAccounts(): string[];
+    signMessage(publicKey: string, text: string): string;
+    exportAccount(publicKey: string): string;
+    signTransaction(psbt: Psbt, inputs: {
+        index: number;
+        publicKey: string;
+        sighashTypes?: number[];
+        disableTweakSigner?: boolean;
+    }[], opts?: any): Psbt;
+    private _getWalletForAccount;
+    private _getPrivateKeyFor;
+}
+export {};

package/lib/src/keyring/keystone-keyring.d.ts

@@ -0,0 +1,82 @@
+import bitcore from 'bitcore-lib';
+import { DeserializeOptionKeystone, IKeyringBase, KeystoneKey } from './interfaces/SimpleKeyringOptions';
+interface Wallet {
+    index: number;
+    publicKey: string;
+    path: string;
+}
+export declare class KeystoneKeyring extends IKeyringBase<DeserializeOptionKeystone> {
+    static type: string;
+    type: string;
+    mfp: string;
+    keys: KeystoneKey[];
+    hdPath?: string;
+    activeIndexes?: number[];
+    root: bitcore.HDPublicKey;
+    page: number;
+    perPage: number;
+    origin: string;
+    constructor(opts?: DeserializeOptionKeystone);
+    initFromUR(type: string, cbor: string): Promise<void>;
+    getHardenedPath(hdPath: string): string;
+    getHDPublicKey(hdPath: string): bitcore.HDPublicKey;
+    getDefaultHdPath(): string;
+    initRoot(): void;
+    deserialize(opts: DeserializeOptionKeystone): void;
+    serialize(): DeserializeOptionKeystone;
+    addAccounts(numberOfAccounts?: number): string[];
+    addChangeAddressAccounts(numberOfAccounts?: number): Promise<any[]>;
+    getAccounts(): string[];
+    getAccounts2(): Promise<{
+        index: number;
+        path: string;
+        publicKey: string;
+    }[]>;
+    getAccountsWithBrand(): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    getWalletByIndex(index: number): Wallet;
+    getChangeAddressWalletByIndex(index: number): Wallet;
+    removeAccount(publicKey: string): void;
+    exportAccount(_publicKey: string): string;
+    getFirstPage(): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    getNextPage(): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    getPreviousPage(): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    getAddresses(start: number, end: number): {
+        address: string;
+        index: number;
+    }[];
+    getPage(increment: number): Promise<{
+        address: string;
+        index: number;
+    }[]>;
+    activeAccounts(indexes: number[]): string[];
+    changeHdPath(hdPath: string): void;
+    changeChangeAddressHdPath(hdPath: string): any[];
+    getAccountByHdPath(hdPath: string, index: number): string;
+    getChangeAddressAccountByHdPath(hdPath: string, index: number): string;
+    genSignPsbtUr(psbtHex: string): Promise<{
+        type: string;
+        cbor: string;
+    }>;
+    parseSignPsbtUr(type: string, cbor: string): Promise<string>;
+    genSignMsgUr(publicKey: string, text: string): Promise<{
+        requestId: any;
+        type: string;
+        cbor: string;
+    }>;
+    parseSignMsgUr(type: string, cbor: string): Promise<import("@keystonehq/keystone-sdk").BtcSignature>;
+    signMessage(publicKey: string, text: string): string;
+    verifyMessage(publicKey: string, text: string, sig: string): Promise<boolean>;
+}
+export {};

package/lib/src/keyring/simple-keyring.d.ts

@@ -0,0 +1,11 @@
+import { IKeyringBase, SimpleKeyringOptions } from './interfaces/SimpleKeyringOptions';
+export declare class SimpleKeyring extends IKeyringBase<SimpleKeyringOptions> {
+    static type: string;
+    type: string;
+    constructor(opts?: SimpleKeyringOptions);
+    serialize(): SimpleKeyringOptions;
+    deserialize(opts: SimpleKeyringOptions): void;
+    addAccounts(n?: number): string[];
+    getAccounts(): string[];
+}
+export declare function verifySignData(publicKey: string, hash: string, type: 'ecdsa' | 'schnorr', signature: string): boolean;

package/lib/src/message/bip322-simple.d.ts

@@ -0,0 +1,19 @@
+import { NetworkType } from '../network';
+import { AbstractWallet } from '../wallet';
+import * as bitcoin from 'bitcoinjs-lib';
+export declare function genPsbtOfBIP322Simple({ message, address, networkType }: {
+    message: string;
+    address: string;
+    networkType: NetworkType;
+}): bitcoin.Psbt;
+export declare function getSignatureFromPsbtOfBIP322Simple(psbt: bitcoin.Psbt): string;
+/**
+ * reference: https://github.com/bitcoin/bips/blob/master/bip-0322.mediawiki
+ */
+export declare function signMessageOfBIP322Simple({ message, address, networkType, wallet }: {
+    message: string;
+    address: string;
+    networkType: NetworkType;
+    wallet: AbstractWallet;
+}): Promise<string>;
+export declare function verifyMessageOfBIP322Simple(address: string, msg: string, signature: string, networkType?: NetworkType): boolean;

package/lib/src/message/deterministic-ecdsa.d.ts

@@ -0,0 +1,2 @@
+import { ECPairInterface } from '../bitcoin-core';
+export declare function signMessageOfDeterministicECDSA(ecpair: ECPairInterface, message: string): string;

package/lib/src/message/ecdsa.d.ts

@@ -0,0 +1,3 @@
+import { ECPairInterface } from 'ecpair';
+export declare function signMessageOfECDSA(privateKey: ECPairInterface, text: string): string;
+export declare function verifyMessageOfECDSA(publicKey: string, text: string, sig: string): boolean;

package/lib/src/message/index.d.ts

@@ -0,0 +1,3 @@
+export * from './bip322-simple';
+export * from './deterministic-ecdsa';
+export * from './ecdsa';