postchain-client/built/src/formatter.js

Client library for accessing a Postchain node through REST.

import { isRawGtx } from "./blockchainClient/validation/rawGtx";
export function pgBytes(buffer) {
    if (!Buffer.isBuffer(buffer)) {
        throw new PgBytesInputException(buffer);
    }
    return `\\x${buffer.toString("hex")}`;
}
/**
 * Converts hex string to Buffer
 * @param key: string
 * @returns {Buffer}
 */
export function toBuffer(key) {
    return Buffer.from(key, "hex");
}
/**
 * Converts Buffer to hex string
 * @param buffer: Buffer
 * @returns {string}
 */
export function toString(buffer) {
    return buffer.toString("hex").toUpperCase();
}
export function toQueryObjectGTV(nameOrObject, queryArguments) {
    if (typeof nameOrObject === "string") {
        return [nameOrObject, Object.assign({}, queryArguments)];
    }
    else {
        const { name, args } = nameOrObject;
        return [name, args || {}];
    }
}
export class PgBytesInputException extends Error {
    constructor(buffer) {
        super(`util.pgBytes expects a buffer, but got ${typeof buffer}`);
    }
}
export function ensureBuffer(value) {
    if (value instanceof Buffer) {
        return value;
    }
    else {
        return toBuffer(value);
    }
}
export function ensureString(value) {
    if (typeof value === "string") {
        return value.toUpperCase();
    }
    else {
        return toString(value);
    }
}
export function checkGtvType(value) {
    try {
        if (value == null) {
            return true;
        }
        if (Buffer.isBuffer(value)) {
            return true;
        }
        if (typeof value === "string" || typeof value === "bigint") {
            return true;
        }
        if (typeof value === "number") {
            if (!Number.isInteger(value)) {
                throw Error("User error: Only integers are supported");
            }
            return true;
        }
        if (Array.isArray(value)) {
            return value.every(item => checkGtvType(item));
        }
        if (typeof value === "object") {
            return Object.values(value).every(val => checkGtvType(val));
        }
    }
    catch (error) {
        throw new Error(`Failed to check type: ${error}`);
    }
    return false;
}
export function rawGtxToGtx(rawGtx) {
    const rawGtxBody = rawGtx[0];
    const signatures = rawGtx[1];
    const gtxBody = {
        blockchainRid: rawGtxBody[0],
        operations: rawGtxBody[1].map((operation) => ({
            opName: operation[0],
            args: operation[1],
        })),
        signers: rawGtxBody[2],
    };
    return {
        blockchainRid: gtxBody.blockchainRid,
        operations: gtxBody.operations,
        signers: gtxBody.signers,
        signatures,
    };
}
export function rawGtxToRawGtxBody(rawGtx) {
    return rawGtx[0];
}
export function checkGtxType(value) {
    if (!isRawGtx(value))
        return false;
    try {
        rawGtxToGtx(value);
        return true;
    }
    catch (error) {
        return false;
    }
}
export function removeDuplicateSigners(signers) {
    const signersAsString = [];
    signers.forEach(item => {
        const itemAsString = item.toString("hex");
        if (!signersAsString.includes(itemAsString)) {
            signersAsString.push(itemAsString);
        }
    });
    const result = [];
    signersAsString.forEach(item => {
        result.push(Buffer.from(item, "hex"));
    });
    return result;
}
export function matchRellErrorString(rellError) {
    const parsed = rellError.match(/\[([^\]]+)\]\sOperation\s'([^']+)'\sfailed:\s(.+)$/);
    if (!parsed)
        return {};
    const [rellLine, operation, shortReason] = parsed.slice(1);
    return { shortReason, rellLine, operation };
}
//# sourceMappingURL=formatter.js.map