chaingate
Version:
A complete TypeScript library for connecting to and making transactions on different blockchains
119 lines • 4.83 kB
JavaScript
;
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 () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.Bech32UtxoCurrencyUtils = void 0;
const UtxoCurrencyUtils_1 = require("../UtxoCurrencyUtils/UtxoCurrencyUtils");
const PublicKey_1 = require("../../../../Wallet/entities/PublicKey");
const btc = __importStar(require("@scure/btc-signer"));
const MessageSigner_1 = require("../../../CurrencyWallet/abstract/UtxoWallet/MessageSigner");
class Bech32UtxoCurrencyUtils extends UtxoCurrencyUtils_1.UtxoCurrencyUtils {
constructor(client, currencyInfo, markets, network, networkParams, signHeader) {
super(client, currencyInfo, markets, network, networkParams, signHeader);
}
publicKeyToAddress(publicKey, addressType = 'segwit-p2wpkh') {
let publicKeyRaw = publicKey.raw;
switch (addressType) {
case 'legacy-p2pkh':
return btc.p2pkh(publicKeyRaw, this.networkParams).address;
case 'legacy-p2pk':
return btc.p2pkh(publicKeyRaw).address;
case 'segwit-p2wpkh':
return btc.p2wpkh(publicKeyRaw, this.networkParams).address;
case 'taproot-p2tr':
if (publicKeyRaw.length === 33)
publicKeyRaw = publicKeyRaw.slice(1);
return btc.p2tr(publicKeyRaw, undefined, this.networkParams).address;
default:
throw new Error(`Address type "${addressType}" not supported`);
}
}
identifyAddressType(address) {
try {
const addr = btc.Address(this.networkParams).decode(address);
switch (addr.type) {
case 'pkh':
return 'legacy-p2pkh';
case 'sh':
return 'legacy-p2sh';
case 'pk':
return 'legacy-p2pk';
case 'ms':
return 'legacy-p2ms';
case 'wpkh':
return 'segwit-p2wpkh';
case 'wsh':
return 'segwit-p2wsh';
case 'tr':
return 'taproot-p2tr';
case 'tr_ns':
return 'taproot-n-of-n';
case 'tr_ms':
return 'taproot-m-of-n';
case 'p2a':
return 'anchor';
default:
return 'unknown';
}
}
catch {
return 'unknown';
}
}
signMessage(message, privateKey) {
return (0, MessageSigner_1.signMessage)(message, privateKey, this.signHeader);
}
async verifySignedMessage(message, signature, address) {
const publicKeyRaw = await (0, MessageSigner_1.getSignedMessagePublicKey)(message, signature, this.signHeader);
const publicKey = new PublicKey_1.PublicKey(publicKeyRaw);
const addressType = this.identifyAddressType(address);
const supportedTypes = [
'legacy-p2pkh',
'legacy-p2pk',
'segwit-p2wpkh',
'taproot-p2tr',
];
if (!supportedTypes.includes(addressType))
return false;
try {
const derivedAddress = this.publicKeyToAddress(publicKey, addressType);
return derivedAddress === address;
}
catch {
return false;
}
}
}
exports.Bech32UtxoCurrencyUtils = Bech32UtxoCurrencyUtils;
//# sourceMappingURL=Bech32UtxoCurrencyUtils.js.map