@okxweb3/coin-stellar/dist/stellar_base/memo.js

@okxweb3/coin-stellar is a Stellar SDK for building Web3 wallets and applications. It supports Stellar and PI blockchains, enabling private key management, address generation, transaction signing, trustline creation, and asset transfers

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Memo = exports.MemoReturn = exports.MemoHash = exports.MemoText = exports.MemoID = exports.MemoNone = void 0;
const js_xdr_1 = require("@stellar/js-xdr");
const bignumber_1 = __importDefault(require("./util/bignumber"));
const xdr_1 = __importDefault(require("./xdr"));
exports.MemoNone = 'none';
exports.MemoID = 'id';
exports.MemoText = 'text';
exports.MemoHash = 'hash';
exports.MemoReturn = 'return';
class Memo {
    constructor(type, value = null) {
        this._type = type;
        this._value = value;
        switch (this._type) {
            case exports.MemoNone:
                break;
            case exports.MemoID:
                Memo._validateIdValue(value);
                break;
            case exports.MemoText:
                Memo._validateTextValue(value);
                break;
            case exports.MemoHash:
            case exports.MemoReturn:
                Memo._validateHashValue(value);
                if (typeof value === 'string') {
                    this._value = Buffer.from(value, 'hex');
                }
                break;
            default:
                throw new Error('Invalid memo type');
        }
    }
    get type() {
        return this._type;
    }
    set type(type) {
        throw new Error('Memo is immutable');
    }
    get value() {
        switch (this._type) {
            case exports.MemoNone:
                return null;
            case exports.MemoID:
            case exports.MemoText:
                return this._value;
            case exports.MemoHash:
            case exports.MemoReturn:
                return Buffer.from(this._value);
            default:
                throw new Error('Invalid memo type');
        }
    }
    set value(value) {
        throw new Error('Memo is immutable');
    }
    static _validateIdValue(value) {
        const error = new Error(`Expects a int64 as a string. Got ${value}`);
        if (typeof value !== 'string') {
            throw error;
        }
        let number;
        try {
            number = new bignumber_1.default(value);
        }
        catch (e) {
            throw error;
        }
        if (!number.isFinite()) {
            throw error;
        }
        if (number.isNaN()) {
            throw error;
        }
    }
    static _validateTextValue(value) {
        if (!xdr_1.default.Memo.armTypeForArm('text').isValid(value)) {
            throw new Error('Expects string, array or buffer, max 28 bytes');
        }
    }
    static _validateHashValue(value) {
        const error = new Error(`Expects a 32 byte hash value or hex encoded string. Got ${value}`);
        if (value === null || typeof value === 'undefined') {
            throw error;
        }
        let valueBuffer;
        if (typeof value === 'string') {
            if (!/^[0-9A-Fa-f]{64}$/g.test(value)) {
                throw error;
            }
            valueBuffer = Buffer.from(value, 'hex');
        }
        else if (Buffer.isBuffer(value)) {
            valueBuffer = Buffer.from(value);
        }
        else {
            throw error;
        }
        if (!valueBuffer.length || valueBuffer.length !== 32) {
            throw error;
        }
    }
    static none() {
        return new Memo(exports.MemoNone);
    }
    static text(text) {
        return new Memo(exports.MemoText, text);
    }
    static id(id) {
        return new Memo(exports.MemoID, id);
    }
    static hash(hash) {
        return new Memo(exports.MemoHash, hash);
    }
    static return(hash) {
        return new Memo(exports.MemoReturn, hash);
    }
    toXDRObject() {
        switch (this._type) {
            case exports.MemoNone:
                return xdr_1.default.Memo.memoNone();
            case exports.MemoID:
                return xdr_1.default.Memo.memoId(js_xdr_1.UnsignedHyper.fromString(this._value));
            case exports.MemoText:
                return xdr_1.default.Memo.memoText(this._value);
            case exports.MemoHash:
                return xdr_1.default.Memo.memoHash(this._value);
            case exports.MemoReturn:
                return xdr_1.default.Memo.memoReturn(this._value);
            default:
                return null;
        }
    }
    static fromXDRObject(object) {
        switch (object.arm()) {
            case 'id':
                return Memo.id(object.value().toString());
            case 'text':
                return Memo.text(object.value());
            case 'hash':
                return Memo.hash(object.value());
            case 'retHash':
                return Memo.return(object.value());
            default:
                break;
        }
        if (typeof object.value() === 'undefined') {
            return Memo.none();
        }
        throw new Error('Unknown type');
    }
}
exports.Memo = Memo;
//# sourceMappingURL=memo.js.map