@ohos-ports/azle 0.33.0-beta.0

package/src/stable/lib/canister_methods/query.ts

@@ -0,0 +1,69 @@
+import { IDL } from '@dfinity/candid';
+
+import {
+    Context,
+    decoratorArgumentsHandler,
+    DecoratorFunction,
+    OriginalMethod
+} from '.';
+
+export type QueryOptions = {
+    composite?: boolean;
+    manual?: boolean;
+    hidden?: boolean;
+};
+
+/**
+ * Decorator to mark a method as a `query` call entry point.
+ *
+ * @remarks
+ *
+ * - **State**: read-only
+ *
+ * - **Replication**: possible
+ *
+ * - **Async**: yes with `composite` set to true
+ *
+ * - **Instruction limit**: [5_000_000_000](https://internetcomputer.org/docs/current/developer-docs/smart-contracts/maintain/resource-limits)
+ *
+ */
+export function query<This, Args extends unknown[], Return>(
+    originalMethod: OriginalMethod<This, Args, Return>,
+    context: Context<This, Args, Return>
+): void;
+
+/**
+ * Decorator to mark a method as a `query` call entry point.
+ *
+ * @param paramIdlTypes - Optional array of Candid IDL types for the decorated method parameters. The runtime arguments will be decoded using these types
+ * @param returnIdlType - Optional Candid IDL type for the decorated method return value. The runtime return value will be encoded using this type
+ * @param options - Optional configuration object
+ * @param options.composite - Optional flag to indicate that the decorated method should be treated as a composite query method capable of some cross-canister query calls
+ * @param options.manual - Optional flag to indicate manual handling of the decorated method's runtime arguments and return value. This is meant to be used with `msgArgData` and `IDL.decode` for arguments, and `msgReply`/`msgReject` and `IDL.encode` for the return value, skipping automatic Candid decoding of the runtime arguments and encoding of the runtime return value
+ * @param options.hidden - Optional flag to indicate that the decorated method should be hidden from the canister's Candid interface
+ *
+ * @remarks
+ *
+ * - **State**: read-only
+ *
+ * - **Replication**: possible
+ *
+ * - **Async**: yes with `composite` set to true
+ *
+ * - **Instruction limit**: [5_000_000_000](https://internetcomputer.org/docs/current/developer-docs/smart-contracts/maintain/resource-limits)
+ *
+ * See [more documentation](https://internetcomputer.org/docs/current/references/ic-interface-spec#http-query).
+ */
+export function query<This, Args extends unknown[], Return>(
+    paramIdlTypes?: IDL.Type[],
+    returnIdlType?: IDL.Type,
+    options?: QueryOptions
+): DecoratorFunction<This, Args, Return>;
+
+export function query<This, Args extends unknown[], Return>(
+    param1?: OriginalMethod<This, Args, Return> | IDL.Type[],
+    param2?: Context<This, Args, Return> | IDL.Type,
+    param3?: QueryOptions
+): void | DecoratorFunction<This, Args, Return> {
+    return decoratorArgumentsHandler('query', param1, param2, param3);
+}

package/src/stable/lib/canister_methods/update.ts

@@ -0,0 +1,66 @@
+import { IDL } from '@dfinity/candid';
+
+import {
+    Context,
+    decoratorArgumentsHandler,
+    DecoratorFunction,
+    OriginalMethod
+} from '.';
+
+export type UpdateOptions = {
+    manual?: boolean;
+    hidden?: boolean;
+};
+
+/**
+ * Decorator to mark a method as an `update` call entry point.
+ *
+ * @remarks
+ *
+ * - **State**: read-write
+ *
+ * - **Replication**: yes
+ *
+ * - **Async**: yes
+ *
+ * - **Instruction limit**: [40_000_000_000](https://internetcomputer.org/docs/current/developer-docs/smart-contracts/maintain/resource-limits)
+ *
+ */
+export function update<This, Args extends unknown[], Return>(
+    originalMethod: OriginalMethod<This, Args, Return>,
+    context: Context<This, Args, Return>
+): void;
+
+/**
+ * Decorator to mark a method as an `update` call entry point.
+ *
+ * @param paramIdlTypes - Optional array of Candid IDL types for the decorated method parameters. The runtime arguments will be decoded using these types
+ * @param returnIdlType - Optional Candid IDL type for the decorated method return value. The runtime return value will be encoded using this type
+ * @param options - Optional configuration object
+ * @param options.manual - Optional flag to indicate manual handling of the decorated method's runtime arguments and return value. This is meant to be used with `msgArgData` and `IDL.decode` for arguments, and `msgReply`/`msgReject` and `IDL.encode` for the return value, skipping automatic Candid decoding of the runtime arguments and encoding of the runtime return value
+ * @param options.hidden - Optional flag to indicate that the method should be hidden from the canister's Candid interface
+ * @remarks
+ *
+ * - **State**: read-write
+ *
+ * - **Replication**: yes
+ *
+ * - **Async**: yes
+ *
+ * - **Instruction limit**: [40_000_000_000](https://internetcomputer.org/docs/current/developer-docs/smart-contracts/maintain/resource-limits)
+ *
+ * See [more documentation](https://internetcomputer.org/docs/current/references/ic-interface-spec#system-api-requests).
+ */
+export function update<This, Args extends unknown[], Return>(
+    paramIdlTypes?: IDL.Type[],
+    returnIdlType?: IDL.Type,
+    options?: UpdateOptions
+): DecoratorFunction<This, Args, Return>;
+
+export function update<This, Args extends unknown[], Return>(
+    param1?: OriginalMethod<This, Args, Return> | IDL.Type[],
+    param2?: Context<This, Args, Return> | IDL.Type,
+    param3?: UpdateOptions
+): void | DecoratorFunction<This, Args, Return> {
+    return decoratorArgumentsHandler('update', param1, param2, param3);
+}

package/src/stable/lib/canisters/NOTICE

@@ -0,0 +1,15 @@
+Copyright 2021 DFINITY Stiftung
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at
+
+   http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.
+
+The original license for the DFINITY code can be found here: https://github.com/dfinity/ic/blob/master/LICENSE
+This project contains derivative works licensed as MIT: https://github.com/demergent-labs/azle/blob/main/LICENSE

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

@@ -0,0 +1,9 @@
+- `index.did` manual Candid source: https://dashboard.internetcomputer.org/canister/mxzaz-hqaaa-aaaar-qaada-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/ck_btc_ledger/idl/index.did

@@ -0,0 +1,289 @@
+type Account = record { owner : principal; subaccount : opt blob };
+type Allowance = record { allowance : nat; expires_at : opt nat64 };
+type AllowanceArgs = record { account : Account; spender : Account };
+type Approve = record {
+  fee : opt nat;
+  from : Account;
+  memo : opt blob;
+  created_at_time : opt nat64;
+  amount : nat;
+  expected_allowance : opt nat;
+  expires_at : opt nat64;
+  spender : Account;
+};
+type ApproveArgs = record {
+  fee : opt nat;
+  memo : opt blob;
+  from_subaccount : opt blob;
+  created_at_time : opt nat64;
+  amount : nat;
+  expected_allowance : opt nat;
+  expires_at : opt nat64;
+  spender : Account;
+};
+type ApproveError = variant {
+  GenericError : record { message : text; error_code : nat };
+  TemporarilyUnavailable;
+  Duplicate : record { duplicate_of : nat };
+  BadFee : record { expected_fee : nat };
+  AllowanceChanged : record { current_allowance : nat };
+  CreatedInFuture : record { ledger_time : nat64 };
+  TooOld;
+  Expired : record { ledger_time : nat64 };
+  InsufficientFunds : record { balance : nat };
+};
+type ArchiveInfo = record {
+  block_range_end : nat;
+  canister_id : principal;
+  block_range_start : nat;
+};
+type ArchiveOptions = record {
+  num_blocks_to_archive : nat64;
+  max_transactions_per_response : opt nat64;
+  trigger_threshold : nat64;
+  more_controller_ids : opt vec principal;
+  max_message_size_bytes : opt nat64;
+  cycles_for_archive_creation : opt nat64;
+  node_max_memory_size_bytes : opt nat64;
+  controller_id : principal;
+};
+type ArchivedBlocks = record {
+  args : vec GetBlocksRequest;
+  callback : func (vec GetBlocksRequest) -> (GetBlocksResult) query;
+};
+type ArchivedRange = record {
+  callback : func (GetBlocksRequest) -> (BlockRange) query;
+  start : nat;
+  length : nat;
+};
+type ArchivedRange_1 = record {
+  callback : func (GetBlocksRequest) -> (TransactionRange) query;
+  start : nat;
+  length : nat;
+};
+type BlockRange = record { blocks : vec Value };
+type BlockWithId = record { id : nat; block : ICRC3Value };
+type Burn = record {
+  from : Account;
+  memo : opt blob;
+  created_at_time : opt nat64;
+  amount : nat;
+  spender : opt Account;
+};
+type ChangeArchiveOptions = record {
+  num_blocks_to_archive : opt nat64;
+  max_transactions_per_response : opt nat64;
+  trigger_threshold : opt nat64;
+  more_controller_ids : opt vec principal;
+  max_message_size_bytes : opt nat64;
+  cycles_for_archive_creation : opt nat64;
+  node_max_memory_size_bytes : opt nat64;
+  controller_id : opt principal;
+};
+type ChangeFeeCollector = variant { SetTo : Account; Unset };
+type ConsentInfo = record {
+  metadata : ConsentMessageMetadata;
+  consent_message : ConsentMessage;
+};
+type ConsentMessage = variant {
+  LineDisplayMessage : record { pages : vec LineDisplayPage };
+  GenericDisplayMessage : text;
+};
+type ConsentMessageMetadata = record {
+  utc_offset_minutes : opt int16;
+  language : text;
+};
+type ConsentMessageRequest = record {
+  arg : blob;
+  method : text;
+  user_preferences : ConsentMessageSpec;
+};
+type ConsentMessageSpec = record {
+  metadata : ConsentMessageMetadata;
+  device_spec : opt DisplayMessageType;
+};
+type DataCertificate = record { certificate : opt blob; hash_tree : blob };
+type DisplayMessageType = variant {
+  GenericDisplay;
+  LineDisplay : record { characters_per_line : nat16; lines_per_page : nat16 };
+};
+type ErrorInfo = record { description : text };
+type FeatureFlags = record { icrc2 : bool };
+type GetArchivesArgs = record { from : opt principal };
+type GetBlocksRequest = record { start : nat; length : nat };
+type GetBlocksResponse = record {
+  certificate : opt blob;
+  first_index : nat;
+  blocks : vec Value;
+  chain_length : nat64;
+  archived_blocks : vec ArchivedRange;
+};
+type GetBlocksResult = record {
+  log_length : nat;
+  blocks : vec BlockWithId;
+  archived_blocks : vec ArchivedBlocks;
+};
+type GetTransactionsResponse = record {
+  first_index : nat;
+  log_length : nat;
+  transactions : vec Transaction;
+  archived_transactions : vec ArchivedRange_1;
+};
+type ICRC3ArchiveInfo = record {
+  end : nat;
+  canister_id : principal;
+  start : nat;
+};
+type ICRC3DataCertificate = record { certificate : blob; hash_tree : blob };
+type ICRC3Value = variant {
+  Int : int;
+  Map : vec record { text; ICRC3Value };
+  Nat : nat;
+  Blob : blob;
+  Text : text;
+  Array : vec ICRC3Value;
+};
+type Icrc21Error = variant {
+  GenericError : record { description : text; error_code : nat };
+  InsufficientPayment : ErrorInfo;
+  UnsupportedCanisterCall : ErrorInfo;
+  ConsentMessageUnavailable : ErrorInfo;
+};
+type InitArgs = record {
+  decimals : opt nat8;
+  token_symbol : text;
+  transfer_fee : nat;
+  metadata : vec record { text; MetadataValue };
+  minting_account : Account;
+  initial_balances : vec record { Account; nat };
+  fee_collector_account : opt Account;
+  archive_options : ArchiveOptions;
+  max_memo_length : opt nat16;
+  token_name : text;
+  feature_flags : opt FeatureFlags;
+};
+type LedgerArgument = variant { Upgrade : opt UpgradeArgs; Init : InitArgs };
+type LineDisplayPage = record { lines : vec text };
+type MetadataValue = variant { Int : int; Nat : nat; Blob : blob; Text : text };
+type Mint = record {
+  to : Account;
+  memo : opt blob;
+  created_at_time : opt nat64;
+  amount : nat;
+};
+type Result = variant { Ok : nat; Err : TransferError };
+type Result_1 = variant { Ok : ConsentInfo; Err : Icrc21Error };
+type Result_2 = variant { Ok : nat; Err : ApproveError };
+type Result_3 = variant { Ok : nat; Err : TransferFromError };
+type StandardRecord = record { url : text; name : text };
+type SupportedBlockType = record { url : text; block_type : text };
+type Transaction = record {
+  burn : opt Burn;
+  kind : text;
+  mint : opt Mint;
+  approve : opt Approve;
+  timestamp : nat64;
+  transfer : opt Transfer;
+};
+type TransactionRange = record { transactions : vec Transaction };
+type Transfer = record {
+  to : Account;
+  fee : opt nat;
+  from : Account;
+  memo : opt blob;
+  created_at_time : opt nat64;
+  amount : nat;
+  spender : opt Account;
+};
+type TransferArg = record {
+  to : Account;
+  fee : opt nat;
+  memo : opt blob;
+  from_subaccount : opt blob;
+  created_at_time : opt nat64;
+  amount : nat;
+};
+type TransferError = variant {
+  GenericError : record { message : text; error_code : nat };
+  TemporarilyUnavailable;
+  BadBurn : record { min_burn_amount : nat };
+  Duplicate : record { duplicate_of : nat };
+  BadFee : record { expected_fee : nat };
+  CreatedInFuture : record { ledger_time : nat64 };
+  TooOld;
+  InsufficientFunds : record { balance : nat };
+};
+type TransferFromArgs = record {
+  to : Account;
+  fee : opt nat;
+  spender_subaccount : opt blob;
+  from : Account;
+  memo : opt blob;
+  created_at_time : opt nat64;
+  amount : nat;
+};
+type TransferFromError = variant {
+  GenericError : record { message : text; error_code : nat };
+  TemporarilyUnavailable;
+  InsufficientAllowance : record { allowance : nat };
+  BadBurn : record { min_burn_amount : nat };
+  Duplicate : record { duplicate_of : nat };
+  BadFee : record { expected_fee : nat };
+  CreatedInFuture : record { ledger_time : nat64 };
+  TooOld;
+  InsufficientFunds : record { balance : nat };
+};
+type UpgradeArgs = record {
+  change_archive_options : opt ChangeArchiveOptions;
+  token_symbol : opt text;
+  transfer_fee : opt nat;
+  metadata : opt vec record { text; MetadataValue };
+  change_fee_collector : opt ChangeFeeCollector;
+  max_memo_length : opt nat16;
+  token_name : opt text;
+  feature_flags : opt FeatureFlags;
+};
+type Value = variant {
+  Int : int;
+  Map : vec record { text; Value };
+  Nat : nat;
+  Nat64 : nat64;
+  Blob : blob;
+  Text : text;
+  Array : Vec;
+};
+type Vec = vec variant {
+  Int : int;
+  Map : vec record { text; Value };
+  Nat : nat;
+  Nat64 : nat64;
+  Blob : blob;
+  Text : text;
+  Array : Vec;
+};
+service : (LedgerArgument) -> {
+  archives : () -> (vec ArchiveInfo) query;
+  get_blocks : (GetBlocksRequest) -> (GetBlocksResponse) query;
+  get_data_certificate : () -> (DataCertificate) query;
+  get_transactions : (GetBlocksRequest) -> (GetTransactionsResponse) query;
+  icrc10_supported_standards : () -> (vec StandardRecord) query;
+  icrc1_balance_of : (Account) -> (nat) query;
+  icrc1_decimals : () -> (nat8) query;
+  icrc1_fee : () -> (nat) query;
+  icrc1_metadata : () -> (vec record { text; MetadataValue }) query;
+  icrc1_minting_account : () -> (opt Account) query;
+  icrc1_name : () -> (text) query;
+  icrc1_supported_standards : () -> (vec StandardRecord) query;
+  icrc1_symbol : () -> (text) query;
+  icrc1_total_supply : () -> (nat) query;
+  icrc1_transfer : (TransferArg) -> (Result);
+  icrc21_canister_call_consent_message : (ConsentMessageRequest) -> (Result_1);
+  icrc2_allowance : (AllowanceArgs) -> (Allowance) query;
+  icrc2_approve : (ApproveArgs) -> (Result_2);
+  icrc2_transfer_from : (TransferFromArgs) -> (Result_3);
+  icrc3_get_archives : (GetArchivesArgs) -> (vec ICRC3ArchiveInfo) query;
+  icrc3_get_blocks : (vec GetBlocksRequest) -> (GetBlocksResult) query;
+  icrc3_get_tip_certificate : () -> (opt ICRC3DataCertificate) query;
+  icrc3_supported_block_types : () -> (vec SupportedBlockType) query;
+  is_ledger_ready : () -> (bool) query;
+}