@onekeyfe/blockchain-libs
Version:
OneKey Blockchain Libs
92 lines • 4.04 kB
JavaScript
;
/* Copyright (c) 2019 Algorand, llc */
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
}) : (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;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.isValidAddress = exports.decodeAddress = exports.encodeAddress = exports.ALGORAND_ZERO_ADDRESS_STRING = void 0;
const hi_base32_1 = __importDefault(require("hi-base32"));
const nacl = __importStar(require("./naclWrappers"));
const utils = __importStar(require("./utils"));
const ALGORAND_ADDRESS_BYTE_LENGTH = 36;
const ALGORAND_CHECKSUM_BYTE_LENGTH = 4;
const ALGORAND_ADDRESS_LENGTH = 58;
exports.ALGORAND_ZERO_ADDRESS_STRING = 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ';
const MALFORMED_ADDRESS_ERROR_MSG = 'address seems to be malformed';
const CHECKSUM_ADDRESS_ERROR_MSG = 'wrong checksum for address';
/**
* decodeAddress takes an Algorand address in string form and decodes it into a Uint8Array.
* @param address - an Algorand address with checksum.
* @returns the decoded form of the address's public key and checksum
*/
function decodeAddress(address) {
if (address.length !== ALGORAND_ADDRESS_LENGTH)
throw new Error(MALFORMED_ADDRESS_ERROR_MSG);
// try to decode
const decoded = hi_base32_1.default.decode.asBytes(address.toString());
// Sanity check
if (decoded.length !== ALGORAND_ADDRESS_BYTE_LENGTH)
throw new Error(MALFORMED_ADDRESS_ERROR_MSG);
// Find publickey and checksum
const pk = new Uint8Array(decoded.slice(0, ALGORAND_ADDRESS_BYTE_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH));
const cs = new Uint8Array(decoded.slice(nacl.PUBLIC_KEY_LENGTH, ALGORAND_ADDRESS_BYTE_LENGTH));
// Compute checksum
const checksum = nacl
.genericHash(pk)
.slice(nacl.HASH_BYTES_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH, nacl.HASH_BYTES_LENGTH);
// Check if the checksum and the address are equal
if (!utils.arrayEqual(checksum, cs))
throw new Error(CHECKSUM_ADDRESS_ERROR_MSG);
return { publicKey: pk, checksum: cs };
}
exports.decodeAddress = decodeAddress;
/**
* isValidAddress checks if a string is a valid Algorand address.
* @param address - an Algorand address with checksum.
* @returns true if valid, false otherwise
*/
function isValidAddress(address) {
// Try to decode
try {
decodeAddress(address);
}
catch (e) {
return false;
}
return true;
}
exports.isValidAddress = isValidAddress;
/**
* encodeAddress takes an Algorand address as a Uint8Array and encodes it into a string with checksum.
* @param address - a raw Algorand address
* @returns the address and checksum encoded as a string.
*/
function encodeAddress(address) {
// compute checksum
const checksum = nacl
.genericHash(address)
.slice(nacl.PUBLIC_KEY_LENGTH - ALGORAND_CHECKSUM_BYTE_LENGTH, nacl.PUBLIC_KEY_LENGTH);
const addr = hi_base32_1.default.encode(utils.concatArrays(address, checksum));
return addr.toString().slice(0, ALGORAND_ADDRESS_LENGTH); // removing the extra '===='
}
exports.encodeAddress = encodeAddress;
//# sourceMappingURL=address.js.map