@ohos-ports/azle 0.33.0-beta.0

package/src/experimental/lib/server.ts

@@ -0,0 +1,279 @@
+import '#experimental/lib/assert_experimental';
+
+import { Server as NodeServer, ServerResponse } from 'http';
+// @ts-ignore
+import { HttpConn } from 'http';
+// @ts-ignore
+import { IncomingMessageForServer } from 'http';
+// @ts-ignore
+import httpMessageParser from 'http-message-parser';
+
+import {
+    HttpRequest,
+    HttpResponse,
+    HttpUpdateRequest
+} from '#lib/canisters/http_gateway/idl/index';
+import { idlDecode, idlEncode } from '#lib/execute_and_reply_with_candid_serde';
+import { msgArgData, msgReply } from '#lib/ic_apis/index';
+import { query, update } from '#lib/index';
+
+export class Server {
+    nodeServer?: NodeServer;
+
+    @query([HttpRequest], HttpResponse, { composite: true, manual: true })
+    async http_request(): Promise<void> {
+        const httpRequest = idlDecode(
+            [HttpRequest],
+            msgArgData()
+        )[0] as unknown as HttpRequest;
+
+        if (this.nodeServer === undefined) {
+            throw new Error(
+                'The nodeServer property of the Server base class has not been set.'
+            );
+        }
+
+        await httpHandler(this.nodeServer, httpRequest, true);
+    }
+
+    @update([HttpUpdateRequest], HttpResponse, { manual: true })
+    async http_request_update(): Promise<void> {
+        const httpUpdateRequest = idlDecode(
+            [HttpUpdateRequest],
+            msgArgData()
+        )[0] as unknown as HttpUpdateRequest;
+
+        if (this.nodeServer === undefined) {
+            throw new Error(
+                'The nodeServer property of the Server base class has not been set.'
+            );
+        }
+
+        await httpHandler(this.nodeServer, httpUpdateRequest, false);
+    }
+}
+
+export async function httpHandler(
+    nodeServer: NodeServer,
+    httpRequest: HttpRequest | HttpUpdateRequest,
+    query: boolean
+): Promise<void> {
+    if (shouldUpgrade(httpRequest, query)) {
+        const encoded = idlEncode(
+            [HttpResponse],
+            [
+                {
+                    status_code: 204,
+                    headers: [],
+                    body: Uint8Array.from([]),
+                    streaming_strategy: [],
+                    upgrade: [true]
+                }
+            ]
+        );
+
+        msgReply(encoded);
+
+        return;
+    }
+
+    // TODO we should probably do the full try socket more in Rust
+    class AzleSocket {
+        responseData = Buffer.from([]);
+        readable = true;
+        writeable = true;
+        res: ServerResponse | null = null;
+
+        async read(): Promise<ArrayBuffer> {
+            const httpLine1 = `${httpRequest.method} ${httpRequest.url} HTTP/1.1\r\n`;
+
+            const httpHeaders = httpRequest.headers
+                .map((header) => {
+                    return `${header[0]}: ${header[1]}`;
+                })
+                .join('\r\n');
+
+            const httpString = `${httpLine1}${httpHeaders}\r\n\r\n`;
+
+            return Buffer.concat([
+                Buffer.from(httpString),
+                new Uint8Array(httpRequest.body)
+            ]).buffer;
+        }
+
+        async write(data: any): Promise<void> {
+            if (data.byteLength !== undefined) {
+                this.responseData = Buffer.concat([
+                    this.responseData,
+                    Buffer.from(data)
+                ]);
+
+                return;
+            }
+
+            if (typeof data === 'string') {
+                this.responseData = Buffer.concat([
+                    this.responseData,
+                    Buffer.from(data)
+                ]);
+
+                return;
+            }
+
+            // TODO I am not sure if this works
+            // TODO I did what I remember Rust doing
+            // TODO which is to just turn the object into a string
+            if (typeof data === 'object') {
+                this.responseData = Buffer.concat([
+                    this.responseData,
+                    Buffer.from(data.toString())
+                ]);
+                return;
+            }
+        }
+
+        end(_data: any): void {
+            const startIndex =
+                this.responseData.indexOf(Buffer.from('\r\n\r\n')) + 4;
+
+            const parsedHttpResponse = httpMessageParser(
+                this.responseData.slice(0, startIndex)
+            );
+
+            const isChunked = Object.keys(parsedHttpResponse.headers)
+                .map((key) => key.toLowerCase())
+                .includes('transfer-encoding');
+
+            const slicedBody = this.responseData.slice(startIndex);
+
+            const unchunkedBody = isChunked
+                ? processChunkedBody(slicedBody)
+                : slicedBody;
+
+            if (this.res === null) {
+                throw new Error('res must be defined');
+            }
+
+            // TODO should we be using parsedHttpResponse.headers or this.res.getHeaders()?
+            // TODO this.res.getHeaders() seems to be missing some headers like Transfer-Encoding
+            // TODO also Express in Node has more headers like Date, Connection, Keep-Alive
+            // TODO Conection and Keep-Alive might just not make sense in our context
+            const encoded = idlEncode(
+                [HttpResponse],
+                [
+                    {
+                        status_code: this.res.statusCode,
+                        headers: Object.entries(this.res.getHeaders())
+                            .map((entry) => entry)
+                            .filter((header) => {
+                                // TODO it seems the ic proxy always wants to put its own content-length
+                                // TODO and having either of these headers causes issues
+                                // TODO we are essentially disabling transfer-encoding and thus the ability
+                                // TODO to do a chunked encoding
+                                return (
+                                    header[0].toLowerCase() !==
+                                        'content-length' &&
+                                    header[0].toLowerCase() !==
+                                        'transfer-encoding'
+                                );
+                            }),
+                        body: new Uint8Array(unchunkedBody),
+                        streaming_strategy: [],
+                        upgrade: []
+                    }
+                ]
+            );
+
+            msgReply(encoded);
+        }
+    }
+
+    const azleSocket = new AzleSocket();
+
+    const httpConn = new HttpConn(azleSocket);
+
+    const request = await httpConn.nextRequest();
+
+    const req = new IncomingMessageForServer(request, httpConn);
+    const res = new ServerResponse(httpConn);
+
+    azleSocket.res = res;
+
+    nodeServer.emit('request', req, res);
+}
+
+function shouldUpgrade(
+    httpRequest: HttpRequest | HttpUpdateRequest,
+    query: boolean
+): boolean {
+    const forceQueryHeaderExists = forceHeaderExists(
+        'X-Ic-Force-Query',
+        httpRequest.headers
+    );
+
+    const forceUpdateHeaderExists = forceHeaderExists(
+        'X-Ic-Force-Update',
+        httpRequest.headers
+    );
+
+    return (
+        query === true &&
+        !forceQueryHeaderExists &&
+        (httpRequest.method === 'POST' ||
+            httpRequest.method === 'PUT' ||
+            httpRequest.method === 'PATCH' ||
+            httpRequest.method === 'DELETE' ||
+            forceUpdateHeaderExists)
+    );
+}
+
+function forceHeaderExists(
+    headerName: string,
+    headers: [string, string][]
+): boolean {
+    return (
+        headers.find(
+            ([key, value]) =>
+                key.toLowerCase() === headerName.toLowerCase() &&
+                value === 'true'
+        ) !== undefined
+    );
+}
+
+// TODO I think this is correct but it is expensive
+// TODO we really just want the icx-proxy or boundary node to not
+// TODO automatically apply the Content-Length header
+// TODO we should open up an issue to get the icx-proxy to allow chunked transfer encodings
+// TODO and to not mess with the content-length header if it is already set
+function processChunkedBody(buffer: Buffer): Buffer {
+    let result = Buffer.alloc(0);
+    let remaining = buffer;
+
+    while (remaining.length > 0) {
+        const sizeEnd = remaining.indexOf('\r\n');
+        if (sizeEnd === -1) {
+            throw new Error('Invalid chunked body: missing size line end');
+        }
+
+        const sizeLine = remaining.slice(0, sizeEnd).toString();
+        const chunkSize = parseInt(sizeLine, 16);
+
+        if (chunkSize === 0) {
+            break; // End of chunks
+        }
+
+        const chunkStart = sizeEnd + 2; // skip CRLF
+        const chunkEnd = chunkStart + chunkSize;
+
+        if (chunkEnd > remaining.length) {
+            throw new Error('Invalid chunked body: incomplete chunk');
+        }
+
+        const chunk = remaining.slice(chunkStart, chunkEnd);
+        result = Buffer.concat([result, chunk]);
+
+        remaining = remaining.slice(chunkEnd + 2); // skip chunk data and trailing CRLF
+    }
+
+    return result;
+}

package/src/experimental/lib/threshold_wallet/calculate_rsv_for_tecdsa.ts

@@ -0,0 +1,45 @@
+import '#experimental/lib/assert_experimental';
+
+import { ethers } from 'ethers';
+
+export function calculateRsvForTEcdsa(
+    chainId: number,
+    address: string,
+    digest: string,
+    signature: Uint8Array
+): { r: string; s: string; v: number } {
+    const r = ethers.hexlify(signature.slice(0, 32));
+    const s = ethers.hexlify(signature.slice(32, 64));
+
+    const vPartial = chainId * 2 + 35;
+    const v0 = vPartial;
+    const v1 = vPartial + 1;
+
+    const rsv0 = {
+        r,
+        s,
+        v: v0
+    };
+
+    if (
+        address.toLowerCase() ===
+        ethers.recoverAddress(digest, rsv0).toLowerCase()
+    ) {
+        return rsv0;
+    }
+
+    const rsv1 = {
+        r,
+        s,
+        v: v1
+    };
+
+    if (
+        address.toLowerCase() ===
+        ethers.recoverAddress(digest, rsv1).toLowerCase()
+    ) {
+        return rsv1;
+    }
+
+    throw new Error(`ThresholdWallet: v could not be calculated correctly`);
+}

package/src/experimental/lib/threshold_wallet/ecdsa_public_key.ts

@@ -0,0 +1,33 @@
+import '#experimental/lib/assert_experimental';
+
+import { Principal } from '@dfinity/principal';
+
+import { serialize } from '../fetch';
+import { ThresholdKeyInfo } from './wallet';
+
+export async function ecdsaPublicKey(
+    thresholdKeyInfo: ThresholdKeyInfo
+): Promise<Uint8Array> {
+    const response = await fetch('icp://aaaaa-aa/ecdsa_public_key', {
+        body: serialize({
+            args: [
+                {
+                    derivation_path: thresholdKeyInfo.derivationPath,
+                    canister_id:
+                        thresholdKeyInfo.canisterId === undefined
+                            ? []
+                            : [Principal.from(thresholdKeyInfo.canisterId)],
+                    key_id: {
+                        curve: {
+                            [thresholdKeyInfo.keyId?.curve ?? 'secp256k1']: null
+                        },
+                        name: thresholdKeyInfo.keyId?.name ?? 'dfx_test_key'
+                    }
+                }
+            ]
+        })
+    });
+    const responseJson = await response.json();
+
+    return responseJson.public_key;
+}

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

@@ -0,0 +1,7 @@
+import '#experimental/lib/assert_experimental';
+
+export * from './calculate_rsv_for_tecdsa';
+export * from './ecdsa_public_key';
+export * from './register_get_url';
+export * from './sign_with_ecdsa';
+export * from './wallet';

package/src/experimental/lib/threshold_wallet/register_get_url.ts

@@ -0,0 +1,36 @@
+import '#experimental/lib/assert_experimental';
+
+// TODO unfortunately this is highly unlikely to work in production because
+// TODO of the headers...we need a good transform
+// TODO what if the nodes automatically removed conflicting information?
+// TODO for example, headers were removed if they weren't the same
+// TODO it would be great if the minimum response could always come back
+// TODO and then the response can say what was wrong, instead of an error
+// TODO what if the developer installs a different version of ethers?
+// TODO should we use a peer dependency?
+import { ethers } from 'ethers';
+
+export async function ethersGetUrl(
+    fetchRequest: ethers.FetchRequest
+): Promise<ethers.FetchResponse> {
+    const response = await fetch(fetchRequest.url, {
+        method: fetchRequest.method,
+        headers: fetchRequest.headers,
+        body: fetchRequest.body ? new Uint8Array(fetchRequest.body) : null
+    });
+
+    const fetchResponse = new ethers.FetchResponse(
+        response.status,
+        response.statusText,
+        Array.from(response.headers.entries()).reduce((acc, [key, value]) => {
+            return {
+                ...acc,
+                [key]: value
+            };
+        }, {}),
+        new Uint8Array(await response.arrayBuffer()),
+        fetchRequest
+    );
+
+    return fetchResponse;
+}

package/src/experimental/lib/threshold_wallet/sign_with_ecdsa.ts

@@ -0,0 +1,28 @@
+import '#experimental/lib/assert_experimental';
+
+import { serialize } from '../fetch';
+import { ThresholdKeyInfo } from './wallet';
+
+export async function signWithEcdsa(
+    thresholdKeyInfo: ThresholdKeyInfo,
+    messageHash: Uint8Array
+): Promise<Uint8Array> {
+    const publicKeyResponse = await fetch(`icp://aaaaa-aa/sign_with_ecdsa`, {
+        body: serialize({
+            args: [
+                {
+                    message_hash: messageHash,
+                    derivation_path: thresholdKeyInfo.derivationPath,
+                    key_id: {
+                        curve: {
+                            [thresholdKeyInfo.keyId?.curve ?? 'secp256k1']: null
+                        },
+                        name: thresholdKeyInfo.keyId?.name ?? 'dfx_test_key'
+                    }
+                }
+            ]
+        })
+    });
+
+    return (await publicKeyResponse.json()).signature;
+}

package/src/experimental/lib/threshold_wallet/wallet.ts

@@ -0,0 +1,99 @@
+import '#experimental/lib/assert_experimental';
+import './register_get_url';
+
+import { Principal } from '@dfinity/principal';
+import { ethers } from 'ethers';
+
+import { calculateRsvForTEcdsa } from './calculate_rsv_for_tecdsa';
+import { ecdsaPublicKey } from './ecdsa_public_key';
+import { signWithEcdsa } from './sign_with_ecdsa';
+
+export type ThresholdKeyInfo = {
+    derivationPath: Uint8Array[];
+    canisterId?: Principal | string;
+    keyId?: {
+        curve: 'secp256k1';
+        name: 'dfx_test_key' | 'test_key_1' | 'key_1';
+    };
+};
+
+export class ThresholdWallet extends ethers.AbstractSigner {
+    thresholdKeyInfo: ThresholdKeyInfo;
+    address: string | null = null;
+
+    constructor(
+        thresholdKeyInfo: ThresholdKeyInfo,
+        provider: ethers.Provider | null = null
+    ) {
+        super(provider);
+
+        this.thresholdKeyInfo = thresholdKeyInfo;
+    }
+
+    connect(provider: ethers.Provider | null): ThresholdWallet {
+        return new ThresholdWallet(this.thresholdKeyInfo, provider);
+    }
+
+    async getAddress(): Promise<string> {
+        if (this.address === null) {
+            this.address = ethers.computeAddress(
+                ethers.hexlify(await ecdsaPublicKey(this.thresholdKeyInfo))
+            );
+        }
+
+        return this.address;
+    }
+
+    async signTransaction(
+        txRequest: ethers.TransactionRequest
+    ): Promise<string> {
+        // TODO Hopefully we can remove the explicit any after this is resolved: https://github.com/ethers-io/ethers.js/issues/4659
+        let tx = ethers.Transaction.from(txRequest as any);
+
+        const unsignedSerializedTx = tx.unsignedSerialized;
+        const unsignedSerializedTxHash = ethers.keccak256(unsignedSerializedTx);
+
+        const signedSerializedTxHash = await signWithEcdsa(
+            this.thresholdKeyInfo,
+            ethers.getBytes(unsignedSerializedTxHash)
+        );
+
+        if (this.provider === null) {
+            throw new Error(`ThresholdWallet: provider must not be null`);
+        }
+
+        const network = await this.provider.getNetwork();
+        const chainId = Number(network.chainId);
+
+        const { r, s, v } = calculateRsvForTEcdsa(
+            chainId,
+            await this.getAddress(),
+            unsignedSerializedTxHash,
+            signedSerializedTxHash
+        );
+
+        tx.signature = {
+            r,
+            s,
+            v
+        };
+
+        const rawTransaction = tx.serialized;
+
+        return rawTransaction;
+    }
+
+    // TODO implement?
+    async signMessage(_message: string | Uint8Array): Promise<string> {
+        throw new Error(`ThresholdWallet: signMessage is not implemented`);
+    }
+
+    // TODO implement?
+    async signTypedData(
+        _domain: ethers.TypedDataDomain,
+        _types: Record<string, ethers.TypedDataField[]>,
+        _value: Record<string, any>
+    ): Promise<string> {
+        throw new Error(`ThresholdWallet: signTypedData is not implemented`);
+    }
+}

package/src/experimental/test/property/arbitraries/candid/candid_definition_arb/complex_candid_definition_memo.ts

@@ -0,0 +1,113 @@
+import '#experimental/build/assert_experimental';
+
+import fc from 'fast-check';
+
+import { Context } from '../../types';
+import { BlobDefinitionArb } from '../constructed/blob_arb/definition_arb';
+import { OptDefinitionArb } from '../constructed/opt_arb/definition_arb';
+import { RecordDefinitionArb } from '../constructed/record_arb/definition_arb';
+import { TupleDefinitionArb } from '../constructed/tuple_arb/definition_arb';
+import { VariantDefinitionArb } from '../constructed/variant_arb/definition_arbs';
+import { VecDefinitionArb } from '../constructed/vec_arb/definition_arb';
+import { FuncDefinitionArb } from '../reference/func_arb/definition_arb';
+import { ServiceDefinitionArb } from '../reference/service_arb/definition_arb';
+import { candidDefinitionMemo } from '.';
+import {
+    CandidDefinitionMemo,
+    DefinitionConstraints,
+    RecursiveCandidName
+} from './types';
+
+export type ComplexDefinitionWeights = Partial<{
+    blob: number;
+    opt: number;
+    record: number;
+    tuple: number;
+    variant: number;
+    vec: number;
+    func: number;
+    service: number;
+}>;
+
+// The number of options below (blob, func, opt, etc)
+export const COMPLEX_ARB_COUNT = 8;
+
+export function complexCandidDefinitionMemo(
+    context: Context<DefinitionConstraints>,
+    parents: RecursiveCandidName[]
+): CandidDefinitionMemo {
+    const constraints = context.constraints;
+    const weights = constraints.weights ?? {};
+    const newConstraints: DefinitionConstraints = {
+        depthLevel: constraints.depthLevel,
+        weights:
+            (constraints.recursiveWeights ?? false)
+                ? (constraints.weights ?? {})
+                : {},
+        recursiveWeights: constraints.recursiveWeights,
+        forceInline: constraints.forceInline
+    };
+    const newContext = {
+        constraints: newConstraints
+    };
+    return fc.memo((depthLevel) => {
+        return fc.oneof(
+            {
+                arbitrary: BlobDefinitionArb(),
+                weight: weights.blob ?? 1
+            },
+            {
+                arbitrary: FuncDefinitionArb(
+                    candidDefinitionMemo(newContext, [])(depthLevel)
+                ),
+                weight: weights.func ?? 1
+            },
+            {
+                arbitrary: OptDefinitionArb(
+                    newContext,
+                    candidDefinitionMemo,
+                    parents
+                ),
+                weight: weights.opt ?? 1
+            },
+            {
+                arbitrary: RecordDefinitionArb(
+                    { ...context, constraints: {} },
+                    candidDefinitionMemo(newContext, [])(depthLevel)
+                ),
+                weight: weights.record ?? 1
+            },
+            {
+                arbitrary: TupleDefinitionArb(
+                    { ...context, constraints: {} },
+                    candidDefinitionMemo(newContext, [])(depthLevel)
+                ),
+                weight: weights.tuple ?? 1
+            },
+            {
+                arbitrary: VariantDefinitionArb(
+                    { ...context, constraints: newConstraints },
+                    candidDefinitionMemo,
+                    parents
+                ),
+                weight: weights.variant ?? 1
+            },
+            {
+                arbitrary: VecDefinitionArb(
+                    context,
+                    candidDefinitionMemo,
+                    parents
+                ),
+                weight: weights.vec ?? 1
+            },
+            {
+                arbitrary: ServiceDefinitionArb(
+                    candidDefinitionMemo(newContext, [])(depthLevel)
+                ),
+                weight: weights.service ?? 0
+                // TODO Service is disabled until it is more refined. Maybe the
+                // only thing missing is deepEquals
+            }
+        );
+    });
+}