@dfinity/pic 0.12.0-b0

package/dist/pocket-ic-actor.d.ts

@@ -0,0 +1,85 @@
+import { IDL } from '@dfinity/candid';
+import { Principal } from '@dfinity/principal';
+import { Identity } from '@dfinity/agent';
+import { PocketIcClient } from './pocket-ic-client';
+/**
+ * Typesafe method of a canister.
+ *
+ * @category Types
+ */
+export interface ActorMethod<Args extends any[] = any[], Ret = any> {
+    (...args: Args): Promise<Ret>;
+}
+/**
+ * Candid interface of a canister.
+ *
+ * @category Types
+ */
+export type ActorInterface<T = object> = {
+    [K in keyof T]: ActorMethod;
+};
+/**
+ * A typesafe class that implements the Candid interface of a canister.
+ * This is acquired by calling {@link PocketIc.setupCanister | setupCanister}
+ * or {@link PocketIc.createActor | createActor}.
+ *
+ * @category API
+ * @typeparam T The type of the {@link Actor}. Must implement {@link ActorInterface}.
+ * @interface
+ */
+export type Actor<T extends ActorInterface<T> = ActorInterface> = T & {
+    /**
+     * @ignore
+     */
+    new (): Actor<T>;
+    /**
+     * Set a Principal to be used as sender for all calls to the canister.
+     *
+     * @param principal The Principal to set.
+     *
+     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
+     *
+     * @example
+     * ```ts
+     * import { PocketIc } from '@dfinity/pic';
+     * import { Principal } from '@dfinity/principal';
+     * import { _SERVICE, idlFactory } from '../declarations';
+     *
+     * const wasmPath = resolve('..', '..', 'canister.wasm');
+     *
+     * const pic = await PocketIc.create();
+     * const fixture = await pic.setupCanister<_SERVICE>(idlFactory, wasmPath);
+     * const { actor } = fixture;
+     *
+     * actor.setPrincipal(Principal.anonymous());
+     * ```
+     */
+    setPrincipal(principal: Principal): void;
+    /**
+     * Set a Principal to be used as sender for all calls to the canister.
+     * This is a convenience method over {@link setPrincipal} that accepts an
+     * Identity and internally extracts the Principal.
+     *
+     * @param identity The identity to set.
+     *
+     * @see [Identity](https://agent-js.icp.xyz/agent/interfaces/Identity.html)
+     * @see [Principal](https://agent-js.icp.xyz/principal/classes/Principal.html)
+     *
+     * @example
+     * ```ts
+     * import { PocketIc } from '@dfinity/pic';
+     * import { AnonymousIdentity } from '@dfinity/agent';
+     * import { _SERVICE, idlFactory } from '../declarations';
+     *
+     * const wasmPath = resolve('..', '..', 'canister.wasm');
+     *
+     * const pic = await PocketIc.create();
+     * const fixture = await pic.setupCanister<_SERVICE>(idlFactory, wasmPath);
+     * const { actor } = fixture;
+     *
+     * actor.setIdentity(new AnonymousIdentity());
+     * ```
+     */
+    setIdentity(identity: Identity): void;
+};
+export declare function createActorClass<T extends ActorInterface<T> = ActorInterface>(interfaceFactory: IDL.InterfaceFactory, canisterId: Principal, pocketIcClient: PocketIcClient): Actor<T>;

package/dist/pocket-ic-actor.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createActorClass = createActorClass;
+const candid_1 = require("@dfinity/candid");
+const principal_1 = require("@dfinity/principal");
+const util_1 = require("./util");
+function createActorClass(interfaceFactory, canisterId, pocketIcClient) {
+    const service = interfaceFactory({ IDL: candid_1.IDL });
+    let sender = null;
+    function createActorMethod(methodName, func) {
+        if (func.annotations.includes('query') ||
+            func.annotations.includes('composite_query')) {
+            return createQueryMethod(methodName, func);
+        }
+        return createCallMethod(methodName, func);
+    }
+    function getSender() {
+        return sender ?? principal_1.Principal.anonymous();
+    }
+    function createQueryMethod(method, func) {
+        return async function (...args) {
+            const arg = candid_1.IDL.encode(func.argTypes, args);
+            const sender = getSender();
+            const res = await pocketIcClient.queryCall({
+                canisterId,
+                sender,
+                method,
+                payload: new Uint8Array(arg),
+            });
+            return (0, util_1.decodeCandid)(func.retTypes, res.body);
+        };
+    }
+    function createCallMethod(method, func) {
+        return async function (...args) {
+            const arg = candid_1.IDL.encode(func.argTypes, args);
+            const sender = getSender();
+            const res = await pocketIcClient.updateCall({
+                canisterId,
+                sender,
+                method,
+                payload: new Uint8Array(arg),
+            });
+            return (0, util_1.decodeCandid)(func.retTypes, res.body);
+        };
+    }
+    function Actor() { }
+    Actor.prototype.setPrincipal = function (newSender) {
+        sender = newSender;
+    };
+    Actor.prototype.setIdentity = function (identity) {
+        sender = identity.getPrincipal();
+    };
+    service._fields.forEach(([methodName, func]) => {
+        Actor.prototype[methodName] = createActorMethod(methodName, func);
+    });
+    return Actor;
+}
+//# sourceMappingURL=pocket-ic-actor.js.map

package/dist/pocket-ic-actor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pocket-ic-actor.js","sourceRoot":"","sources":["../src/pocket-ic-actor.ts"],"names":[],"mappings":";;AAyFA,4CAyEC;AAlKD,4CAAsC;AACtC,kDAA+C;AAG/C,iCAAsC;AAqFtC,SAAgB,gBAAgB,CAC9B,gBAAsC,EACtC,UAAqB,EACrB,cAA8B;IAE9B,MAAM,OAAO,GAAG,gBAAgB,CAAC,EAAE,GAAG,EAAH,YAAG,EAAE,CAAC,CAAC;IAC1C,IAAI,MAAM,GAAqB,IAAI,CAAC;IAEpC,SAAS,iBAAiB,CACxB,UAAkB,EAClB,IAAmB;QAEnB,IACE,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,OAAO,CAAC;YAClC,IAAI,CAAC,WAAW,CAAC,QAAQ,CAAC,iBAAiB,CAAC,EAC5C,CAAC;YACD,OAAO,iBAAiB,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;QAC7C,CAAC;QAED,OAAO,gBAAgB,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;IAC5C,CAAC;IAED,SAAS,SAAS;QAChB,OAAO,MAAM,IAAI,qBAAS,CAAC,SAAS,EAAE,CAAC;IACzC,CAAC;IAED,SAAS,iBAAiB,CAAC,MAAc,EAAE,IAAmB;QAC5D,OAAO,KAAK,WAAW,GAAG,IAAI;YAC5B,MAAM,GAAG,GAAG,YAAG,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;YAC5C,MAAM,MAAM,GAAG,SAAS,EAAE,CAAC;YAE3B,MAAM,GAAG,GAAG,MAAM,cAAc,CAAC,SAAS,CAAC;gBACzC,UAAU;gBACV,MAAM;gBACN,MAAM;gBACN,OAAO,EAAE,IAAI,UAAU,CAAC,GAAG,CAAC;aAC7B,CAAC,CAAC;YAEH,OAAO,IAAA,mBAAY,EAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;QAC/C,CAAC,CAAC;IACJ,CAAC;IAED,SAAS,gBAAgB,CAAC,MAAc,EAAE,IAAmB;QAC3D,OAAO,KAAK,WAAW,GAAG,IAAI;YAC5B,MAAM,GAAG,GAAG,YAAG,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;YAC5C,MAAM,MAAM,GAAG,SAAS,EAAE,CAAC;YAE3B,MAAM,GAAG,GAAG,MAAM,cAAc,CAAC,UAAU,CAAC;gBAC1C,UAAU;gBACV,MAAM;gBACN,MAAM;gBACN,OAAO,EAAE,IAAI,UAAU,CAAC,GAAG,CAAC;aAC7B,CAAC,CAAC;YAEH,OAAO,IAAA,mBAAY,EAAC,IAAI,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,CAAC,CAAC;QAC/C,CAAC,CAAC;IACJ,CAAC;IAED,SAAS,KAAK,KAAI,CAAC;IAEnB,KAAK,CAAC,SAAS,CAAC,YAAY,GAAG,UAAU,SAAoB;QAC3D,MAAM,GAAG,SAAS,CAAC;IACrB,CAAC,CAAC;IAEF,KAAK,CAAC,SAAS,CAAC,WAAW,GAAG,UAAU,QAAkB;QACxD,MAAM,GAAG,QAAQ,CAAC,YAAY,EAAE,CAAC;IACnC,CAAC,CAAC;IAEF,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,EAAE,IAAI,CAAC,EAAE,EAAE;QAC7C,KAAK,CAAC,SAAS,CAAC,UAAU,CAAC,GAAG,iBAAiB,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;IACpE,CAAC,CAAC,CAAC;IAEH,OAAO,KAA0B,CAAC;AACpC,CAAC"}

package/dist/pocket-ic-client-types.d.ts

@@ -0,0 +1,372 @@
+import { Principal } from '@dfinity/principal';
+export interface CreateInstanceRequest {
+    nns?: NnsSubnetConfig;
+    sns?: SnsSubnetConfig;
+    ii?: IiSubnetConfig;
+    fiduciary?: FiduciarySubnetConfig;
+    bitcoin?: BitcoinSubnetConfig;
+    system?: SystemSubnetConfig[];
+    application?: ApplicationSubnetConfig[];
+    verifiedApplication?: VerifiedApplicationSubnetConfig[];
+    processingTimeoutMs?: number;
+    nonmainnetFeatures?: boolean;
+}
+export interface SubnetConfig<T extends NewSubnetStateConfig | FromPathSubnetStateConfig = NewSubnetStateConfig | FromPathSubnetStateConfig> {
+    enableDeterministicTimeSlicing?: boolean;
+    enableBenchmarkingInstructionLimits?: boolean;
+    state: T;
+}
+export type NnsSubnetConfig = SubnetConfig<NnsSubnetStateConfig>;
+export type NnsSubnetStateConfig = NewSubnetStateConfig | FromPathSubnetStateConfig;
+export type SnsSubnetConfig = SubnetConfig<SnsSubnetStateConfig>;
+export type SnsSubnetStateConfig = NewSubnetStateConfig;
+export type IiSubnetConfig = SubnetConfig<IiSubnetStateConfig>;
+export type IiSubnetStateConfig = NewSubnetStateConfig;
+export type FiduciarySubnetConfig = SubnetConfig<FiduciarySubnetStateConfig>;
+export type FiduciarySubnetStateConfig = NewSubnetStateConfig;
+export type BitcoinSubnetConfig = SubnetConfig<BitcoinSubnetStateConfig>;
+export type BitcoinSubnetStateConfig = NewSubnetStateConfig;
+export type SystemSubnetConfig = SubnetConfig<SystemSubnetStateConfig>;
+export type SystemSubnetStateConfig = NewSubnetStateConfig;
+export type ApplicationSubnetConfig = SubnetConfig<ApplicationSubnetStateConfig>;
+export type ApplicationSubnetStateConfig = NewSubnetStateConfig;
+export type VerifiedApplicationSubnetConfig = SubnetConfig<VerifiedApplicationSubnetStateConfig>;
+export type VerifiedApplicationSubnetStateConfig = NewSubnetStateConfig;
+export interface NewSubnetStateConfig {
+    type: SubnetStateType.New;
+}
+export interface FromPathSubnetStateConfig {
+    type: SubnetStateType.FromPath;
+    path: string;
+    subnetId: Principal;
+}
+export declare enum SubnetStateType {
+    New = "new",
+    FromPath = "fromPath"
+}
+export interface EncodedCreateInstanceRequest {
+    subnet_config_set: EncodedCreateInstanceSubnetConfig;
+    nonmainnet_features: boolean;
+}
+export interface EncodedCreateInstanceSubnetConfig {
+    nns?: EncodedSubnetConfig;
+    sns?: EncodedSubnetConfig;
+    ii?: EncodedSubnetConfig;
+    fiduciary?: EncodedSubnetConfig;
+    bitcoin?: EncodedSubnetConfig;
+    system: EncodedSubnetConfig[];
+    application: EncodedSubnetConfig[];
+    verified_application: EncodedSubnetConfig[];
+}
+export interface EncodedSubnetConfig {
+    dts_flag: 'Enabled' | 'Disabled';
+    instruction_config: 'Production' | 'Benchmarking';
+    state_config: 'New' | {
+        FromPath: [string, {
+            subnet_id: string;
+        }];
+    };
+}
+export declare function encodeCreateInstanceRequest(req?: CreateInstanceRequest): EncodedCreateInstanceRequest;
+export interface GetPubKeyRequest {
+    subnetId: Principal;
+}
+export interface EncodedGetPubKeyRequest {
+    subnet_id: string;
+}
+export declare function encodeGetPubKeyRequest(req: GetPubKeyRequest): EncodedGetPubKeyRequest;
+export type InstanceTopology = Record<string, SubnetTopology>;
+export interface SubnetTopology {
+    id: Principal;
+    type: SubnetType;
+    size: number;
+    canisterRanges: Array<{
+        start: Principal;
+        end: Principal;
+    }>;
+}
+export declare enum SubnetType {
+    Application = "Application",
+    Bitcoin = "Bitcoin",
+    Fiduciary = "Fiduciary",
+    InternetIdentity = "II",
+    NNS = "NNS",
+    SNS = "SNS",
+    System = "System"
+}
+export interface EncodedGetTopologyResponse {
+    subnet_configs: Record<string, EncodedSubnetTopology>;
+    default_effective_canister_id: {
+        canister_id: string;
+    };
+}
+export interface EncodedSubnetTopology {
+    subnet_kind: EncodedSubnetKind;
+    size: number;
+    canister_ranges: Array<{
+        start: {
+            canister_id: string;
+        };
+        end: {
+            canister_id: string;
+        };
+    }>;
+}
+export type EncodedSubnetKind = 'Application' | 'Bitcoin' | 'Fiduciary' | 'II' | 'NNS' | 'SNS' | 'System';
+export declare function decodeGetTopologyResponse(encoded: EncodedGetTopologyResponse): InstanceTopology;
+export declare function decodeSubnetTopology(subnetId: string, encoded: EncodedSubnetTopology): SubnetTopology;
+export declare function decodeSubnetKind(kind: EncodedSubnetKind): SubnetType;
+export interface CreateInstanceSuccessResponse {
+    Created: {
+        instance_id: number;
+        topology: EncodedGetTopologyResponse;
+    };
+}
+export interface CreateInstanceErrorResponse {
+    Error: {
+        message: string;
+    };
+}
+export type CreateInstanceResponse = CreateInstanceSuccessResponse | CreateInstanceErrorResponse;
+export interface GetControllersRequest {
+    canisterId: Principal;
+}
+export interface EncodedGetControllersRequest {
+    canister_id: string;
+}
+export declare function encodeGetControllersRequest(req: GetControllersRequest): EncodedGetControllersRequest;
+export type GetControllersResponse = Principal[];
+export type EncodedGetControllersResponse = {
+    principal_id: string;
+}[];
+export declare function decodeGetControllersResponse(res: EncodedGetControllersResponse): GetControllersResponse;
+export interface GetTimeResponse {
+    millisSinceEpoch: number;
+}
+export interface EncodedGetTimeResponse {
+    nanos_since_epoch: number;
+}
+export declare function decodeGetTimeResponse(res: EncodedGetTimeResponse): GetTimeResponse;
+export interface SetTimeRequest {
+    millisSinceEpoch: number;
+}
+export interface EncodedSetTimeRequest {
+    nanos_since_epoch: number;
+}
+export declare function encodeSetTimeRequest(req: SetTimeRequest): EncodedSetTimeRequest;
+export interface GetSubnetIdRequest {
+    canisterId: Principal;
+}
+export interface EncodedGetSubnetIdRequest {
+    canister_id: string;
+}
+export declare function encodeGetSubnetIdRequest(req: GetSubnetIdRequest): EncodedGetSubnetIdRequest;
+export type GetSubnetIdResponse = {
+    subnetId: Principal | null;
+};
+export type EncodedGetSubnetIdResponse = {
+    subnet_id: string;
+} | {};
+export declare function decodeGetSubnetIdResponse(res: EncodedGetSubnetIdResponse): GetSubnetIdResponse;
+export interface GetCyclesBalanceRequest {
+    canisterId: Principal;
+}
+export interface EncodedGetCyclesBalanceRequest {
+    canister_id: string;
+}
+export declare function encodeGetCyclesBalanceRequest(req: GetCyclesBalanceRequest): EncodedGetCyclesBalanceRequest;
+export interface EncodedGetCyclesBalanceResponse {
+    cycles: number;
+}
+export interface GetCyclesBalanceResponse {
+    cycles: number;
+}
+export declare function decodeGetCyclesBalanceResponse(res: EncodedGetCyclesBalanceResponse): GetCyclesBalanceResponse;
+export interface AddCyclesRequest {
+    canisterId: Principal;
+    amount: number;
+}
+export interface EncodedAddCyclesRequest {
+    canister_id: string;
+    amount: number;
+}
+export declare function encodeAddCyclesRequest(req: AddCyclesRequest): EncodedAddCyclesRequest;
+export interface AddCyclesResponse {
+    cycles: number;
+}
+export interface EncodedAddCyclesResponse {
+    cycles: number;
+}
+export declare function decodeAddCyclesResponse(res: EncodedAddCyclesResponse): AddCyclesResponse;
+export interface UploadBlobRequest {
+    blob: Uint8Array;
+}
+export type EncodedUploadBlobRequest = Uint8Array;
+export declare function encodeUploadBlobRequest(req: UploadBlobRequest): EncodedUploadBlobRequest;
+export interface UploadBlobResponse {
+    blobId: Uint8Array;
+}
+export type EncodedUploadBlobResponse = string;
+export declare function decodeUploadBlobResponse(res: EncodedUploadBlobResponse): UploadBlobResponse;
+export interface SetStableMemoryRequest {
+    canisterId: Principal;
+    blobId: Uint8Array;
+}
+export interface EncodedSetStableMemoryRequest {
+    canister_id: string;
+    blob_id: string;
+}
+export declare function encodeSetStableMemoryRequest(req: SetStableMemoryRequest): EncodedSetStableMemoryRequest;
+export interface GetStableMemoryRequest {
+    canisterId: Principal;
+}
+export interface EncodedGetStableMemoryRequest {
+    canister_id: string;
+}
+export declare function encodeGetStableMemoryRequest(req: GetStableMemoryRequest): EncodedGetStableMemoryRequest;
+export interface GetStableMemoryResponse {
+    blob: Uint8Array;
+}
+export interface EncodedGetStableMemoryResponse {
+    blob: string;
+}
+export declare function decodeGetStableMemoryResponse(res: EncodedGetStableMemoryResponse): GetStableMemoryResponse;
+export interface GetPendingHttpsOutcallsResponse {
+    subnetId: Principal;
+    requestId: number;
+    httpMethod: CanisterHttpMethod;
+    url: string;
+    headers: CanisterHttpHeader[];
+    body: Uint8Array;
+    maxResponseBytes?: number;
+}
+export declare enum CanisterHttpMethod {
+    GET = "GET",
+    POST = "POST",
+    HEAD = "HEAD"
+}
+export type CanisterHttpHeader = [string, string];
+export interface EncodedGetPendingHttpsOutcallsResponse {
+    subnet_id: {
+        subnet_id: string;
+    };
+    request_id: number;
+    http_method: EncodedCanisterHttpMethod;
+    url: string;
+    headers: EncodedCanisterHttpHeader[];
+    body: string;
+    max_response_bytes?: number;
+}
+export declare enum EncodedCanisterHttpMethod {
+    GET = "GET",
+    POST = "POST",
+    HEAD = "HEAD"
+}
+export interface EncodedCanisterHttpHeader {
+    name: string;
+    value: string;
+}
+export declare function decodeGetPendingHttpsOutcallsResponse(res: EncodedGetPendingHttpsOutcallsResponse[]): GetPendingHttpsOutcallsResponse[];
+export interface MockPendingHttpsOutcallRequest {
+    subnetId: Principal;
+    requestId: number;
+    response: HttpsOutcallResponseMock;
+    additionalResponses: HttpsOutcallResponseMock[];
+}
+export type HttpsOutcallResponseMock = HttpsOutcallSuccessResponseMock | HttpsOutcallRejectResponseMock;
+export interface HttpsOutcallSuccessResponseMock {
+    type: 'success';
+    statusCode: number;
+    headers: CanisterHttpHeader[];
+    body: Uint8Array;
+}
+export interface HttpsOutcallRejectResponseMock {
+    type: 'reject';
+    statusCode: number;
+    message: string;
+}
+export interface EncodedMockPendingHttpsOutcallRequest {
+    subnet_id: {
+        subnet_id: string;
+    };
+    request_id: number;
+    response: EncodedHttpsOutcallResponseMock;
+    additional_responses: EncodedHttpsOutcallResponseMock[];
+}
+export type EncodedHttpsOutcallResponseMock = EncodedHttpsOutcallSuccessResponseMock | EncodedHttpsOutcallRejectResponseMock;
+export interface EncodedHttpsOutcallSuccessResponseMock {
+    CanisterHttpReply: {
+        status: number;
+        headers: EncodedCanisterHttpHeader[];
+        body: string;
+    };
+}
+export interface EncodedHttpsOutcallRejectResponseMock {
+    CanisterHttpReject: {
+        reject_code: number;
+        message: string;
+    };
+}
+export declare function encodeMockPendingHttpsOutcallRequest(req: MockPendingHttpsOutcallRequest): EncodedMockPendingHttpsOutcallRequest;
+export interface CanisterCallRequest {
+    sender: Principal;
+    canisterId: Principal;
+    method: string;
+    payload: Uint8Array;
+    effectivePrincipal?: EffectivePrincipal;
+}
+export type EffectivePrincipal = {
+    subnetId: Principal;
+} | {
+    canisterId: Principal;
+};
+export interface EncodedCanisterCallRequest {
+    sender: string;
+    canister_id: string;
+    method: string;
+    payload: string;
+    effective_principal?: EncodedEffectivePrincipal;
+}
+export type EncodedEffectivePrincipal = {
+    SubnetId: string;
+} | {
+    CanisterId: string;
+} | 'None';
+export declare function encodeEffectivePrincipal(effectivePrincipal?: EffectivePrincipal | null): EncodedEffectivePrincipal;
+export declare function decodeEffectivePrincipal(effectivePrincipal: EncodedEffectivePrincipal): EffectivePrincipal | null;
+export declare function encodeCanisterCallRequest(req: CanisterCallRequest): EncodedCanisterCallRequest;
+export type EncodedCanisterCallResult<T> = {
+    Ok: T;
+} | {
+    Err: EncodedCanisterCallRejectResponse;
+};
+export interface EncodedCanisterCallRejectResponse {
+    reject_code: number;
+    reject_message: string;
+    error_code: number;
+    certified: boolean;
+}
+export interface CanisterCallResponse {
+    body: Uint8Array;
+}
+export type EncodedCanisterCallResponse = EncodedCanisterCallResult<string>;
+export declare function decodeCanisterCallResponse(res: EncodedCanisterCallResponse): CanisterCallResponse;
+export type SubmitCanisterCallRequest = CanisterCallRequest;
+export type EncodedSubmitCanisterCallRequest = EncodedCanisterCallRequest;
+export declare function encodeSubmitCanisterCallRequest(req: SubmitCanisterCallRequest): EncodedSubmitCanisterCallRequest;
+export interface SubmitCanisterCallResponse {
+    effectivePrincipal: EffectivePrincipal | null;
+    messageId: Uint8Array;
+}
+export interface EncodedCanisterCallId {
+    effective_principal: EncodedEffectivePrincipal;
+    message_id: Uint8Array;
+}
+export type EncodedSubmitCanisterCallResponse = EncodedCanisterCallResult<EncodedCanisterCallId>;
+export declare function decodeSubmitCanisterCallResponse(res: EncodedSubmitCanisterCallResponse): SubmitCanisterCallResponse;
+export type AwaitCanisterCallRequest = SubmitCanisterCallResponse;
+export type EncodedAwaitCanisterCallRequest = EncodedCanisterCallId;
+export declare function encodeAwaitCanisterCallRequest(req: AwaitCanisterCallRequest): EncodedAwaitCanisterCallRequest;
+export type AwaitCanisterCallResponse = CanisterCallResponse;
+export type EncodedAwaitCanisterCallResponse = EncodedCanisterCallResponse;
+export declare function decodeAwaitCanisterCallResponse(res: EncodedAwaitCanisterCallResponse): AwaitCanisterCallResponse;