pic-ic/dist/pocket-ic-client-types.js

An Internet Computer Protocol canister testing library for TypeScript and JavaScript.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SubnetType = exports.SubnetStateType = void 0;
exports.encodeCreateInstanceRequest = encodeCreateInstanceRequest;
exports.encodeGetPubKeyRequest = encodeGetPubKeyRequest;
exports.decodeInstanceTopology = decodeInstanceTopology;
exports.decodeSubnetTopology = decodeSubnetTopology;
exports.decodeSubnetKind = decodeSubnetKind;
exports.decodeGetTimeResponse = decodeGetTimeResponse;
exports.encodeSetTimeRequest = encodeSetTimeRequest;
exports.encodeGetSubnetIdRequest = encodeGetSubnetIdRequest;
exports.decodeGetSubnetIdResponse = decodeGetSubnetIdResponse;
exports.encodeGetCyclesBalanceRequest = encodeGetCyclesBalanceRequest;
exports.decodeGetCyclesBalanceResponse = decodeGetCyclesBalanceResponse;
exports.encodeAddCyclesRequest = encodeAddCyclesRequest;
exports.decodeAddCyclesResponse = decodeAddCyclesResponse;
exports.encodeUploadBlobRequest = encodeUploadBlobRequest;
exports.decodeUploadBlobResponse = decodeUploadBlobResponse;
exports.encodeSetStableMemoryRequest = encodeSetStableMemoryRequest;
exports.encodeGetStableMemoryRequest = encodeGetStableMemoryRequest;
exports.decodeGetStableMemoryResponse = decodeGetStableMemoryResponse;
exports.encodeEffectivePrincipal = encodeEffectivePrincipal;
exports.encodeCanisterCallRequest = encodeCanisterCallRequest;
exports.decodeCanisterCallResponse = decodeCanisterCallResponse;
const principal_1 = require("@dfinity/principal");
const util_1 = require("./util");
const error_1 = require("./error");
var SubnetStateType;
(function (SubnetStateType) {
    SubnetStateType["New"] = "new";
    SubnetStateType["FromPath"] = "fromPath";
})(SubnetStateType || (exports.SubnetStateType = SubnetStateType = {}));
function encodeManySubnetConfigs(configs = []) {
    return configs.map(encodeSubnetConfig).filter(util_1.isNotNil);
}
function encodeSubnetConfig(config) {
    if ((0, util_1.isNil)(config)) {
        return undefined;
    }
    switch (config.state.type) {
        default: {
            return undefined;
        }
        case SubnetStateType.New: {
            return {
                dts_flag: encodeDtsFlag(config.enableDeterministicTimeSlicing),
                instruction_config: encodeInstructionConfig(config.enableBenchmarkingInstructionLimits),
                state_config: 'New',
            };
        }
        case SubnetStateType.FromPath: {
            return {
                dts_flag: encodeDtsFlag(config.enableDeterministicTimeSlicing),
                instruction_config: encodeInstructionConfig(config.enableBenchmarkingInstructionLimits),
                state_config: {
                    FromPath: [
                        config.state.path,
                        { subnet_id: (0, util_1.base64EncodePrincipal)(config.state.subnetId) },
                    ],
                },
            };
        }
    }
}
function encodeDtsFlag(enableDeterministicTimeSlicing) {
    return enableDeterministicTimeSlicing === false ? 'Disabled' : 'Enabled';
}
function encodeInstructionConfig(enableBenchmarkingInstructionLimits) {
    return enableBenchmarkingInstructionLimits === true
        ? 'Benchmarking'
        : 'Production';
}
function encodeCreateInstanceRequest(req) {
    const defaultApplicationSubnet = {
        state: { type: SubnetStateType.New },
    };
    const defaultOptions = req ?? {
        application: [defaultApplicationSubnet],
    };
    const options = {
        nns: encodeSubnetConfig(defaultOptions.nns),
        sns: encodeSubnetConfig(defaultOptions.sns),
        ii: encodeSubnetConfig(defaultOptions.ii),
        fiduciary: encodeSubnetConfig(defaultOptions.fiduciary),
        bitcoin: encodeSubnetConfig(defaultOptions.bitcoin),
        system: encodeManySubnetConfigs(defaultOptions.system),
        application: encodeManySubnetConfigs(defaultOptions.application ?? [defaultApplicationSubnet]),
    };
    if (((0, util_1.isNil)(options.nns) &&
        (0, util_1.isNil)(options.sns) &&
        (0, util_1.isNil)(options.ii) &&
        (0, util_1.isNil)(options.fiduciary) &&
        (0, util_1.isNil)(options.bitcoin) &&
        options.system.length === 0 &&
        options.application.length === 0) ||
        options.system.length < 0 ||
        options.application.length < 0) {
        throw new error_1.TopologyValidationError();
    }
    return options;
}
function encodeGetPubKeyRequest(req) {
    return {
        subnet_id: (0, util_1.base64EncodePrincipal)(req.subnetId),
    };
}
var SubnetType;
(function (SubnetType) {
    SubnetType["Application"] = "Application";
    SubnetType["Bitcoin"] = "Bitcoin";
    SubnetType["Fiduciary"] = "Fiduciary";
    SubnetType["InternetIdentity"] = "II";
    SubnetType["NNS"] = "NNS";
    SubnetType["SNS"] = "SNS";
    SubnetType["System"] = "System";
})(SubnetType || (exports.SubnetType = SubnetType = {}));
function decodeInstanceTopology(encoded) {
    return Object.fromEntries(Object.entries(encoded).map(([subnetId, subnetTopology]) => [
        subnetId,
        decodeSubnetTopology(subnetId, subnetTopology),
    ]));
}
function decodeSubnetTopology(subnetId, encoded) {
    return {
        id: principal_1.Principal.fromText(subnetId),
        type: decodeSubnetKind(encoded.subnet_kind),
        size: encoded.size,
        canisterRanges: encoded.canister_ranges.map(range => ({
            start: (0, util_1.base64DecodePrincipal)(range.start.canister_id),
            end: (0, util_1.base64DecodePrincipal)(range.end.canister_id),
        })),
    };
}
function decodeSubnetKind(kind) {
    switch (kind) {
        case 'Application':
            return SubnetType.Application;
        case 'Bitcoin':
            return SubnetType.Bitcoin;
        case 'Fiduciary':
            return SubnetType.Fiduciary;
        case 'II':
            return SubnetType.InternetIdentity;
        case 'NNS':
            return SubnetType.NNS;
        case 'SNS':
            return SubnetType.SNS;
        case 'System':
            return SubnetType.System;
        default:
            throw new Error(`Unknown subnet kind: ${kind}`);
    }
}
function decodeGetTimeResponse(res) {
    return {
        millisSinceEpoch: res.nanos_since_epoch / 1_000_000,
    };
}
function encodeSetTimeRequest(req) {
    return {
        nanos_since_epoch: req.millisSinceEpoch * 1_000_000,
    };
}
function encodeGetSubnetIdRequest(req) {
    return {
        canister_id: (0, util_1.base64EncodePrincipal)(req.canisterId),
    };
}
function decodeGetSubnetIdResponse(res) {
    if ((0, util_1.isNil)(res)) {
        return { subnetId: null };
    }
    if ('subnet_id' in res) {
        return { subnetId: (0, util_1.base64DecodePrincipal)(res.subnet_id) };
    }
    return { subnetId: null };
}
function encodeGetCyclesBalanceRequest(req) {
    return {
        canister_id: (0, util_1.base64EncodePrincipal)(req.canisterId),
    };
}
function decodeGetCyclesBalanceResponse(res) {
    return {
        cycles: res.cycles,
    };
}
function encodeAddCyclesRequest(req) {
    return {
        canister_id: (0, util_1.base64EncodePrincipal)(req.canisterId),
        amount: req.amount,
    };
}
function decodeAddCyclesResponse(res) {
    return {
        cycles: res.cycles,
    };
}
function encodeUploadBlobRequest(req) {
    return req.blob;
}
function decodeUploadBlobResponse(res) {
    return {
        blobId: new Uint8Array((0, util_1.hexDecode)(res)),
    };
}
function encodeSetStableMemoryRequest(req) {
    return {
        canister_id: (0, util_1.base64EncodePrincipal)(req.canisterId),
        blob_id: (0, util_1.base64Encode)(req.blobId),
    };
}
function encodeGetStableMemoryRequest(req) {
    return {
        canister_id: (0, util_1.base64EncodePrincipal)(req.canisterId),
    };
}
function decodeGetStableMemoryResponse(res) {
    return {
        blob: (0, util_1.base64Decode)(res.blob),
    };
}
function encodeEffectivePrincipal(effectivePrincipal) {
    if ((0, util_1.isNil)(effectivePrincipal)) {
        return 'None';
    }
    if ('subnetId' in effectivePrincipal) {
        return {
            SubnetId: (0, util_1.base64EncodePrincipal)(effectivePrincipal.subnetId),
        };
    }
    else {
        return {
            CanisterId: (0, util_1.base64EncodePrincipal)(effectivePrincipal.canisterId),
        };
    }
}
function encodeCanisterCallRequest(req) {
    return {
        sender: (0, util_1.base64EncodePrincipal)(req.sender),
        canister_id: (0, util_1.base64EncodePrincipal)(req.canisterId),
        method: req.method,
        payload: (0, util_1.base64Encode)(req.payload),
        effective_principal: encodeEffectivePrincipal(req.effectivePrincipal),
    };
}
function decodeCanisterCallResponse(res) {
    if ('Err' in res) {
        throw new Error(res.Err.description);
    }
    if ('Reject' in res.Ok) {
        throw new Error(res.Ok.Reject);
    }
    return {
        body: (0, util_1.base64Decode)(res.Ok.Reply),
    };
}
//#endregion CanisterCall
//# sourceMappingURL=pocket-ic-client-types.js.map