@gluneau/hive-mcp-server
Version:
An MCP server that enables AI assistants to interact with the Hive blockchain
128 lines • 5.64 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.signMessage = signMessage;
exports.verifySignature = verifySignature;
// Cryptography tools implementation
const dhive_1 = require("@hiveio/dhive");
const config_1 = __importDefault(require("../config"));
const error_1 = require("../utils/error");
const response_1 = require("../utils/response");
// Sign a message using a private key
function signMessage(params) {
return __awaiter(this, void 0, void 0, function* () {
try {
// Get the private key from environment variables
let keyEnvVar;
switch (params.key_type) {
case 'posting':
keyEnvVar = config_1.default.hive.postingKey;
break;
case 'active':
keyEnvVar = config_1.default.hive.activeKey;
break;
case 'memo':
keyEnvVar = config_1.default.hive.memoKey;
break;
case 'owner':
keyEnvVar = config_1.default.hive.ownerKey;
break;
default:
return (0, response_1.errorResponse)(`Error: Invalid key_type: ${params.key_type}`);
}
// Check if the key is available
if (!keyEnvVar) {
return (0, response_1.errorResponse)(`Error: HIVE_${params.key_type.toUpperCase()}_KEY environment variable is not set`);
}
// Create PrivateKey object
let privateKey;
try {
privateKey = dhive_1.PrivateKey.fromString(keyEnvVar);
}
catch (error) {
return (0, response_1.errorResponse)(`Error: Invalid ${params.key_type} key format`);
}
// Hash the message with sha256 before signing
const messageHash = dhive_1.cryptoUtils.sha256(params.message);
// Sign the message hash
let signature;
try {
signature = privateKey.sign(messageHash).toString();
}
catch (error) {
return (0, response_1.errorResponse)(`Error signing message: ${error instanceof Error ? error.message : String(error)}`);
}
// Get the public key
const publicKey = privateKey.createPublic().toString();
return (0, response_1.successJson)({
success: true,
message_hash: messageHash.toString('hex'),
signature,
public_key: publicKey,
});
}
catch (error) {
return (0, response_1.errorResponse)((0, error_1.handleError)(error, 'sign_message'));
}
});
}
// Verify a message signature
function verifySignature(params) {
return __awaiter(this, void 0, void 0, function* () {
try {
// Parse the public key (handling keys with or without the STM prefix)
let publicKey;
try {
publicKey = params.public_key.startsWith('STM')
? params.public_key
: `STM${params.public_key}`;
publicKey = dhive_1.PublicKey.fromString(publicKey);
}
catch (error) {
return (0, response_1.errorResponse)('Error: Invalid public key format');
}
// Parse the signature
let signatureObj;
try {
signatureObj = dhive_1.Signature.fromString(params.signature);
}
catch (error) {
return (0, response_1.errorResponse)('Error: Invalid signature format');
}
// Validate and parse the message hash
let messageHashBuffer;
try {
if (!/^[0-9a-fA-F]{64}$/.test(params.message_hash)) {
throw new Error('Message hash must be a 64-character hex string');
}
messageHashBuffer = Buffer.from(params.message_hash, 'hex');
}
catch (error) {
return (0, response_1.errorResponse)('Error: Invalid message hash format - must be a 64-character hex string');
}
// Verify the signature against the hash
const isValid = publicKey.verify(messageHashBuffer, signatureObj);
return (0, response_1.successJson)({
success: true,
is_valid: isValid,
message_hash: params.message_hash,
public_key: publicKey.toString(),
});
}
catch (error) {
return (0, response_1.errorResponse)((0, error_1.handleError)(error, 'verify_signature'));
}
});
}
//# sourceMappingURL=crypto.js.map