koilib 2.6.1 → 3.0.0

package/lib/browser/interface.d.ts

@@ -1,4 +1,5 @@
 import { INamespace } from "protobufjs/light";
+import { Serializer } from "./Serializer";
 /**
  * Application Binary Interface (ABI)
  *
@@ -110,12 +111,114 @@ export interface DecodedOperationJson {
     /** Arguments decoded. See [[Abi]] */
     args?: Record<string, unknown>;
 }
-export interface TransactionOptions {
-    rc_limit?: number | bigint | string;
-    nonce?: number;
+export interface BaseTransactionOptions {
+    /**
+     * Chain ID
+     *
+     * If this option is not set it will be taken
+     * by querying the blockchain
+     */
+    chainId?: string;
+    /**
+     * Resource Credits limit
+     *
+     * Max amount of mana to be spent. If this option
+     * is not set it will be taken by querying the
+     * actual mana of the payer
+     */
+    rcLimit?: string;
+    /**
+     * Transaction nonce
+     *
+     * It can be the nonce of the payee or the nonce of the
+     * payer. Use the payee's nonce when the payer's nonce changes
+     * continuosly without your control, for instance, when the
+     * payer is a dApp.
+     *
+     * The nonce is not required to be consecutive,
+     * only greater than the previous one.
+     *
+     * If this option is not set it will be taken
+     * from the blockchain depending on the payer/payee
+     * configuration.
+     */
+    nonce?: string;
+    /**
+     * Payer
+     *
+     * Address that will pay the resource credits (aka mana)
+     * consumed in the transaction.
+     *
+     * If this option is not set it will take the address
+     * of the signer as payer.
+     */
+    payer?: string;
+    /**
+     * Payee
+     *
+     * Address that increases the nonce. When this option is
+     * not set the blockchain will increase the payer's nonce.
+     */
+    payee?: string;
+    /**
+     * Sign transaction
+     *
+     * Boolean to define if the transaction should be signed.
+     * By default it is true.
+     */
+    signTransaction?: boolean;
+    /**
+     * Send transaction
+     *
+     * Boolean to define if the transaction should be signed
+     * ans broadcasted to the blockchain. By default it is
+     * true.
+     */
     sendTransaction?: boolean;
+}
+export interface TransactionOptions extends BaseTransactionOptions {
+    /**
+     * Send abis
+     *
+     * Boolean to define if the abis should be shared with
+     * the signer so it will be able to decode the operations.
+     * By default it is true.
+     */
     sendAbis?: boolean;
 }
+export interface DeployOptions extends BaseTransactionOptions {
+    /**
+     * ABI
+     *
+     * ABI to be stored in the koinos-contract-meta-store.
+     * This option is optional.
+     */
+    abi?: string;
+    /**
+     * Authorizes call contract
+     *
+     * Set it true if the contract implements the "authorize"
+     * function and can authorize calling other contracts in
+     * its name.
+     */
+    authorizesCallContract?: boolean;
+    /**
+     * Authorizes transaction application
+     *
+     * Set it true if the contract implements the "authorize"
+     * function and can authorize paying the mana to apply
+     * transactions, or can authorize the use of its nonce
+     * to apply transactions.
+     */
+    authorizesTransactionApplication?: boolean;
+    /**
+     * Authorizes upload contract
+     *
+     * Set it true if the contract implements the "authorize"
+     * function and can authorize upgrades of the actual contract
+     */
+    authorizesUploadContract?: boolean;
+}
 export interface RecoverPublicKeyOptions {
     /**
      * Boolean to define if the public key should
@@ -132,44 +235,71 @@ export interface RecoverPublicKeyOptions {
      */
     transformSignature?: (signatureData: string) => Promise<string>;
 }
-export interface SendTransactionResponse {
-    /**
-     * Function to wait for a transaction to be mined.
-     * This function comes as a response after sending a transaction.
-     * See [[Provider.sendTransaction]]
-     *
-     * @param type - Type must be "byBlock" (default) or "byTransactionId".
-     * _byBlock_ will query the blockchain to get blocks and search for the
-     * transaction there. _byTransactionId_ will query the "transaction store"
-     * microservice to search the transaction by its id. If non of them is
-     * specified the function will use "byBlock" (as "byTransactionId"
-     * requires the transaction store, which is an optional microservice).
-     *
-     * When _byBlock_ is used it returns the block number.
-     *
-     * When _byTransactionId_ is used it returns the block id.
-     *
-     * @param timeout - Timeout in milliseconds. By default it is 30000
-     */
-    wait: (type?: "byBlock" | "byTransactionId", timeout?: number) => Promise<string | number>;
+/**
+ * Function to wait for a transaction to be mined.
+ * This function comes as a response after sending a transaction.
+ * See [[Provider.sendTransaction]]
+ *
+ * @param type - Type must be "byBlock" (default) or "byTransactionId".
+ * _byBlock_ will query the blockchain to get blocks and search for the
+ * transaction there. _byTransactionId_ will query the "transaction store"
+ * microservice to search the transaction by its id. If non of them is
+ * specified the function will use "byBlock" (as "byTransactionId"
+ * requires the transaction store, which is an optional microservice).
+ *
+ * When _byBlock_ is used it returns the block number.
+ *
+ * When _byTransactionId_ is used it returns the block id.
+ *
+ * @param timeout - Timeout in milliseconds. By default it is 30000
+ */
+export declare type WaitFunction = (type?: "byBlock" | "byTransactionId", timeout?: number) => Promise<string | number>;
+export interface GenesisDataEntryEncoded {
+    space: {
+        system?: boolean;
+        zone?: string;
+        id?: number;
+    };
+    key?: string;
+    value: string;
+    error?: string;
 }
-export interface UploadContractOperation {
-    contract_id?: Uint8Array;
-    bytecode?: Uint8Array;
+export interface GenesisDataEncoded {
+    entries?: GenesisDataEntryEncoded[];
 }
-export interface UploadContractOperationJson {
-    contract_id?: string;
-    bytecode?: string;
+export interface GenesisDataEntryDecoded {
+    space: {
+        system?: boolean;
+        zone?: string;
+        id?: number;
+    };
+    key?: string;
+    alias?: string;
+    value: string | Record<string, unknown>;
+    error?: string;
 }
-export interface CallContractOperation {
-    contract_id: Uint8Array;
-    entry_point: number;
-    args: Uint8Array;
+export interface GenesisDataDecoded {
+    entries?: GenesisDataEntryDecoded[];
 }
-export interface CallContractOperationJson {
-    contract_id: string;
-    entry_point: number;
-    args: string;
+export interface DictionaryGenesisData {
+    /** key name */
+    [x: string]: {
+        /** alternative name for the key name */
+        alias?: string;
+        /** boolean defining if it's an address */
+        isAddress?: boolean;
+        /** custom serializer */
+        serializer?: Serializer;
+        /** type name for serialization */
+        typeName?: string;
+        /** preformat bytes for base64url, base58 or hex string */
+        bytesConversion?: boolean;
+    };
+}
+export interface TypeField {
+    type: string;
+    btype?: string;
+    subtypes?: Record<string, TypeField>;
 }
 export interface ContractCallBundle {
     contract_id: Uint8Array;
@@ -186,13 +316,51 @@ export interface ContractCallBundleNested {
     system_call_bundle: ContractCallBundle;
 }
 export declare type SystemCallTarget = ThunkIdNested | ContractCallBundleNested;
+export interface SystemCallTargetJson {
+    thunk_id?: number;
+    system_call_bundle?: ContractCallBundleJson;
+}
+export interface UploadContractOperation {
+    contract_id?: Uint8Array;
+    bytecode?: Uint8Array;
+    abi?: string;
+    authorizes_call_contract?: boolean;
+    authorizes_transaction_application?: boolean;
+    authorizes_upload_contract?: boolean;
+}
+export interface UploadContractOperationJson {
+    contract_id?: string;
+    bytecode?: string;
+    abi?: string;
+    authorizes_call_contract?: boolean;
+    authorizes_transaction_application?: boolean;
+    authorizes_upload_contract?: boolean;
+}
+export interface CallContractOperation {
+    contract_id: Uint8Array;
+    entry_point: number;
+    args: Uint8Array;
+}
+export interface CallContractOperationJson {
+    contract_id: string;
+    entry_point: number;
+    args: string;
+}
 export interface SetSystemCallOperation {
     call_id: number;
     target: SystemCallTarget;
 }
 export interface SetSystemCallOperationJson {
     call_id: number;
-    target: number | ContractCallBundleJson;
+    target: SystemCallTargetJson;
+}
+export interface SetSystemContractOperation {
+    contract_id: Uint8Array;
+    system_contract: boolean;
+}
+export interface SetSystemContractOperationJson {
+    contract_id: string;
+    system_contract: boolean;
 }
 export interface UploadContractOperationNested {
     upload_contract: UploadContractOperation;
@@ -203,40 +371,41 @@ export interface CallContractOperationNested {
 export interface SetSystemCallOperationNested {
     set_system_call: SetSystemCallOperation;
 }
-export declare type Operation = UploadContractOperationNested | CallContractOperationNested | SetSystemCallOperationNested;
+export interface SetSystemContractOperationNested {
+    set_system_contract: SetSystemContractOperation;
+}
+export declare type Operation = UploadContractOperationNested | CallContractOperationNested | SetSystemCallOperationNested | SetSystemContractOperationNested;
 export declare type OperationJson = {
     upload_contract?: UploadContractOperationJson;
     call_contract?: CallContractOperationJson;
     set_system_call?: SetSystemCallOperationJson;
+    set_system_contract?: SetSystemContractOperationJson;
 };
-export interface ActiveTransactionData {
+export interface TransactionHeaderJson {
     /**
-     * Resource credits limit
+     * ID of the chain
      */
-    rc_limit?: string | number | bigint;
+    chain_id?: string;
     /**
-     * Account nonce
+     * Resource credits limit
      */
-    nonce?: string | number | bigint;
+    rc_limit?: string;
     /**
-     * Array of operations
+     * Account nonce
      */
-    operations?: Operation[];
-    [x: string]: unknown;
-}
-export interface ActiveTransactionDataJson {
+    nonce?: string;
     /**
-     * Resource credits limit
+     * Merkle root of the serialized operations's SHA2-256 hashes
      */
-    rc_limit?: string | number | bigint;
+    operation_merkle_root?: string;
     /**
-     * Account nonce
+     * Transaction's payer
      */
-    nonce?: string | number | bigint;
+    payer?: string;
     /**
-     * Array of operations
+     * Transaction's payee
      */
-    operations?: OperationJson[];
+    payee?: string;
     [x: string]: unknown;
 }
 /**
@@ -245,34 +414,42 @@ export interface ActiveTransactionDataJson {
 export interface TransactionJson {
     /**
      * Transaction ID. It must be the sha2-256 of the
-     * serialized data of active data, and encoded in multi base58
+     * serialized header of the transaction
      */
     id?: string;
     /**
-     * Consensus data
+     * Header of the transaction
      */
-    active?: string;
+    header?: TransactionHeaderJson;
     /**
-     * Non-consensus data
+     * Array of operations
      */
-    passive?: string;
+    operations?: OperationJson[];
     /**
-     * Signature in compact format enconded in multi base64
+     * Signatures in compact format
      */
-    signature_data?: string;
+    signatures?: string[];
+}
+export interface TransactionJsonWait extends TransactionJson {
+    wait: WaitFunction;
 }
 export interface BlockHeaderJson {
     previous?: string;
     height?: string;
     timestamp?: string;
+    previous_state_merkle_root?: string;
+    transaction_merkle_root?: string;
+    signer?: string;
     [x: string]: unknown;
 }
 export interface BlockJson {
     id?: string;
     header?: BlockHeaderJson;
-    active?: string;
-    passive?: string;
-    signature_data?: string;
     transactions?: TransactionJson[];
+    signature?: string;
+    [x: string]: unknown;
+}
+export interface ValueType {
+    uint64_value?: string;
     [x: string]: unknown;
 }