@airgap/icp 0.13.11-beta.1 → 0.13.11-beta.11

package/v1/types/protocol.d.ts

@@ -0,0 +1,37 @@
+import { FeeDefaults, ProtocolNetwork, ProtocolUnitsMetadata } from '@airgap/module-kit';
+export declare type ICPUnits = 'ICP';
+export declare type CkBTCUnits = 'ckBTC';
+export interface ICPProtocolNetwork extends ProtocolNetwork {
+    ledgerCanisterId: string;
+    explorerUrl: string;
+}
+export interface ICPProtocolOptions {
+    network: ICPProtocolNetwork;
+}
+export interface ICRC1OfflineProtocolOptions<_Units extends string = string> {
+    ledgerCanisterId: string;
+    identifier: string;
+    name: string;
+    units: ProtocolUnitsMetadata<_Units>;
+    mainUnit: _Units;
+    feeDefaults: FeeDefaults<_Units>;
+}
+export interface ICRC1ProtocolNetwork extends ICPProtocolNetwork {
+}
+export interface ICRC1OnlineProtocolOptions<_ProtocolNetwork extends ICRC1ProtocolNetwork = ICRC1ProtocolNetwork, _Units extends string = string> {
+    network: _ProtocolNetwork;
+    identifier: string;
+    name?: string;
+    units?: ProtocolUnitsMetadata<_Units>;
+    mainUnit?: _Units;
+    feeDefaults?: FeeDefaults<_Units>;
+}
+export interface CkBTCProtocolNetwork extends ICRC1ProtocolNetwork {
+    indexerCanisterId: string;
+}
+export interface CkBTCOfflineProtocolOptions {
+    ledgerCanisterId: string;
+}
+export interface CkBTCOnlineProtocolOptions {
+    network: CkBTCProtocolNetwork;
+}

package/v1/types/protocol.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=protocol.js.map

package/v1/types/protocol.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../../src/v1/types/protocol.ts"],"names":[],"mappings":""}

package/v1/types/transaction.d.ts

@@ -0,0 +1,11 @@
+import { SignedTransaction, TransactionCursor, UnsignedTransaction } from '@airgap/module-kit';
+export interface ICPUnsignedTransaction extends UnsignedTransaction {
+    networkId: string;
+    transaction: string;
+}
+export interface ICPSignedTransaction extends SignedTransaction {
+    transaction: string;
+}
+export interface ICPTransactionCursor extends TransactionCursor {
+    next: string;
+}

package/v1/types/transaction.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=transaction.js.map

package/v1/types/transaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../src/v1/types/transaction.ts"],"names":[],"mappings":""}

package/v1/utils/account.d.ts

@@ -0,0 +1,24 @@
+import type { AccountIdentifier as AccountIdentifierCandid } from '../types/governance';
+import { Principal } from './principal';
+export declare class AccountIdentifier {
+    private readonly bytes;
+    private constructor();
+    static fromHex(hex: string): AccountIdentifier;
+    static fromPrincipal({ principal, subAccount }: {
+        principal: Principal;
+        subAccount?: SubAccount;
+    }): AccountIdentifier;
+    toHex(): string;
+    toUint8Array(): Uint8Array;
+    toNumbers(): number[];
+    toAccountIdentifierHash(): AccountIdentifierCandid;
+}
+export declare class SubAccount {
+    private readonly bytes;
+    private constructor();
+    static fromBytes(bytes: Uint8Array): SubAccount | Error;
+    static fromPrincipal(principal: Principal): SubAccount;
+    static fromID(id: number): SubAccount;
+    static ZERO: SubAccount;
+    toUint8Array(): Uint8Array;
+}

package/v1/utils/account.js

@@ -0,0 +1,112 @@
+"use strict";
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubAccount = exports.AccountIdentifier = void 0;
+var js_sha256_1 = require("js-sha256");
+var buffer_1 = require("./buffer");
+var convert_1 = require("./convert");
+var AccountIdentifier = /** @class */ (function () {
+    function AccountIdentifier(bytes) {
+        this.bytes = bytes;
+    }
+    AccountIdentifier.fromHex = function (hex) {
+        return new AccountIdentifier(Uint8Array.from(Buffer.from(hex, 'hex')));
+    };
+    AccountIdentifier.fromPrincipal = function (_a) {
+        var principal = _a.principal, _b = _a.subAccount, subAccount = _b === void 0 ? SubAccount.ZERO : _b;
+        // Hash (sha224) the principal, the subAccount and some padding
+        var padding = (0, convert_1.asciiStringToByteArray)('\x0Aaccount-id');
+        var shaObj = js_sha256_1.sha224.create();
+        shaObj.update(__spreadArray(__spreadArray(__spreadArray([], __read(padding), false), __read(principal.toUint8Array()), false), __read(subAccount.toUint8Array()), false));
+        var hash = new Uint8Array(shaObj.array());
+        // Prepend the checksum of the hash and convert to a hex string
+        var checksum = (0, convert_1.calculateCrc32)(hash);
+        var bytes = new Uint8Array(__spreadArray(__spreadArray([], __read(checksum), false), __read(hash), false));
+        return new AccountIdentifier(bytes);
+    };
+    //   /**
+    //    * @returns An AccountIdentifier protobuf object.
+    //    */
+    //   public toProto(): AccountIdentifierPb {
+    //     const accountIdentifier = new AccountIdentifierPb()
+    //     accountIdentifier.setHash(this.bytes)
+    //     return accountIdentifier
+    //   }
+    AccountIdentifier.prototype.toHex = function () {
+        return (0, buffer_1.toHexString)(this.bytes);
+    };
+    AccountIdentifier.prototype.toUint8Array = function () {
+        return this.bytes;
+    };
+    AccountIdentifier.prototype.toNumbers = function () {
+        return Array.from(this.bytes);
+    };
+    AccountIdentifier.prototype.toAccountIdentifierHash = function () {
+        return {
+            hash: this.toUint8Array()
+        };
+    };
+    return AccountIdentifier;
+}());
+exports.AccountIdentifier = AccountIdentifier;
+var SubAccount = /** @class */ (function () {
+    function SubAccount(bytes) {
+        this.bytes = bytes;
+    }
+    SubAccount.fromBytes = function (bytes) {
+        if (bytes.length != 32) {
+            return Error('Subaccount length must be 32-bytes');
+        }
+        return new SubAccount(bytes);
+    };
+    SubAccount.fromPrincipal = function (principal) {
+        var bytes = new Uint8Array(32).fill(0);
+        var principalBytes = principal.toUint8Array();
+        bytes[0] = principalBytes.length;
+        for (var i = 0; i < principalBytes.length; i++) {
+            bytes[1 + i] = principalBytes[i];
+        }
+        return new SubAccount(bytes);
+    };
+    SubAccount.fromID = function (id) {
+        if (id < 0 || id > 255) {
+            throw 'Subaccount ID must be >= 0 and <= 255';
+        }
+        var bytes = new Uint8Array(32).fill(0);
+        bytes[31] = id;
+        return new SubAccount(bytes);
+    };
+    SubAccount.prototype.toUint8Array = function () {
+        return this.bytes;
+    };
+    var _a;
+    _a = SubAccount;
+    SubAccount.ZERO = _a.fromID(0);
+    return SubAccount;
+}());
+exports.SubAccount = SubAccount;
+//# sourceMappingURL=account.js.map

package/v1/utils/account.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.js","sourceRoot":"","sources":["../../../src/v1/utils/account.ts"],"names":[],"mappings":"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"}

package/v1/utils/actor.d.ts

@@ -0,0 +1,246 @@
+import { RequestId } from './auth';
+import { CreateCertificateOptions } from './certificate';
+import { Agent, HttpAgent, QueryResponseRejected, SubmitResponse } from './http';
+import { Principal } from './principal';
+import * as IDL from './idl';
+import { PollStrategyFactory } from './polling';
+import { AgentError } from './errors';
+export interface GlobalInternetComputer {
+    ic: {
+        agent: Agent;
+        HttpAgent: typeof HttpAgent;
+        IDL: typeof IDL;
+        /**
+         * Simple advertisement of features in whoever is managing this `globalThis.ic`.
+         * Use Case
+         * * Scripts that know they need an ic feature can detect using this and, if not present
+         *   (e.g. old bootstrap version), they can dynamically include their own and continue
+         *   operating (e.g. polyfill).
+         *   This is useful when adding features to bootstrap. You can still deploy your canister to
+         *   an ic with old bootstrap, then just dynamically reload your own new-version bootstrap if
+         *   needed.
+         */
+        features?: {
+            /** This is falsy if authn isn't supported at all */
+            authentication?: boolean;
+        };
+        /**
+         * The Actor for the canister being used for the frontend. Normally should correspond to the
+         * canister represented by the canister id in the URL.
+         *
+         * It does not have any functions configured.
+         *
+         * If a canister ID could not be found, no actor were created and this is undefined.
+         */
+        canister: ActorSubclass | undefined;
+    };
+}
+export declare function getDefaultAgent(): Agent;
+/**
+ * This file is generated from the candid for asset management.
+ */
+export declare type canister_id = Principal;
+export interface canister_settings {
+    controllers: [] | [Array<Principal>];
+    freezing_threshold: [] | [bigint];
+    memory_allocation: [] | [bigint];
+    compute_allocation: [] | [bigint];
+}
+export interface definite_canister_settings {
+    controllers: Array<Principal>;
+    freezing_threshold: bigint;
+    memory_allocation: bigint;
+    compute_allocation: bigint;
+}
+export declare type user_id = Principal;
+export declare type wasm_module = Array<number>;
+export default interface _SERVICE {
+    canister_status: (arg_0: {
+        canister_id: canister_id;
+    }) => Promise<{
+        status: {
+            stopped: null;
+        } | {
+            stopping: null;
+        } | {
+            running: null;
+        };
+        memory_size: bigint;
+        cycles: bigint;
+        settings: definite_canister_settings;
+        module_hash: [] | [Array<number>];
+    }>;
+    create_canister: (arg_0: {
+        settings: [] | [canister_settings];
+    }) => Promise<{
+        canister_id: canister_id;
+    }>;
+    delete_canister: (arg_0: {
+        canister_id: canister_id;
+    }) => Promise<undefined>;
+    deposit_cycles: (arg_0: {
+        canister_id: canister_id;
+    }) => Promise<undefined>;
+    install_code: (arg_0: {
+        arg: Array<number>;
+        wasm_module: wasm_module;
+        mode: {
+            reinstall: null;
+        } | {
+            upgrade: null;
+        } | {
+            install: null;
+        };
+        canister_id: canister_id;
+    }) => Promise<undefined>;
+    provisional_create_canister_with_cycles: (arg_0: {
+        settings: [] | [canister_settings];
+        amount: [] | [bigint];
+    }) => Promise<{
+        canister_id: canister_id;
+    }>;
+    provisional_top_up_canister: (arg_0: {
+        canister_id: canister_id;
+        amount: bigint;
+    }) => Promise<undefined>;
+    raw_rand: () => Promise<Array<number>>;
+    start_canister: (arg_0: {
+        canister_id: canister_id;
+    }) => Promise<undefined>;
+    stop_canister: (arg_0: {
+        canister_id: canister_id;
+    }) => Promise<undefined>;
+    uninstall_code: (arg_0: {
+        canister_id: canister_id;
+    }) => Promise<undefined>;
+    update_settings: (arg_0: {
+        canister_id: Principal;
+        settings: canister_settings;
+    }) => Promise<undefined>;
+}
+export declare type ManagementCanisterRecord = _SERVICE;
+export declare function getManagementCanister(config: CallConfig): ActorSubclass<ManagementCanisterRecord>;
+export declare class ActorCallError extends AgentError {
+    readonly canisterId: Principal;
+    readonly methodName: string;
+    readonly type: 'query' | 'update';
+    readonly props: Record<string, string>;
+    constructor(canisterId: Principal, methodName: string, type: 'query' | 'update', props: Record<string, string>);
+}
+export declare class QueryCallRejectedError extends ActorCallError {
+    readonly result: QueryResponseRejected;
+    constructor(canisterId: Principal, methodName: string, result: QueryResponseRejected);
+}
+export declare class UpdateCallRejectedError extends ActorCallError {
+    readonly requestId: RequestId;
+    readonly response: SubmitResponse['response'];
+    constructor(canisterId: Principal, methodName: string, requestId: RequestId, response: SubmitResponse['response']);
+}
+/**
+ * Configuration to make calls to the Replica.
+ */
+export interface CallConfig {
+    /**
+     * An agent to use in this call, otherwise the actor or call will try to discover the
+     * agent to use.
+     */
+    agent?: Agent;
+    /**
+     * A polling strategy factory that dictates how much and often we should poll the
+     * read_state endpoint to get the result of an update call.
+     */
+    pollingStrategyFactory?: PollStrategyFactory;
+    /**
+     * The canister ID of this Actor.
+     */
+    canisterId?: string | Principal;
+    /**
+     * The effective canister ID. This should almost always be ignored.
+     */
+    effectiveCanisterId?: Principal;
+}
+/**
+ * Configuration that can be passed to customize the Actor behaviour.
+ */
+export interface ActorConfig extends CallConfig {
+    /**
+     * The Canister ID of this Actor. This is required for an Actor.
+     */
+    canisterId: string | Principal;
+    /**
+     * An override function for update calls' CallConfig. This will be called on every calls.
+     */
+    callTransform?(methodName: string, args: unknown[], callConfig: CallConfig): Partial<CallConfig> | void;
+    /**
+     * An override function for query calls' CallConfig. This will be called on every query.
+     */
+    queryTransform?(methodName: string, args: unknown[], callConfig: CallConfig): Partial<CallConfig> | void;
+    /**
+     * Polyfill for BLS Certificate verification in case wasm is not supported
+     */
+    blsVerify?: CreateCertificateOptions['blsVerify'];
+}
+/**
+ * A subclass of an actor. Actor class itself is meant to be a based class.
+ */
+export declare type ActorSubclass<T = Record<string, ActorMethod>> = Actor & T;
+/**
+ * An actor method type, defined for each methods of the actor service.
+ */
+export interface ActorMethod<Args extends unknown[] = unknown[], Ret extends unknown = unknown> {
+    (...args: Args): Promise<Ret>;
+    withOptions(options: CallConfig): (...args: Args) => Promise<Ret>;
+}
+/**
+ * The mode used when installing a canister.
+ */
+export declare enum CanisterInstallMode {
+    Install = "install",
+    Reinstall = "reinstall",
+    Upgrade = "upgrade"
+}
+/**
+ * Internal metadata for actors. It's an enhanced version of ActorConfig with
+ * some fields marked as required (as they are defaulted) and canisterId as
+ * a Principal type.
+ */
+interface ActorMetadata {
+    service: IDL.ServiceClass;
+    agent?: Agent;
+    config: ActorConfig;
+}
+declare const metadataSymbol: unique symbol;
+/**
+ * An actor base class. An actor is an object containing only functions that will
+ * return a promise. These functions are derived from the IDL definition.
+ */
+export declare class Actor {
+    /**
+     * Get the Agent class this Actor would call, or undefined if the Actor would use
+     * the default agent (global.ic.agent).
+     * @param actor The actor to get the agent of.
+     */
+    static agentOf(actor: Actor): Agent | undefined;
+    /**
+     * Get the interface of an actor, in the form of an instance of a Service.
+     * @param actor The actor to get the interface of.
+     */
+    static interfaceOf(actor: Actor): IDL.ServiceClass;
+    static canisterIdOf(actor: Actor): Principal;
+    static install(fields: {
+        module: ArrayBuffer;
+        mode?: CanisterInstallMode;
+        arg?: ArrayBuffer;
+    }, config: ActorConfig): Promise<void>;
+    static createCanister(config?: CallConfig): Promise<Principal>;
+    static createAndInstallCanister(interfaceFactory: IDL.InterfaceFactory, fields: {
+        module: ArrayBuffer;
+        arg?: ArrayBuffer;
+    }, config?: CallConfig): Promise<ActorSubclass>;
+    static createActorClass(interfaceFactory: IDL.InterfaceFactory): ActorConstructor;
+    static createActor<T = Record<string, ActorMethod>>(interfaceFactory: IDL.InterfaceFactory, configuration: ActorConfig): ActorSubclass<T>;
+    private [metadataSymbol];
+    protected constructor(metadata: ActorMetadata);
+}
+export declare type ActorConstructor = new (config: ActorConfig) => ActorSubclass;
+export {};