@ohos-ports/azle 0.33.0-beta.0

package/src/experimental/lib/http_client/fetch_ic/call.ts

@@ -0,0 +1,257 @@
+// TODO CONNECT and TRACE are not currently supported as we believe ICP does not support them in any way
+
+import { createActor } from './actor';
+
+export type CallResult = CallHttpRequestResult | CallHttpRequestUpdateResult;
+
+export type CallHttpRequestResult = Awaited<
+    ReturnType<Awaited<ReturnType<typeof createActor>>['http_request']>
+>;
+
+export type CallHttpRequestUpdateResult = Awaited<
+    ReturnType<Awaited<ReturnType<typeof createActor>>['http_request_update']>
+>;
+
+export async function call(
+    input: RequestInfo | URL,
+    init: RequestInit | undefined,
+    actor: Awaited<ReturnType<typeof createActor>>
+): Promise<CallResult> {
+    const urlString = getUrlString(input);
+    const url = new URL(urlString);
+    const urlAndQueryParams = `${url.pathname}${url.search}`;
+
+    const body = await prepareRequestBody(init);
+    const headers = prepareRequestHeaders(init);
+
+    if (shouldCallHttpRequest(init, headers)) {
+        return await callHttpRequest(
+            init,
+            actor,
+            urlAndQueryParams,
+            headers,
+            body
+        );
+    }
+
+    if (shouldCallHttpRequestUpdate(init, headers)) {
+        return await callHttpRequestUpdate(
+            init,
+            actor,
+            urlAndQueryParams,
+            headers,
+            body
+        );
+    }
+
+    throw new Error(`fetchIc: This request combination is not supported`);
+}
+
+function getUrlString(input: RequestInfo | URL): string {
+    if (typeof input === 'string') {
+        return input;
+    }
+
+    if (input instanceof URL) {
+        return input.toString();
+    }
+
+    if (input instanceof Request) {
+        return input.url;
+    }
+
+    throw new Error(`fetchIc: input must be a string, URL, or Request`);
+}
+
+function prepareRequestHeaders(
+    init: RequestInit | undefined
+): [string, string][] {
+    // TODO should we try to add in the default headers that browsers or Node.js would add?
+    const headersTuples = getHeadersTuples(init);
+
+    return headersTuples.filter(([key]) => key !== 'Authorization');
+}
+
+function getHeadersTuples(init: RequestInit | undefined): [string, string][] {
+    if (init === undefined) {
+        return [];
+    }
+
+    if (init.headers instanceof Headers) {
+        throw new Error(`fetchIc: Headers is not a supported headers type`);
+    }
+
+    if (Array.isArray(init.headers)) {
+        return init.headers;
+    }
+
+    if (typeof init.headers === 'object') {
+        return Object.entries(init.headers);
+    }
+
+    throw new Error(`fetchIc: not a supported headers type`);
+}
+
+async function prepareRequestBody(
+    init: RequestInit | undefined
+): Promise<Uint8Array> {
+    if (init === undefined) {
+        return Uint8Array.from([]);
+    }
+
+    if (init.body === null) {
+        return Uint8Array.from([]);
+    }
+
+    if (init.body === undefined) {
+        return Uint8Array.from([]);
+    }
+
+    if (typeof init.body === 'string') {
+        const textEncoder = new TextEncoder();
+        return textEncoder.encode(init.body);
+    }
+
+    if (
+        init.body instanceof BigUint64Array ||
+        init.body instanceof BigInt64Array
+    ) {
+        return new Uint8Array(init.body.buffer);
+    }
+
+    if (init.body instanceof Uint8Array) {
+        return init.body;
+    }
+
+    if (
+        init.body instanceof ArrayBuffer ||
+        init.body instanceof Uint8ClampedArray ||
+        init.body instanceof Uint16Array ||
+        init.body instanceof Uint32Array ||
+        init.body instanceof Int8Array ||
+        init.body instanceof Int16Array ||
+        init.body instanceof Int32Array ||
+        init.body instanceof Float32Array ||
+        init.body instanceof Float64Array
+    ) {
+        return new Uint8Array(init.body);
+    }
+
+    if (init.body instanceof DataView) {
+        return new Uint8Array(init.body.buffer);
+    }
+
+    if (init.body instanceof Blob) {
+        return new Uint8Array(await init.body.arrayBuffer());
+    }
+
+    if (init.body instanceof File) {
+        const blob = new Blob([init.body], { type: init.body.type });
+        const buffer = await blob.arrayBuffer();
+        return new Uint8Array(buffer);
+    }
+
+    if (init.body instanceof URLSearchParams) {
+        const encoder = new TextEncoder();
+        return encoder.encode(init.body.toString());
+    }
+
+    if (init.body instanceof FormData) {
+        throw new Error(`fetchIc: FormData is not a supported body type`);
+    }
+
+    throw new Error(`fetchIc: Not a supported body type`);
+}
+
+function shouldCallHttpRequest(
+    init: RequestInit | undefined,
+    headers: [string, string][]
+): boolean {
+    return (
+        init === undefined ||
+        init.method === undefined ||
+        init.method === 'GET' ||
+        init.method === 'HEAD' ||
+        init.method === 'OPTIONS' ||
+        headers.find(
+            ([key, value]) =>
+                key.toLowerCase() === 'x-ic-force-query' && value === 'true'
+        ) !== undefined
+    );
+}
+
+function shouldCallHttpRequestUpdate(
+    init: RequestInit | undefined,
+    headers: [string, string][]
+): boolean {
+    return (
+        init !== undefined &&
+        (init.method === 'POST' ||
+            init.method === 'PUT' ||
+            init.method === 'PATCH' ||
+            init.method === 'DELETE' ||
+            headers.find(
+                ([key, value]) =>
+                    key.toLowerCase() === 'x-ic-force-update' &&
+                    value === 'true'
+            ) !== undefined)
+    );
+}
+
+async function callHttpRequest(
+    init: RequestInit | undefined,
+    actor: Awaited<ReturnType<typeof createActor>>,
+    urlAndQueryParams: string,
+    headers: [string, string][],
+    body: Uint8Array
+): Promise<CallHttpRequestResult> {
+    const method = init?.method ?? 'GET';
+
+    checkGetHeadBody(method, body);
+
+    return await actor.http_request({
+        method,
+        url: urlAndQueryParams,
+        headers,
+        body,
+        certificate_version: [2]
+    });
+}
+
+async function callHttpRequestUpdate(
+    init: RequestInit | undefined,
+    actor: Awaited<ReturnType<typeof createActor>>,
+    urlAndQueryParams: string,
+    headers: [string, string][],
+    body: Uint8Array
+): Promise<CallHttpRequestUpdateResult> {
+    const method = init?.method ?? 'GET';
+
+    checkGetHeadBody(method, body);
+
+    return await actor.http_request_update({
+        method,
+        url: urlAndQueryParams,
+        headers: [
+            ...headers,
+            ...(body.length !== 0
+                ? ([['Content-Length', body.length.toString()]] as [
+                      string,
+                      string
+                  ][])
+                : ([] as [string, string][]))
+        ],
+        body
+    });
+}
+
+function checkGetHeadBody(method: string, body: Uint8Array): void {
+    if (
+        (method.toLowerCase() === 'get' || method.toLowerCase() === 'head') &&
+        body.length !== 0
+    ) {
+        throw new Error(
+            `fetchIc: Request with GET/HEAD method cannot have body.`
+        );
+    }
+}

package/src/experimental/lib/http_client/fetch_ic/get_canister_id.ts

@@ -0,0 +1,25 @@
+// TODO it would be pretty cool to get the canister id from DNS records
+// TODO seems we would have to call some service that can query DNS
+export function getCanisterId(input: RequestInfo | URL): string {
+    // @ts-ignore
+    if (typeof import.meta.env.IC_ORIGIN_CANISTER_ID === 'string') {
+        // @ts-ignore
+        return import.meta.env.IC_ORIGIN_CANISTER_ID;
+    }
+
+    if (typeof input === 'string') {
+        return new URL(input).hostname.split('.')[0];
+    }
+
+    if (input instanceof URL) {
+        return input.hostname.split('.')[0];
+    }
+
+    if (input instanceof Request) {
+        return getCanisterId(input.url);
+    }
+
+    throw new Error(
+        `fetchIc: canister id could not be obtained from URL or IC_ORIGIN_CANISTER_ID environment variable`
+    );
+}

package/src/experimental/lib/http_client/fetch_ic/host.ts

@@ -0,0 +1,30 @@
+export function getHost(input: RequestInfo | URL): string {
+    const hostString = getHostString(input);
+
+    const runningLocally =
+        hostString.includes(`localhost:`) || hostString.includes(`127.0.0.1:`);
+
+    // icp-api.io is the API gateway hostname: https://internetcomputer.org/docs/current/references/http-gateway-protocol-spec#api-gateway-resolution
+    // A production application may have a custom domain
+    // thus it is safest to use icp-api.io instead of the hostString when on mainnet
+    // I am also not sure if the hostString on mainnet e.g. https://canisterId.icp0.io can be used
+    const host = runningLocally === true ? hostString : 'http://icp-api.io';
+
+    return host;
+}
+
+function getHostString(input: RequestInfo | URL): string {
+    if (typeof input === 'string') {
+        return new URL(input).host;
+    }
+
+    if (input instanceof URL) {
+        return input.host;
+    }
+
+    if (input instanceof Request) {
+        return getHostString(input.url);
+    }
+
+    throw new Error(`fetchIc: input not supported`);
+}

package/src/experimental/lib/http_client/fetch_ic/identity.ts

@@ -0,0 +1,52 @@
+import { Identity } from '@dfinity/agent';
+
+export function getIdentity(
+    headers: RequestInit['headers']
+): Identity | undefined {
+    const authorizationHeaderValue = getAuthorizationHeaderValue(headers);
+
+    if (
+        typeof authorizationHeaderValue === 'string' ||
+        authorizationHeaderValue === undefined
+    ) {
+        return undefined;
+    }
+
+    if (
+        authorizationHeaderValue === null ||
+        authorizationHeaderValue.getPrincipal === undefined ||
+        authorizationHeaderValue.transformRequest === undefined
+    ) {
+        throw new Error(
+            'fetchIc: Authorization header value is not an instance of Identity'
+        );
+    }
+
+    return authorizationHeaderValue;
+}
+
+// The return type is explicitly any
+function getAuthorizationHeaderValue(headers: RequestInit['headers']): any {
+    if (Array.isArray(headers)) {
+        return headers.reduce(
+            (acc: string | undefined | Identity, [key, value]) => {
+                if (key === 'Authorization') {
+                    return value;
+                }
+
+                return acc;
+            },
+            undefined
+        );
+    }
+
+    if (headers instanceof Headers) {
+        return headers.get('Authorization') ?? undefined;
+    }
+
+    if (typeof headers === 'object') {
+        return headers['Authorization'];
+    }
+
+    return undefined;
+}

package/src/experimental/lib/http_client/fetch_ic/index.ts

@@ -0,0 +1,95 @@
+// TODO should we write tests for nodejs as well then?
+
+import { createActor } from './actor';
+import { call } from './call';
+import { getCanisterId } from './get_canister_id';
+import { getHost } from './host';
+import { getIdentity } from './identity';
+import { createResponse } from './response';
+
+const originalFetch = globalThis.fetch;
+
+// TODO it would be nice to get rid of the any cast
+// TODO and to ensure that we really are using the correct types for fetch
+(globalThis as any).fetch = fetchIc;
+
+// TODO input can be a request, which acts just like init...we have not accounted for that
+// TODO it seems very uncommon to do that though, for now we won't implement it
+export async function fetchIc(
+    input: RequestInfo | URL,
+    init?: RequestInit | undefined
+): Promise<Response> {
+    const identity = getIdentity(init?.headers);
+
+    if (identity === undefined) {
+        return await originalFetch(input, init);
+    }
+
+    logWarnings(init);
+
+    const canisterId = getCanisterId(input);
+    const host = getHost(input);
+    const actor = await createActor(identity, canisterId, host);
+
+    const callResult = await call(input, init, actor);
+    const response = createResponse(callResult);
+
+    return response;
+}
+
+export { createActor } from './actor';
+export { createAgent } from './agent';
+export { getCanisterId };
+export { getHost } from './host';
+
+function logWarnings(init?: RequestInit | undefined): void {
+    if (init === undefined) {
+        return;
+    }
+
+    if (init.cache !== undefined) {
+        logWarning(`cache`);
+    }
+
+    if (init.credentials !== undefined) {
+        logWarning(`credentials`);
+    }
+
+    if (init.integrity !== undefined) {
+        logWarning(`integrity`);
+    }
+
+    if (init.keepalive !== undefined) {
+        logWarning(`keepalive`);
+    }
+
+    if (init.mode !== undefined) {
+        logWarning(`mode`);
+    }
+
+    if (init.redirect !== undefined) {
+        logWarning(`redirect`);
+    }
+
+    if (init.referrer !== undefined) {
+        logWarning(`referrer`);
+    }
+
+    if (init.referrerPolicy !== undefined) {
+        logWarning(`referrerPolicy`);
+    }
+
+    if (init.signal !== undefined) {
+        logWarning(`signal`);
+    }
+
+    if (init.window !== undefined) {
+        logWarning(`window`);
+    }
+}
+
+function logWarning(method: string): void {
+    console.warn(
+        `fetchIc: init.${method} has no effect when using an identity as the Authorization header`
+    );
+}

package/src/experimental/lib/http_client/fetch_ic/response.ts

@@ -0,0 +1,8 @@
+import { CallResult } from './call';
+
+export function createResponse(callResult: CallResult): Response {
+    return new Response(Uint8Array.from(callResult.body), {
+        headers: new Headers(callResult.headers),
+        status: callResult.status_code
+    });
+}

package/src/experimental/lib/http_client/index.ts

@@ -0,0 +1,6 @@
+// I am not sure if this side-effect import is necessary
+// but we must ensure that no bundler drops the ./fetch_ic file
+// because we are overwridding globalThis.fetch in there
+import './fetch_ic';
+export * from './fetch_ic';
+export * from './to_jwt';

package/src/experimental/lib/http_client/to_jwt.ts

@@ -0,0 +1,6 @@
+// TODO We hope to eventually truly convert the Identity into a JWT
+// TODO and have the boundary node verify it and construct the appropriate
+// TODO request to the canister
+export function toJwt(value: any): string {
+    return value as unknown as string;
+}

package/src/experimental/lib/ic/azle_ic_experimental.ts

@@ -0,0 +1,92 @@
+/**
+ * The interface for our rust methods it slightly different than the interface
+ * we expose to the users. This is the interface for the rust functions.
+ */
+export type AzleIcExperimental = {
+    msgArgData: () => ArrayBuffer;
+    callRaw: (
+        globalResolveId: string,
+        globalRejectId: string,
+        canisterIdBytes: ArrayBuffer,
+        method: string,
+        argsRaw: ArrayBuffer,
+        paymentString: string
+    ) => void;
+    msgCaller: () => ArrayBuffer;
+    candidCompiler: (candidPath: string) => string;
+    candidDecode: (candidBytes: ArrayBuffer) => string;
+    candidEncode: (candidString: string) => ArrayBuffer;
+    canisterCycleBalance: () => string;
+    canisterVersion: () => string;
+    clearTimer: (timerIdString: string) => void;
+    cyclesBurn: (amount: string) => string;
+    dataCertificate: () => ArrayBuffer | undefined;
+    canisterSelf: () => string;
+    inReplicatedExecution: () => boolean;
+    isController: (principalBytes: ArrayBuffer) => boolean;
+    msgCyclesAccept: (maxAmountString: string) => string;
+    msgCyclesAvailable: () => string;
+    msgCyclesRefunded: () => string;
+    notifyRaw: (
+        canisterIdBytes: ArrayBuffer,
+        method: string,
+        argsRawBuffer: ArrayBuffer,
+        paymentString: string
+    ) => void;
+    performanceCounter: (counterType: string) => string;
+    msgRejectCode: () => number;
+    msgReply: (bytes: ArrayBuffer) => void;
+    randBytes: (byteLength: number) => ArrayBuffer;
+    randSeed: (seed: ArrayBuffer) => void;
+    certifiedDataSet: (dataBytes: ArrayBuffer) => void;
+    setTimer: (delayString: string) => string;
+    setTimerInterval: (intervalString: string) => string;
+    time: () => string;
+    drainMicrotasks: () => void;
+    // These calls aren't intercepted by our IC object, they go right to the
+    // rust version and come out. Since they don't need to be intercepted I am
+    // assuming that their types are the same as the types declared by our
+    // interceptor.
+    acceptMessage: () => void;
+    msgMethodName: () => string;
+    debugPrint: (message: string) => void;
+    msgReject: (message: string) => void;
+    msgRejectMsg: () => string;
+    trap: (message: string) => never;
+    // Stable B Tree Map Functions
+    stableBTreeMapInit: (memoryId: string) => void;
+    stableBTreeMapContainsKey: (
+        memoryId: string,
+        encodedKey: ArrayBuffer
+    ) => boolean;
+    stableBTreeMapGet: (
+        memoryId: string,
+        encodedKey: ArrayBuffer
+    ) => ArrayBuffer | undefined;
+    stableBTreeMapInsert: (
+        memoryId: string,
+        encodedKey: ArrayBuffer,
+        encodedValue: ArrayBuffer
+    ) => ArrayBuffer | undefined;
+    stableBTreeMapIsEmpty: (memoryId: string) => boolean;
+    stableBTreeMapItems: (
+        memoryId: string,
+        startIndex: string,
+        length: string
+    ) => [ArrayBuffer, ArrayBuffer][];
+    stableBTreeMapKeys: (
+        memoryId: string,
+        startIndex: string,
+        length: string
+    ) => ArrayBuffer[];
+    stableBTreeMapLen: (memoryId: string) => string;
+    stableBTreeMapRemove(
+        memoryId: string,
+        encodedKey: ArrayBuffer
+    ): ArrayBuffer;
+    stableBTreeMapValues: (
+        memoryId: string,
+        startIndex: string,
+        length: string
+    ) => ArrayBuffer[];
+};

package/src/experimental/lib/ic/candid_compiler.ts

@@ -0,0 +1,14 @@
+import '#experimental/lib/assert_experimental';
+
+/**
+ * Converts a Candid string into its corresponding IDL as a string
+ * @param candidString a valid Candid string
+ * @returns the IDL string
+ */
+export function candidCompiler(candidPath: string): string {
+    if (globalThis._azleIcExperimental === undefined) {
+        return '';
+    }
+
+    return globalThis._azleIcExperimental.candidCompiler(candidPath);
+}

package/src/experimental/lib/ic/index.ts

@@ -0,0 +1,10 @@
+import '#experimental/lib/assert_experimental';
+
+import { candidCompiler } from './candid_compiler';
+import { setOutgoingHttpOptions } from './set_outgoing_http_options';
+
+/** API entrypoint for interacting with the Internet Computer */
+export const ic = {
+    candidCompiler,
+    setOutgoingHttpOptions
+};

package/src/experimental/lib/ic/set_outgoing_http_options.ts

@@ -0,0 +1,18 @@
+import '#experimental/lib/assert_experimental';
+
+export function setOutgoingHttpOptions(options: {
+    maxResponseBytes?: bigint;
+    subnetSize?: number;
+    cycles?: bigint;
+    transformMethodName?: string;
+    transformContext?: Uint8Array;
+}): void {
+    globalThis._azleOutgoingHttpOptionsMaxResponseBytes =
+        options.maxResponseBytes;
+    globalThis._azleOutgoingHttpOptionsSubnetSize = options.subnetSize;
+    globalThis._azleOutgoingHttpOptionsCycles = options.cycles;
+    globalThis._azleOutgoingHttpOptionsTransformMethodName =
+        options.transformMethodName;
+    globalThis._azleOutgoingHttpOptionsTransformContext =
+        options.transformContext;
+}

package/src/experimental/lib/index.ts

@@ -0,0 +1,7 @@
+import '#experimental/lib/assert_experimental';
+import '#experimental/lib/globals';
+
+export { serialize } from '#experimental/lib/fetch/index';
+export * from '#experimental/lib/ic/index';
+export * from '#experimental/lib/server';
+export * from '#experimental/lib/threshold_wallet/index';