@gear-js/api/lib/cjs/api/Storage.js

A JavaScript library that provides functionality to connect GEAR Component APIs.

'use strict';

var util = require('@polkadot/util');
var program_errors = require('../errors/program.errors.js');

class GearProgramStorage {
    _api;
    constructor(_api) {
        this._api = _api;
    }
    /**
     * ### Get program from chain
     * @param id Program id
     * @param at _(optional)_ Hash of block to query at
     * @returns
     */
    async getProgram(id, at) {
        const api = at ? await this._api.at(at) : this._api;
        const programOption = (await api.query.gearProgram.programStorage(id));
        if (programOption.isNone) {
            throw new program_errors.ProgramDoesNotExistError(id);
        }
        const program = programOption.unwrap();
        if (program.isTerminated)
            throw new program_errors.ProgramTerminatedError(program.asTerminated.toHex());
        if (program.isExited)
            throw new program_errors.ProgramExitedError(program.asExited.toHex());
        return program.asActive;
    }
    /**
     * Get list of pages for program
     * @param programId
     * @param gProg
     * @returns
     */
    async getProgramPages(programId, program, at) {
        const pages = {};
        const blockAt = at || (await this._api.rpc.chain.getHeader()).hash.toHex();
        const apiAt = await this._api.at(blockAt);
        const keys = await apiAt.query.gearProgram.memoryPages.keys(programId, program.memoryInfix);
        const pageNumbers = keys.map((k) => {
            const u8aAddr = k.toU8a();
            const page = u8aAddr.slice(u8aAddr.length - 4);
            return util.u8aToNumber(page, { isLe: true });
        });
        for (let i = 0; i < pageNumbers.length; i++) {
            const page = pageNumbers[i];
            pages[page] = (await this._api.rpc.state.getStorage(keys[i].toHex(), blockAt)).toU8a();
        }
        return pages;
    }
    /**
     * ### Get block number and hash of paused program
     * @param id paused program id
     * @param at _(optional)_ Hash of block to query at
     * @returns
     */
    async getPausedProgramHashAndBlockNumber(id, at) {
        const storageOption = (await this._api.query.gearProgram.pausedProgramStorage(id, at));
        if (storageOption.isNone) {
            throw new program_errors.PausedProgramDoesNotExistError(id);
        }
        const storage = storageOption.unwrap();
        return {
            blockNumber: storage[0],
            hash: storage[1],
        };
    }
}

exports.GearProgramStorage = GearProgramStorage;