@ohos-ports/azle 0.33.0-beta.0

package/src/stable/lib/canisters/exchange_rate/idl/README.md

@@ -0,0 +1,9 @@
+- `index.did` manual Candid source: https://dashboard.internetcomputer.org/canister/uf6dk-hyaaa-aaaaq-qaaaq-cai
+- Licensing is assumed to be that described in ../../NOTICE
+
+# How to update the IDL and TypeScript types
+
+1. Go to the URL above
+2. Find the Candid on that page and copy it
+3. Paste the Candid into `index.did`
+4. From this directory run `npx azle generate index.did > index.ts`

package/src/stable/lib/canisters/exchange_rate/idl/index.did

@@ -0,0 +1,83 @@
+type AssetClass = variant { Cryptocurrency; FiatCurrency; };
+
+type Asset = record {
+    symbol: text;
+    class: AssetClass;
+};
+
+// The parameters for the `get_exchange_rate` API call.
+type GetExchangeRateRequest = record {
+    base_asset: Asset;
+    quote_asset: Asset;
+    // An optional timestamp to get the rate for a specific time period.
+    timestamp: opt nat64;
+}; 
+
+type ExchangeRateMetadata = record {
+    decimals: nat32;
+    base_asset_num_received_rates: nat64;
+    base_asset_num_queried_sources: nat64;
+    quote_asset_num_received_rates: nat64;
+    quote_asset_num_queried_sources: nat64;
+    standard_deviation: nat64;
+    forex_timestamp: opt nat64;
+};
+
+type ExchangeRate = record {
+    base_asset: Asset;
+    quote_asset: Asset;
+    timestamp: nat64;
+    rate: nat64;
+    metadata: ExchangeRateMetadata;
+};
+
+type ExchangeRateError = variant {
+    // Returned when the canister receives a call from the anonymous principal.
+    AnonymousPrincipalNotAllowed: null;
+    /// Returned when the canister is in process of retrieving a rate from an exchange.
+    Pending: null;
+    // Returned when the base asset rates are not found from the exchanges HTTP outcalls.
+    CryptoBaseAssetNotFound: null;
+    // Returned when the quote asset rates are not found from the exchanges HTTP outcalls.
+    CryptoQuoteAssetNotFound: null;
+    // Returned when the stablecoin rates are not found from the exchanges HTTP outcalls needed for computing a crypto/fiat pair.
+    StablecoinRateNotFound: null;
+    // Returned when there are not enough stablecoin rates to determine the forex/USDT rate.
+    StablecoinRateTooFewRates: null;
+    // Returned when the stablecoin rate is zero.
+    StablecoinRateZeroRate: null;
+    // Returned when a rate for the provided forex asset could not be found at the provided timestamp.
+    ForexInvalidTimestamp: null;
+    // Returned when the forex base asset is found.
+    ForexBaseAssetNotFound: null;
+    // Returned when the forex quote asset is found.
+    ForexQuoteAssetNotFound: null;
+    // Returned when neither forex asset is found.
+    ForexAssetsNotFound: null;
+    // Returned when the caller is not the CMC and there are too many active requests.
+    RateLimited: null;
+    // Returned when the caller does not send enough cycles to make a request.
+    NotEnoughCycles: null;
+    // Returned when the canister fails to accept enough cycles.
+    FailedToAcceptCycles: null;
+    /// Returned if too many collected rates deviate substantially.
+    InconsistentRatesReceived: null;
+    // Until candid bug is fixed, new errors after launch will be placed here.
+    Other: record {
+        // The identifier for the error that occurred.
+        code: nat32;
+        // A description of the error that occurred.
+        description: text;
+    }
+};
+
+type GetExchangeRateResult = variant {
+    // Successfully retrieved the exchange rate from the cache or API calls.
+    Ok: ExchangeRate;
+    // Failed to retrieve the exchange rate due to invalid API calls, invalid timestamp, etc.
+    Err: ExchangeRateError;
+};
+
+service : {
+    "get_exchange_rate": (GetExchangeRateRequest) -> (GetExchangeRateResult);
+}

package/src/stable/lib/canisters/exchange_rate/idl/index.ts

@@ -0,0 +1,165 @@
+import { ActorMethod } from '@dfinity/agent';
+import { IDL } from '@dfinity/candid';
+
+export interface Asset {
+    class: AssetClass;
+    symbol: string;
+}
+export type AssetClass = { Cryptocurrency: null } | { FiatCurrency: null };
+export interface ExchangeRate {
+    metadata: ExchangeRateMetadata;
+    rate: bigint;
+    timestamp: bigint;
+    quote_asset: Asset;
+    base_asset: Asset;
+}
+export type ExchangeRateError =
+    | { AnonymousPrincipalNotAllowed: null }
+    | { CryptoQuoteAssetNotFound: null }
+    | { FailedToAcceptCycles: null }
+    | { ForexBaseAssetNotFound: null }
+    | { CryptoBaseAssetNotFound: null }
+    | { StablecoinRateTooFewRates: null }
+    | { ForexAssetsNotFound: null }
+    | { InconsistentRatesReceived: null }
+    | { RateLimited: null }
+    | { StablecoinRateZeroRate: null }
+    | { Other: { code: number; description: string } }
+    | { ForexInvalidTimestamp: null }
+    | { NotEnoughCycles: null }
+    | { ForexQuoteAssetNotFound: null }
+    | { StablecoinRateNotFound: null }
+    | { Pending: null };
+export interface ExchangeRateMetadata {
+    decimals: number;
+    forex_timestamp: [] | [bigint];
+    quote_asset_num_received_rates: bigint;
+    base_asset_num_received_rates: bigint;
+    base_asset_num_queried_sources: bigint;
+    standard_deviation: bigint;
+    quote_asset_num_queried_sources: bigint;
+}
+export interface GetExchangeRateRequest {
+    timestamp: [] | [bigint];
+    quote_asset: Asset;
+    base_asset: Asset;
+}
+export type GetExchangeRateResult =
+    | { Ok: ExchangeRate }
+    | { Err: ExchangeRateError };
+export interface _SERVICE {
+    get_exchange_rate: ActorMethod<
+        [GetExchangeRateRequest],
+        GetExchangeRateResult
+    >;
+}
+export type idlFactory = IDL.InterfaceFactory;
+export type init = (args: { IDL: typeof IDL }) => IDL.Type[];
+export const AssetClass = IDL.Variant({
+    Cryptocurrency: IDL.Null,
+    FiatCurrency: IDL.Null
+});
+export const Asset = IDL.Record({ class: AssetClass, symbol: IDL.Text });
+export const GetExchangeRateRequest = IDL.Record({
+    timestamp: IDL.Opt(IDL.Nat64),
+    quote_asset: Asset,
+    base_asset: Asset
+});
+export const ExchangeRateMetadata = IDL.Record({
+    decimals: IDL.Nat32,
+    forex_timestamp: IDL.Opt(IDL.Nat64),
+    quote_asset_num_received_rates: IDL.Nat64,
+    base_asset_num_received_rates: IDL.Nat64,
+    base_asset_num_queried_sources: IDL.Nat64,
+    standard_deviation: IDL.Nat64,
+    quote_asset_num_queried_sources: IDL.Nat64
+});
+export const ExchangeRate = IDL.Record({
+    metadata: ExchangeRateMetadata,
+    rate: IDL.Nat64,
+    timestamp: IDL.Nat64,
+    quote_asset: Asset,
+    base_asset: Asset
+});
+export const ExchangeRateError = IDL.Variant({
+    AnonymousPrincipalNotAllowed: IDL.Null,
+    CryptoQuoteAssetNotFound: IDL.Null,
+    FailedToAcceptCycles: IDL.Null,
+    ForexBaseAssetNotFound: IDL.Null,
+    CryptoBaseAssetNotFound: IDL.Null,
+    StablecoinRateTooFewRates: IDL.Null,
+    ForexAssetsNotFound: IDL.Null,
+    InconsistentRatesReceived: IDL.Null,
+    RateLimited: IDL.Null,
+    StablecoinRateZeroRate: IDL.Null,
+    Other: IDL.Record({ code: IDL.Nat32, description: IDL.Text }),
+    ForexInvalidTimestamp: IDL.Null,
+    NotEnoughCycles: IDL.Null,
+    ForexQuoteAssetNotFound: IDL.Null,
+    StablecoinRateNotFound: IDL.Null,
+    Pending: IDL.Null
+});
+export const GetExchangeRateResult = IDL.Variant({
+    Ok: ExchangeRate,
+    Err: ExchangeRateError
+});
+export const idlFactory: idlFactory = ({ IDL }) => {
+    const AssetClass = IDL.Variant({
+        Cryptocurrency: IDL.Null,
+        FiatCurrency: IDL.Null
+    });
+    const Asset = IDL.Record({ class: AssetClass, symbol: IDL.Text });
+    const GetExchangeRateRequest = IDL.Record({
+        timestamp: IDL.Opt(IDL.Nat64),
+        quote_asset: Asset,
+        base_asset: Asset
+    });
+    const ExchangeRateMetadata = IDL.Record({
+        decimals: IDL.Nat32,
+        forex_timestamp: IDL.Opt(IDL.Nat64),
+        quote_asset_num_received_rates: IDL.Nat64,
+        base_asset_num_received_rates: IDL.Nat64,
+        base_asset_num_queried_sources: IDL.Nat64,
+        standard_deviation: IDL.Nat64,
+        quote_asset_num_queried_sources: IDL.Nat64
+    });
+    const ExchangeRate = IDL.Record({
+        metadata: ExchangeRateMetadata,
+        rate: IDL.Nat64,
+        timestamp: IDL.Nat64,
+        quote_asset: Asset,
+        base_asset: Asset
+    });
+    const ExchangeRateError = IDL.Variant({
+        AnonymousPrincipalNotAllowed: IDL.Null,
+        CryptoQuoteAssetNotFound: IDL.Null,
+        FailedToAcceptCycles: IDL.Null,
+        ForexBaseAssetNotFound: IDL.Null,
+        CryptoBaseAssetNotFound: IDL.Null,
+        StablecoinRateTooFewRates: IDL.Null,
+        ForexAssetsNotFound: IDL.Null,
+        InconsistentRatesReceived: IDL.Null,
+        RateLimited: IDL.Null,
+        StablecoinRateZeroRate: IDL.Null,
+        Other: IDL.Record({ code: IDL.Nat32, description: IDL.Text }),
+        ForexInvalidTimestamp: IDL.Null,
+        NotEnoughCycles: IDL.Null,
+        ForexQuoteAssetNotFound: IDL.Null,
+        StablecoinRateNotFound: IDL.Null,
+        Pending: IDL.Null
+    });
+    const GetExchangeRateResult = IDL.Variant({
+        Ok: ExchangeRate,
+        Err: ExchangeRateError
+    });
+    return IDL.Service({
+        get_exchange_rate: IDL.Func(
+            [GetExchangeRateRequest],
+            [GetExchangeRateResult],
+            []
+        )
+    });
+};
+export const init: init = () => {
+    return [];
+};

package/src/stable/lib/canisters/http_gateway/idl/README.md

@@ -0,0 +1,9 @@
+- `ic.did` manual Candid source: https://github.com/dfinity/portal/blob/440f74a06a813842f54720e00e938512238f5bce/docs/references/_attachments/http-gateway.did
+- Licensing is assumed to be that described in ../../NOTICE
+
+# How to update the IDL and TypeScript types
+
+1. Go to the URL above, but at the latest commit
+2. Find the Candid on that page and copy it
+3. Paste the Candid into `http-gateway.did`
+4. From this directory run `npx azle generate http-gateway.did > index.ts`

package/src/stable/lib/canisters/http_gateway/idl/http-gateway.did

@@ -0,0 +1,49 @@
+type HeaderField = record { text; text; };
+
+type HttpRequest = record {
+  method: text;
+  url: text;
+  headers: vec HeaderField;
+  body: blob;
+  certificate_version: opt nat16;
+};
+
+type HttpUpdateRequest = record {
+  method: text;
+  url: text;
+  headers: vec HeaderField;
+  body: blob;
+};
+
+type HttpResponse = record {
+  status_code: nat16;
+  headers: vec HeaderField;
+  body: blob;
+  upgrade : opt bool;
+  streaming_strategy: opt StreamingStrategy;
+};
+
+// Each canister that uses the streaming feature gets to choose their concrete
+// type; the HTTP Gateway will treat it as an opaque value that is only fed to
+// the callback method
+
+type StreamingToken = record {
+  // application-specific type
+};
+
+type StreamingCallbackHttpResponse = record {
+  body: blob;
+  token: opt StreamingToken;
+};
+
+type StreamingStrategy = variant {
+  Callback: record {
+    callback: func (StreamingToken) -> (opt StreamingCallbackHttpResponse) query;
+    token: StreamingToken;
+  };
+};
+
+service : {
+  http_request: (request: HttpRequest) -> (HttpResponse) query;
+  http_request_update: (request: HttpUpdateRequest) -> (HttpResponse);
+}

package/src/stable/lib/canisters/http_gateway/idl/index.ts

@@ -0,0 +1,120 @@
+import { ActorMethod } from '@dfinity/agent';
+import { IDL } from '@dfinity/candid';
+import { Principal } from '@dfinity/principal';
+
+export type HeaderField = [string, string];
+export interface HttpRequest {
+    url: string;
+    method: string;
+    body: Uint8Array | number[];
+    headers: Array<HeaderField>;
+    certificate_version: [] | [number];
+}
+export interface HttpResponse {
+    body: Uint8Array | number[];
+    headers: Array<HeaderField>;
+    upgrade: [] | [boolean];
+    streaming_strategy: [] | [StreamingStrategy];
+    status_code: number;
+}
+export interface HttpUpdateRequest {
+    url: string;
+    method: string;
+    body: Uint8Array | number[];
+    headers: Array<HeaderField>;
+}
+export interface StreamingCallbackHttpResponse {
+    token: [] | [StreamingToken];
+    body: Uint8Array | number[];
+}
+export type StreamingStrategy = {
+    Callback: { token: StreamingToken; callback: [Principal, string] };
+};
+export type StreamingToken = {};
+export interface _SERVICE {
+    http_request: ActorMethod<[HttpRequest], HttpResponse>;
+    http_request_update: ActorMethod<[HttpUpdateRequest], HttpResponse>;
+}
+export type idlFactory = IDL.InterfaceFactory;
+export type init = (args: { IDL: typeof IDL }) => IDL.Type[];
+export const HeaderField = IDL.Tuple(IDL.Text, IDL.Text);
+export const HttpRequest = IDL.Record({
+    url: IDL.Text,
+    method: IDL.Text,
+    body: IDL.Vec(IDL.Nat8),
+    headers: IDL.Vec(HeaderField),
+    certificate_version: IDL.Opt(IDL.Nat16)
+});
+export const StreamingToken = IDL.Record({});
+export const StreamingCallbackHttpResponse = IDL.Record({
+    token: IDL.Opt(StreamingToken),
+    body: IDL.Vec(IDL.Nat8)
+});
+export const StreamingStrategy = IDL.Variant({
+    Callback: IDL.Record({
+        token: StreamingToken,
+        callback: IDL.Func(
+            [StreamingToken],
+            [IDL.Opt(StreamingCallbackHttpResponse)],
+            ['query']
+        )
+    })
+});
+export const HttpResponse = IDL.Record({
+    body: IDL.Vec(IDL.Nat8),
+    headers: IDL.Vec(HeaderField),
+    upgrade: IDL.Opt(IDL.Bool),
+    streaming_strategy: IDL.Opt(StreamingStrategy),
+    status_code: IDL.Nat16
+});
+export const HttpUpdateRequest = IDL.Record({
+    url: IDL.Text,
+    method: IDL.Text,
+    body: IDL.Vec(IDL.Nat8),
+    headers: IDL.Vec(HeaderField)
+});
+export const idlFactory: idlFactory = ({ IDL }) => {
+    const HeaderField = IDL.Tuple(IDL.Text, IDL.Text);
+    const HttpRequest = IDL.Record({
+        url: IDL.Text,
+        method: IDL.Text,
+        body: IDL.Vec(IDL.Nat8),
+        headers: IDL.Vec(HeaderField),
+        certificate_version: IDL.Opt(IDL.Nat16)
+    });
+    const StreamingToken = IDL.Record({});
+    const StreamingCallbackHttpResponse = IDL.Record({
+        token: IDL.Opt(StreamingToken),
+        body: IDL.Vec(IDL.Nat8)
+    });
+    const StreamingStrategy = IDL.Variant({
+        Callback: IDL.Record({
+            token: StreamingToken,
+            callback: IDL.Func(
+                [StreamingToken],
+                [IDL.Opt(StreamingCallbackHttpResponse)],
+                ['query']
+            )
+        })
+    });
+    const HttpResponse = IDL.Record({
+        body: IDL.Vec(IDL.Nat8),
+        headers: IDL.Vec(HeaderField),
+        upgrade: IDL.Opt(IDL.Bool),
+        streaming_strategy: IDL.Opt(StreamingStrategy),
+        status_code: IDL.Nat16
+    });
+    const HttpUpdateRequest = IDL.Record({
+        url: IDL.Text,
+        method: IDL.Text,
+        body: IDL.Vec(IDL.Nat8),
+        headers: IDL.Vec(HeaderField)
+    });
+    return IDL.Service({
+        http_request: IDL.Func([HttpRequest], [HttpResponse], ['query']),
+        http_request_update: IDL.Func([HttpUpdateRequest], [HttpResponse], [])
+    });
+};
+export const init: init = () => {
+    return [];
+};

package/src/stable/lib/canisters/icrc_1/idl/ICRC-1.did

@@ -0,0 +1,63 @@
+// Taken from: https://github.com/dfinity/ICRC-1/blob/effeeaa89d8dd75ce3b2215b9c36eed98dafb7a8/standards/ICRC-1/ICRC-1.did
+
+// Number of nanoseconds since the UNIX epoch in UTC timezone.
+type Timestamp = nat64;
+
+// Number of nanoseconds between two [Timestamp]s.
+type Duration = nat64;
+
+type Subaccount = blob;
+
+type Account = record {
+    owner : principal;
+    subaccount : opt Subaccount;
+};
+
+type TransferArgs = record {
+    from_subaccount : opt Subaccount;
+    to : Account;
+    amount : nat;
+    fee : opt nat;
+    memo : opt blob;
+    created_at_time : opt Timestamp;
+};
+
+// TODO added by Demergent Labs, would be nice to upstream or automate
+type TransferResult = variant { Ok : nat; Err : TransferError };
+
+type TransferError = variant {
+    BadFee : record { expected_fee : nat };
+    BadBurn : record { min_burn_amount : nat };
+    InsufficientFunds : record { balance : nat };
+    TooOld;
+    CreatedInFuture: record { ledger_time : Timestamp };
+    Duplicate : record { duplicate_of : nat };
+    TemporarilyUnavailable;
+    GenericError : record { error_code : nat; message : text };
+};
+
+type Value = variant {
+    Nat : nat;
+    Int : int;
+    Text : text;
+    Blob : blob;
+};
+
+// TODO added by Demergent Labs, would be nice to upstream or automate
+type Metadatum = record { text; Value; };
+
+// TODO added by Demergent Labs, would be nice to upstream or automate
+type SupportedStandard = record { name : text; url : text };
+
+service : {
+    icrc1_metadata : () -> (vec Metadatum) query;
+    icrc1_name : () -> (text) query;
+    icrc1_symbol : () -> (text) query;
+    icrc1_decimals : () -> (nat8) query;
+    icrc1_fee : () -> (nat) query;
+    icrc1_total_supply : () -> (nat) query;
+    icrc1_minting_account : () -> (opt Account) query;
+    icrc1_balance_of : (Account) -> (nat) query;
+    icrc1_transfer : (TransferArgs) -> (TransferResult);
+    icrc1_supported_standards : () -> (vec SupportedStandard) query;
+}