@aeternity/aepp-sdk 13.2.2 → 13.3.0

package/types-legacy/ts4.2/chain.d.ts

@@ -1,43 +1,40 @@
 import { AE_AMOUNT_FORMATS } from './utils/amount-formatter';
-import { ValidatorResult } from './tx/validator';
 import { AensName } from './tx/builder/constants';
-import { TransactionError } from './utils/errors';
 import Node, { TransformNodeType } from './Node';
 import { Account as AccountNode, ByteCode, ContractObject, DryRunResult, DryRunResults, Generation, KeyBlock, MicroBlockHeader, NameEntry, SignedTx } from './apis/node';
 import { Encoded, Encoding } from './utils/encoder';
-import AccountBase from './account/Base';
 /**
  * @category chain
+ * @param type - Type
+ * @param options - Options
  */
 export declare function _getPollInterval(type: 'block' | 'microblock', // TODO: rename to 'key-block' | 'micro-block'
-{ _expectedMineRate, _microBlockCycle, _maxPollInterval }: {
+{ _expectedMineRate, _microBlockCycle }: {
     _expectedMineRate?: number;
     _microBlockCycle?: number;
-    _maxPollInterval?: number;
 }): number;
-/**
- * @category exception
- */
-export declare class InvalidTxError extends TransactionError {
-    validation: ValidatorResult[];
-    transaction: Encoded.Transaction;
-    constructor(message: string, validation: ValidatorResult[], transaction: Encoded.Transaction);
-}
 /**
  * Obtain current height of the chain
  * @category chain
+ * @param options - Options
+ * @param options.cached - Get height from the cache. The lag behind the actual height shouldn't
+ * be more than 1 block. Use if needed to reduce requests count, and approximate value can be used.
+ * For example, for timeout check in transaction status polling.
  * @returns Current chain height
  */
-export declare function getHeight({ onNode }: {
+export declare function getHeight({ cached, ...options }: {
     onNode: Node;
-}): Promise<number>;
+    cached?: boolean;
+} & Parameters<typeof _getPollInterval>[1]): Promise<number>;
 /**
- * Wait for a transaction to be mined
+ * Return transaction details if it is mined, fail otherwise.
+ * If the transaction has ttl specified then would wait till it leaves the mempool.
+ * Otherwise would fail if a specified amount of blocks were mined.
  * @category chain
  * @param th - The hash of transaction to poll
  * @param options - Options
  * @param options.interval - Interval (in ms) at which to poll the chain
- * @param options.blocks - Number of blocks mined after which to fail
+ * @param options.blocks - Number of blocks mined after which to fail if transaction ttl is not set
  * @param options.onNode - Node to use
  * @returns The transaction as it was mined
  */
@@ -72,33 +69,6 @@ export declare function waitForTxConfirm(txHash: Encoded.TxHash, { confirm, onNo
     confirm?: number;
     onNode: Node;
 } & Parameters<typeof awaitHeight>[1]): Promise<number>;
-/**
- * Signs and submits transaction for mining
- * @category chain
- * @param txUnsigned - Transaction to sign and submit
- * @param options - Options
- * @param options.onNode - Node to use
- * @param options.onAccount - Account to use
- * @param options.verify - Verify transaction before broadcast, throw error if not
- * @param options.waitMined - Ensure that transaction get into block
- * @param options.confirm - Number of micro blocks that should be mined after tx get included
- * @returns Transaction details
- */
-export declare function sendTransaction(txUnsigned: Encoded.Transaction, { onNode, onAccount, verify, waitMined, confirm, innerTx, ...options }: SendTransactionOptions): Promise<SendTransactionReturnType>;
-type SendTransactionOptionsType = {
-    onNode: Node;
-    onAccount: AccountBase;
-    verify?: boolean;
-    waitMined?: boolean;
-    confirm?: boolean | number;
-} & Parameters<typeof poll>[1] & Omit<Parameters<typeof waitForTxConfirm>[1], 'confirm'> & Parameters<AccountBase['signTransaction']>[1];
-export interface SendTransactionOptions extends SendTransactionOptionsType {
-}
-interface SendTransactionReturnType extends Partial<TransformNodeType<SignedTx>> {
-    hash: Encoded.TxHash;
-    rawTx: Encoded.Transaction;
-    confirmationHeight?: number;
-}
 /**
  * Get account by account public key
  * @category chain

package/types-legacy/ts4.2/channel/Base.d.ts

@@ -27,6 +27,7 @@ import { TxUnpacked } from '../tx/builder/schema.generated';
  * ```
  */
 export default class Channel {
+    #private;
     _eventEmitter: EventEmitter;
     _pingTimeoutId: NodeJS.Timeout;
     _nextRpcMessageId: number;
@@ -42,55 +43,10 @@ export default class Channel {
     _state: Encoded.Transaction | '';
     _options: ChannelOptions;
     _channelId?: Encoded.Channel;
+    protected constructor();
+    _debug(...args: any[]): void;
     /**
      * @param options - Channel params
-     * @param options.url - Channel url (for example: "ws://localhost:3001")
-     * @param options.role - Participant role ("initiator" or "responder")
-     * @param options.initiatorId - Initiator's public key
-     * @param options.responderId - Responder's public key
-     * @param options.pushAmount - Initial deposit in favour of the responder by the initiator
-     * @param options.initiatorAmount - Amount of coins the initiator has committed to
-     * the channel
-     * @param options.responderAmount - Amount of coins the responder has committed to
-     * the channel
-     * @param options.channelReserve - The minimum amount both peers need to maintain
-     * @param options.ttl - Minimum block height to include the channel_create_tx
-     * @param options.host - Host of the responder's node
-     * @param options.port - The port of the responders node
-     * @param options.lockPeriod - Amount of blocks for disputing a solo close
-     * @param options.minimumDepthStrategy - How to calculate minimum depth (default: txfee)
-     * @param options.minimumDepth - The minimum amount of blocks to be mined
-     * @param options.fee - The fee to be used for the channel open transaction
-     * @param options.gasPrice - Used for the fee computation of the channel open transaction
-     * @param options.existingChannelId - Existing channel id (required if reestablishing a
-     * channel)
-     * @param options.offchainTx - Offchain transaction (required if reestablishing
-     * a channel)
-     * @param options.timeoutIdle - The time waiting for a new event to be initiated
-     * (default: 600000)
-     * @param options.timeoutFundingCreate - The time waiting for the initiator to produce
-     * the create channel transaction after the noise session had been established (default: 120000)
-     * @param options.timeoutFundingSign - The time frame the other client has to sign an
-     * off-chain update after our client had initiated and signed it. This applies only for double
-     * signed on-chain intended updates: channel create transaction, deposit, withdrawal and etc.
-     * (default: 120000)
-     * @param options.timeoutFundingLock - The time frame the other client has to confirm an
-     * on-chain transaction reaching maturity (passing minimum depth) after the local node has
-     * detected this. This applies only for double signed on-chain intended updates: channel create
-     * transaction, deposit, withdrawal and etc. (default: 360000)
-     * @param options.timeoutSign - The time frame the client has to return a signed
-     * off-chain update or to decline it. This applies for all off-chain updates (default: 500000)
-     * @param options.timeoutAccept - The time frame the other client has to react to an
-     * event. This applies for all off-chain updates that are not meant to land on-chain, as well as
-     * some special cases: opening a noise connection, mutual closing acknowledgement and
-     * reestablishing an existing channel (default: 120000)
-     * @param options.timeoutInitialized - the time frame the responder has to accept an
-     * incoming noise session. Applicable only for initiator (default: timeout_accept's value)
-     * @param options.timeoutAwaitingOpen - The time frame the initiator has to start an
-     * outgoing noise session to the responder's node. Applicable only for responder (default:
-     * timeout_idle's value)
-     * @param options.debug=false - Log websocket communication
-     * @param options.sign - Function which verifies and signs transactions
      */
     static initialize(options: ChannelOptions): Promise<Channel>;
     static _initialize<T extends Channel>(channel: T, options: ChannelOptions): Promise<T>;

package/types-legacy/ts4.2/channel/Contract.d.ts

@@ -6,10 +6,24 @@ import { ContractCallReturnType } from '../apis/node';
 import { ContractCallObject } from '../contract/Contract';
 import ChannelSpend from './Spend';
 interface CallContractOptions {
+    /**
+     * Amount the caller of the contract commits to it
+     */
     amount?: number | BigNumber;
+    /**
+     * ABI encoded compiled AEVM call data for the code
+     */
     callData?: Encoded.ContractBytearray;
+    /**
+     * Version of the ABI
+     */
     abiVersion?: AbiVersion;
+    /**
+     * Address of the contract to call
+     */
     contract?: Encoded.ContractAddress;
+}
+interface CallContractResult extends CallContractOptions {
     returnValue?: any;
     gasUsed?: number | BigNumber;
     gasPrice?: number | BigNumber;
@@ -91,10 +105,6 @@ export default class ChannelContract extends ChannelSpend {
      * if a call with a similar computation amount is to be forced on-chain.
      *
      * @param options - Options
-     * @param options.amount - Amount the caller of the contract commits to it
-     * @param options.callData - ABI encoded compiled AEVM call data for the code
-     * @param options.contract - Address of the contract to call
-     * @param options.abiVersion - Version of the ABI
      * @param sign - Function which verifies and signs contract call transaction
      * @example
      * ```js
@@ -120,12 +130,6 @@ export default class ChannelContract extends ChannelSpend {
      * Trigger a force progress contract call
      * This call is going on-chain
      * @param options - Options
-     * @param options.amount - Amount the caller of the contract commits to it
-     * @param options.callData - ABI encoded compiled AEVM call data for the code
-     * @param options.contract - Address of the contract to call
-     * @param options.abiVersion - Version of the ABI
-     * @param options.gasPrice=1000000000]
-     * @param options.gasLimit=1000000]
      * @param sign - Function which verifies and signs contract force progress transaction
      * @param callbacks - Callbacks
      * @example
@@ -145,11 +149,7 @@ export default class ChannelContract extends ChannelSpend {
      * })
      * ```
      */
-    forceProgress({ amount, callData, contract, abiVersion, gasLimit, gasPrice, }: {
-        amount: number;
-        callData: Encoded.ContractBytearray;
-        contract: Encoded.ContractAddress;
-        abiVersion: AbiVersion;
+    forceProgress({ amount, callData, contract, abiVersion, gasLimit, gasPrice, }: CallContractOptions & {
         gasLimit?: number;
         gasPrice?: number;
     }, sign: SignTx, { onOnChainTx }?: Pick<ChannelState, 'onOnChainTx'>): Promise<{
@@ -169,10 +169,6 @@ export default class ChannelContract extends ChannelSpend {
      * top of the blockchain as seen by the node.
      *
      * @param options - Options
-     * @param options.amount - Amount the caller of the contract commits to it
-     * @param options.callData - ABI encoded compiled AEVM call data for the code
-     * @param options.contract - Address of the contract to call
-     * @param options.abiVersion - Version of the ABI
      * @example
      * ```js
      * channel.callContractStatic({
@@ -186,12 +182,7 @@ export default class ChannelContract extends ChannelSpend {
      * })
      * ```
      */
-    callContractStatic({ amount, callData, contract, abiVersion, }: {
-        amount: number;
-        callData: Encoded.ContractBytearray;
-        contract: Encoded.ContractAddress;
-        abiVersion: AbiVersion;
-    }): Promise<CallContractOptions>;
+    callContractStatic({ amount, callData, contract, abiVersion, }: CallContractOptions): Promise<CallContractResult>;
     /**
      * Get contract call result
      *

package/types-legacy/ts4.2/channel/Spend.d.ts

@@ -121,10 +121,6 @@ export default class ChannelSpend extends Channel {
      * @param amount - Amount of coins to withdraw
      * @param sign - Function which verifies and signs withdraw transaction
      * @param callbacks - Callbacks
-     * @param callbacks.onOnChainTx - Called when withdraw transaction has been posted
-     * on chain
-     * @param callbacks.onOwnWithdrawLocked
-     * @param callbacks.onWithdrawLocked
      * @example
      * ```js
      * channel.withdraw(
@@ -174,10 +170,6 @@ export default class ChannelSpend extends Channel {
      * @param amount - Amount of coins to deposit
      * @param sign - Function which verifies and signs deposit transaction
      * @param callbacks - Callbacks
-     * @param callbacks.onOnChainTx - Called when deposit transaction has been posted
-     * on chain
-     * @param callbacks.onOwnDepositLocked
-     * @param callbacks.onDepositLocked
      * @example
      * ```js
      * channel.deposit(

package/types-legacy/ts4.2/channel/internal.d.ts

@@ -29,41 +29,137 @@ interface SignOptions {
 }
 export type SignTxWithTag = (tag: string, tx: Encoded.Transaction, options?: SignOptions) => (Promise<Encoded.Transaction>);
 export type SignTx = (tx: Encoded.Transaction, options?: SignOptions) => (Promise<Encoded.Transaction | number | null>);
+/**
+ * @see {@link https://github.com/aeternity/protocol/blob/6734de2e4c7cce7e5e626caa8305fb535785131d/node/api/channels_api_usage.md#channel-establishing-parameters}
+ */
 export interface ChannelOptions {
     existingFsmId?: Encoded.Bytearray;
+    /**
+     * Channel url (for example: "ws://localhost:3001")
+     */
     url: string;
     /**
-     * @see {@link https://github.com/aeternity/protocol/blob/6734de2e4c7cce7e5e626caa8305fb535785131d/node/api/channels_api_usage.md#channel-establishing-parameters}
+     * Initiator's public key
      */
     initiatorId: Encoded.AccountAddress;
+    /**
+     * Responder's public key
+     */
     responderId: Encoded.AccountAddress;
+    /**
+     * Amount of blocks for disputing a solo close
+     */
     lockPeriod: number;
+    /**
+     * Initial deposit in favour of the responder by the initiator
+     */
     pushAmount: number;
-    initiatorAmount: BigNumber;
-    responderAmount: BigNumber;
+    /**
+     * Amount of coins the initiator has committed to the channel
+     */
+    initiatorAmount: BigNumber | number;
+    /**
+     * Amount of coins the responder has committed to the channel
+     */
+    responderAmount: BigNumber | number;
+    /**
+     * The minimum amount both peers need to maintain
+     */
     channelReserve?: BigNumber | number;
+    /**
+     * Minimum block height to include the channel_create_tx
+     */
     ttl?: number;
+    /**
+     * Host of the responder's node
+     */
     host: string;
+    /**
+     * The port of the responders node
+     */
     port: number;
+    /**
+     * Participant role
+     */
     role: 'initiator' | 'responder';
+    /**
+     * How to calculate minimum depth (default: txfee)
+     */
     minimumDepthStrategy?: 'txfee' | 'plain';
+    /**
+     * The minimum amount of blocks to be mined
+     */
     minimumDepth?: number;
+    /**
+     * The fee to be used for the channel open transaction
+     */
     fee?: BigNumber | number;
+    /**
+     * Used for the fee computation of the channel open transaction
+     */
     gasPrice?: BigNumber | number;
     signedTx?: string;
+    /**
+     * Existing channel id (required if reestablishing a channel)
+     */
     existingChannelId?: string;
+    /**
+     * Offchain transaction (required if reestablishing a channel)
+     */
     offChainTx?: string;
     reconnectTx?: string;
+    /**
+     * The time waiting for a new event to be initiated (default: 600000)
+     */
     timeoutIdle?: number;
+    /**
+     * The time waiting for the initiator to produce the create channel transaction after the noise
+     * session had been established (default: 120000)
+     */
     timeoutFundingCreate?: number;
+    /**
+     * The time frame the other client has to sign an off-chain update after our client had initiated
+     * and signed it. This applies only for double signed on-chain intended updates: channel create
+     * transaction, deposit, withdrawal and etc. (default: 120000)
+     */
     timeoutFundingSign?: number;
+    /**
+     * The time frame the other client has to confirm an on-chain transaction reaching maturity
+     * (passing minimum depth) after the local node has detected this. This applies only for double
+     * signed on-chain intended updates: channel create transaction, deposit, withdrawal and etc.
+     * (default: 360000)
+     */
     timeoutFundingLock?: number;
+    /**
+     * The time frame the client has to return a signed off-chain update or to decline it.
+     * This applies for all off-chain updates (default: 500000)
+     */
     timeoutSign?: number;
+    /**
+     * The time frame the other client has to react to an event. This applies for all off-chain
+     * updates that are not meant to land on-chain, as well as some special cases: opening a noise
+     * connection, mutual closing acknowledgement and reestablishing an existing channel
+     * (default: 120000)
+     */
     timeoutAccept?: number;
+    /**
+     * the time frame the responder has to accept an incoming noise session.
+     * Applicable only for initiator (default: timeout_accept's value)
+     */
     timeoutInitialized?: number;
+    /**
+     * The time frame the initiator has to start an outgoing noise session to the responder's node.
+     * Applicable only for responder (default: timeout_idle's value)
+     */
     timeoutAwaitingOpen?: number;
     statePassword?: string;
-    debug: boolean;
+    /**
+     * Log websocket communication and state changes
+     */
+    debug?: boolean;
+    /**
+     * Function which verifies and signs transactions
+     */
     sign: SignTxWithTag;
     offchainTx?: string;
 }
@@ -76,6 +172,9 @@ export interface ChannelState {
     reject: (e: BaseError) => void;
     sign: SignTx;
     handler?: ChannelHandler;
+    /**
+     * Called when transaction has been posted on chain
+     */
     onOnChainTx?: (tx: Encoded.Transaction) => void;
     onOwnWithdrawLocked?: () => void;
     onWithdrawLocked?: () => void;
@@ -114,7 +213,7 @@ export declare function emit<E extends keyof ChannelEvents>(channel: Channel, ..
     ...Parameters<ChannelEvents[E]>
 ]): void;
 export type ChannelStatus = 'connecting' | 'connected' | 'accepted' | 'halfSigned' | 'signed' | 'open' | 'closing' | 'closed' | 'died' | 'disconnected';
-export declare function changeStatus(channel: Channel, newStatus: ChannelStatus): void;
+export declare function changeStatus(channel: Channel, newStatus: ChannelStatus, debug?: unknown): void;
 export declare function changeState(channel: Channel, newState: Encoded.Transaction | ''): void;
 export declare function notify(channel: Channel, method: string, params?: object): void;
 export declare function enqueueAction(channel: Channel, guard: ChannelAction['guard'], action: () => {

package/types-legacy/ts4.2/contract/Contract.d.ts

@@ -11,7 +11,8 @@ import { Encoded } from '../utils/encoder';
 import { ContractCallObject as NodeContractCallObject, Event as NodeEvent } from '../apis/node';
 import CompilerBase, { Aci } from './compiler/Base';
 import Node, { TransformNodeType } from '../Node';
-import { txDryRun, sendTransaction, SendTransactionOptions } from '../chain';
+import { txDryRun } from '../chain';
+import { sendTransaction, SendTransactionOptions } from '../send-transaction';
 import AccountBase from '../account/Base';
 import { TxUnpacked } from '../tx/builder/schema.generated';
 interface Event extends NodeEvent {
@@ -137,12 +138,19 @@ declare class Contract<M extends ContractMethodsBase> {
     _name: string;
     _calldata: Calldata;
     $options: Omit<ConstructorParameters<typeof Contract>[0], 'aci'>;
+    /**
+     * @param options - Options
+     */
     constructor({ aci, ...otherOptions }: {
         onCompiler?: CompilerBase;
         onNode: Node;
         bytecode?: Encoded.ContractBytearray;
         aci: Aci;
         address?: Encoded.ContractAddress;
+        /**
+         * Supported only in Ceres
+         */
+        name?: AensName;
         sourceCodePath?: Parameters<CompilerBase['compile']>[0];
         sourceCode?: Parameters<CompilerBase['compileBySourceCode']>[0];
         fileSystem?: Parameters<CompilerBase['compileBySourceCode']>[1];

package/types-legacy/ts4.2/contract/compiler/Base.d.ts

@@ -16,6 +16,18 @@ export type Aci = Array<{
         typedefs: any[];
     };
 }>;
+export type CompileResult = Promise<{
+    bytecode: Encoded.ContractBytearray;
+    aci: Aci;
+    warnings: Array<{
+        message: string;
+        pos: {
+            file?: string;
+            line: number;
+            col: number;
+        };
+    }>;
+}>;
 /**
  * A base class for all compiler implementations
  */
@@ -26,10 +38,7 @@ export default abstract class CompilerBase {
      * @param path - Path to contract source code
      * @returns ACI and bytecode
      */
-    abstract compile(path: string): Promise<{
-        bytecode: Encoded.ContractBytearray;
-        aci: Aci;
-    }>;
+    abstract compile(path: string): CompileResult;
     /**
      * Compile contract by contract's source code
      * @param sourceCode - Contract source code as string
@@ -43,10 +52,7 @@ export default abstract class CompilerBase {
      * ```
      * @returns ACI and bytecode
      */
-    abstract compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<{
-        bytecode: Encoded.ContractBytearray;
-        aci: Aci;
-    }>;
+    abstract compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): CompileResult;
     /**
      * Generate contract's ACI by contract's path
      * Available only in Node.js

package/types-legacy/ts4.2/contract/compiler/Cli.d.ts

@@ -1,8 +1,10 @@
-import CompilerBase, { Aci } from './Base';
+import CompilerBase, { Aci, CompileResult } from './Base';
 import { Encoded } from '../../utils/encoder';
+export declare const getPackagePath: () => string;
 /**
  * A wrapper around aesophia_cli, available only in Node.js.
  * Requires Erlang installed, assumes that `escript` is available in PATH.
+ * @category contract
  */
 export default class CompilerCli extends CompilerBase {
     #private;
@@ -14,14 +16,8 @@ export default class CompilerCli extends CompilerBase {
     constructor(compilerPath?: string, { ignoreVersion }?: {
         ignoreVersion?: boolean;
     });
-    compile(path: string): Promise<{
-        bytecode: Encoded.ContractBytearray;
-        aci: Aci;
-    }>;
-    compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<{
-        bytecode: Encoded.ContractBytearray;
-        aci: Aci;
-    }>;
+    compile(path: string): CompileResult;
+    compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): CompileResult;
     generateAci(path: string): Promise<Aci>;
     generateAciBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<Aci>;
     validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean>;

package/types-legacy/ts4.2/contract/compiler/Cli8.d.ts

@@ -0,0 +1,13 @@
+import CompilerCli from './Cli';
+/**
+ * @category contract
+ */
+export default class CompilerCli8 extends CompilerCli {
+    /**
+     * @param options - Options
+     * @param options.ignoreVersion - Don't ensure that the compiler is supported
+     */
+    constructor({ ignoreVersion }?: {
+        ignoreVersion?: boolean;
+    });
+}

package/types-legacy/ts4.2/contract/compiler/Http.d.ts

@@ -1,5 +1,5 @@
 import { Compiler as CompilerApi } from '../../apis/compiler';
-import CompilerBase, { Aci } from './Base';
+import CompilerBase, { Aci, CompileResult } from './Base';
 import { Encoded } from '../../utils/encoder';
 /**
  * Contract Compiler over HTTP
@@ -18,14 +18,8 @@ export default class CompilerHttp extends CompilerBase {
     constructor(compilerUrl: string, { ignoreVersion }?: {
         ignoreVersion?: boolean;
     });
-    compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<{
-        bytecode: Encoded.ContractBytearray;
-        aci: Aci;
-    }>;
-    compile(path: string): Promise<{
-        bytecode: Encoded.ContractBytearray;
-        aci: Aci;
-    }>;
+    compileBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): CompileResult;
+    compile(path: string): CompileResult;
     generateAciBySourceCode(sourceCode: string, fileSystem?: Record<string, string>): Promise<Aci>;
     generateAci(path: string): Promise<Aci>;
     validateBySourceCode(bytecode: Encoded.ContractBytearray, sourceCode: string, fileSystem?: Record<string, string>): Promise<boolean>;

package/types-legacy/ts4.2/contract/compiler/HttpNode.d.ts

@@ -1,5 +1,5 @@
 import HttpBrowser from './Http';
-import { Aci } from './Base';
+import { Aci, CompileResult } from './Base';
 import { Encoded } from '../../utils/encoder';
 /**
  * Contract Compiler over HTTP for Nodejs
@@ -9,10 +9,7 @@ import { Encoded } from '../../utils/encoder';
  * @example CompilerHttpNode('COMPILER_URL')
  */
 export default class CompilerHttpNode extends HttpBrowser {
-    compile(path: string): Promise<{
-        bytecode: Encoded.ContractBytearray;
-        aci: Aci;
-    }>;
+    compile(path: string): CompileResult;
     generateAci(path: string): Promise<Aci>;
     validate(bytecode: Encoded.ContractBytearray, path: string): Promise<boolean>;
 }

package/types-legacy/ts4.2/contract/delegation-signature.d.ts

@@ -37,8 +37,9 @@ import Node from '../Node';
  *   .createDelegationSignature(contractAddress, [oracleQueryId], { onAccount, omitAddress: true })
  * ```
  */
-export default function createDelegationSignature(contractAddress: Encoded.ContractAddress, ids: Array<Encoded.Any | AensName>, { onAccount, omitAddress, ...options }: {
+export default function createDelegationSignature(contractAddress: Encoded.ContractAddress, ids: Array<Encoded.Any | AensName>, { onAccount, omitAddress, isOracle, ...options }: {
     omitAddress?: boolean;
     onAccount: AccountBase;
+    isOracle?: boolean;
     onNode: Node;
 }): Promise<Uint8Array>;

package/types-legacy/ts4.2/contract/ga.d.ts

@@ -8,13 +8,12 @@ import { Encoded } from '../utils/encoder';
 import AccountBase from '../account/Base';
 import Contract from './Contract';
 import Node from '../Node';
-import { SendTransactionOptions } from '../chain';
+import { SendTransactionOptions } from '../send-transaction';
 import CompilerBase from './compiler/Base';
 /**
  * Convert current account to GA
  * @category contract
  * @param authFnName - Authorization function name
- * @param sourceCode - Auth contract source code
  * @param args - init arguments
  * @param options - Options
  * @returns General Account Object

package/types-legacy/ts4.2/deprecated.d.ts

@@ -1,6 +1,7 @@
 import { AciValue } from './utils/typed-data';
 import { Encoded } from './utils/encoder';
 import { RpcError } from './aepp-wallet-communication/schema';
+import { ORACLE_TTL_TYPES } from './tx/builder/schema';
 /**
  * @category exception
  * @deprecated this exception is not thrown anymore
@@ -22,3 +23,40 @@ export declare function encodeFateValue(value: unknown, aci: AciValue): Encoded.
  * @deprecated use ContractByteArrayEncoder:decodeWithType from \@aeternity/aepp-calldata
  */
 export declare function decodeFateValue(value: Encoded.ContractBytearray, aci: AciValue): any;
+/**
+ * @deprecated inlined in buildTx or use `180000`
+ */
+export declare const NAME_TTL = 180000;
+/**
+ * @deprecated inlined in buildTx or use `36000`
+ */
+export declare const NAME_MAX_TTL = 36000;
+/**
+ * @deprecated inlined in buildTx or use `60 * 60`
+ */
+export declare const NAME_MAX_CLIENT_TTL: number;
+/**
+ * @deprecated inlined in buildTx or use `60 * 60`
+ */
+export declare const CLIENT_TTL: number;
+/**
+ * @deprecated inlined in buildTx or use `{ type: ORACLE_TTL_TYPES.delta, value: 500 }`
+ */
+export declare const ORACLE_TTL: {
+    type: ORACLE_TTL_TYPES;
+    value: number;
+};
+/**
+ * @deprecated inlined in buildTx or use `{ type: ORACLE_TTL_TYPES.delta, value: 10 }`
+ */
+export declare const QUERY_TTL: {
+    type: ORACLE_TTL_TYPES;
+    value: number;
+};
+/**
+ * @deprecated inlined in buildTx or use `{ type: ORACLE_TTL_TYPES.delta, value: 10 }`
+ */
+export declare const RESPONSE_TTL: {
+    type: ORACLE_TTL_TYPES;
+    value: number;
+};