@aeternity/aepp-sdk 13.0.0-alpha.1 → 13.0.0-beta.0

package/src/utils/errors.ts

@@ -1,6 +1,7 @@
 // eslint-disable-next-line max-classes-per-file
 import BigNumber from 'bignumber.js';
-import { Int } from '../tx/builder/constants';
+import { AensName, Int } from '../tx/builder/constants';
+import * as Encoded from './encoder-types';
 
 /**
  * aepp-sdk originated error
@@ -187,7 +188,7 @@ export class RequestTimedOutError extends BaseError {
  * @category exception
  */
 export class TxTimedOutError extends BaseError {
-  constructor(blocks: number, th: string) {
+  constructor(blocks: number, th: Encoded.TxHash) {
     super([
       `Giving up after ${blocks} blocks mined`,
       `transaction hash: ${th}`,
@@ -270,7 +271,7 @@ export class UnexpectedTsError extends InternalError {
  * @category exception
  */
 export class UnavailableAccountError extends AccountError {
-  constructor(address: string) {
+  constructor(address: Encoded.AccountAddress) {
     super(`Account for ${address} not available`);
     this.name = 'UnavailableAccountError';
   }
@@ -280,7 +281,7 @@ export class UnavailableAccountError extends AccountError {
  * @category exception
  */
 export class AensPointerContextError extends AensError {
-  constructor(nameOrId: string, prefix: string) {
+  constructor(nameOrId: AensName | Encoded.Name, prefix: string) {
     super(`Name ${nameOrId} don't have pointers for ${prefix}`);
     this.name = 'AensPointerContextError';
   }
@@ -330,7 +331,7 @@ export class MissingCallbackError extends AeppError {
  * @category exception
  */
 export class UnAuthorizedAccountError extends AeppError {
-  constructor(onAccount: string) {
+  constructor(onAccount: Encoded.AccountAddress) {
     super(`You do not have access to account ${onAccount}`);
     this.name = 'UnAuthorizedAccountError';
   }
@@ -436,7 +437,7 @@ export class InvalidAuthDataError extends CompilerError {
  * @category exception
  */
 export class BytecodeMismatchError extends ContractError {
-  constructor(source: string) {
+  constructor(source: 'source code' | 'bytecode') {
     super(`Contract ${source} do not correspond to the bytecode deployed on the chain`);
     this.name = 'BytecodeMismatchError';
   }
@@ -456,7 +457,7 @@ export class DuplicateContractError extends ContractError {
  * @category exception
  */
 export class InactiveContractError extends ContractError {
-  constructor(contractAddress: string) {
+  constructor(contractAddress: Encoded.ContractAddress) {
     super(`Contract with address ${contractAddress} not active`);
     this.name = 'InactiveContractError';
   }
@@ -506,9 +507,9 @@ export class MissingFunctionNameError extends ContractError {
  * @category exception
  */
 export class NodeInvocationError extends ContractError {
-  transaction: string;
+  transaction?: Encoded.Transaction;
 
-  constructor(message: string, transaction: string) {
+  constructor(message: string, transaction?: Encoded.Transaction) {
     super(`Invocation failed${message == null ? '' : `: "${message}"`}`);
     this.name = 'NodeInvocationError';
     this.transaction = transaction;
@@ -542,7 +543,7 @@ export class NotPayableFunctionError extends ContractError {
  * @category exception
  */
 export class MissingEventDefinitionError extends ContractError {
-  constructor(eventNameHash: string, eventAddress: string) {
+  constructor(eventNameHash: string, eventAddress: Encoded.ContractAddress) {
     super(
       `Can't find definition of ${eventNameHash} event emitted by ${eventAddress}`
       + ' (use omitUnknown option to ignore events like this)',
@@ -555,7 +556,7 @@ export class MissingEventDefinitionError extends ContractError {
  * @category exception
  */
 export class AmbiguousEventDefinitionError extends ContractError {
-  constructor(eventAddress: string, matchedEvents: Array<[string, string]>) {
+  constructor(eventAddress: Encoded.ContractAddress, matchedEvents: Array<[string, string]>) {
     super(
       `Found multiple definitions of "${matchedEvents[0][1]}" event with different types emitted by`
       + ` ${eventAddress} in ${matchedEvents.map(([name]) => `"${name}"`).join(', ')} contracts`
@@ -695,16 +696,6 @@ export class InvalidSignatureError extends TransactionError {
   }
 }
 
-/**
- * @category exception
- */
-export class InvalidTxParamsError extends TransactionError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'InvalidTxParamsError';
-  }
-}
-
 /**
  * @category exception
  */
@@ -719,8 +710,8 @@ export class PrefixNotFoundError extends TransactionError {
  * @category exception
  */
 export class SchemaNotFoundError extends TransactionError {
-  constructor(schemaName: string, key: string, version: number) {
-    super(`Transaction ${schemaName} not implemented for ${key} version ${version}`);
+  constructor(key: string, version: number) {
+    super(`Transaction schema not implemented for tag ${key} version ${version}`);
     this.name = 'SchemaNotFoundError';
   }
 }
@@ -739,32 +730,12 @@ export class TagNotFoundError extends TransactionError {
  * @category exception
  */
 export class TxNotInChainError extends TransactionError {
-  constructor(txHash: string) {
+  constructor(txHash: Encoded.TxHash) {
     super(`Transaction ${txHash} is removed from chain`);
     this.name = 'TxNotInChainError';
   }
 }
 
-/**
- * @category exception
- */
-export class UnsupportedABIversionError extends TransactionError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'UnsupportedABIversionError';
-  }
-}
-
-/**
- * @category exception
- */
-export class UnsupportedVMversionError extends TransactionError {
-  constructor(message: string) {
-    super(message);
-    this.name = 'UnsupportedVMversionError';
-  }
-}
-
 /**
  * @category exception
  */

package/src/utils/string.ts

@@ -1,20 +1,3 @@
-/*
- * ISC License (ISC)
- * Copyright 2018 aeternity developers
- *
- *  Permission to use, copy, modify, and/or distribute this software for any
- *  purpose with or without fee is hereby granted, provided that the above
- *  copyright notice and this permission notice appear in all copies.
- *
- *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
- *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
- *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
- *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
- *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
- *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
- *  PERFORMANCE OF THIS SOFTWARE.
- */
-
 /**
  * Convert string from snake_case to PascalCase
  * @param s - String to convert

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

@@ -3,19 +3,20 @@ import * as aensMethods from './aens';
 import * as spendMethods from './spend';
 import * as oracleMethods from './oracle';
 import Contract, { ContractMethodsBase } from './contract/Contract';
+import createDelegationSignature from './contract/delegation-signature';
 import * as contractGaMethods from './contract/ga';
-import { _buildTx } from './tx';
 import { UnionToIntersection } from './utils/other';
 import Node from './Node';
-import { Tag } from './tx/builder/constants';
+import { TxParamsAsync } from './tx/builder/schema.generated';
 import AccountBase from './account/Base';
 import { Encoded } from './utils/encoder';
-import CompilerBase from './contract/compiler/Base';
 export type OnAccount = Encoded.AccountAddress | AccountBase | undefined;
 export declare function getValueOrErrorProxy<Value extends object>(valueCb: () => Value): Value;
 declare const methods: {
     readonly createGeneralizedAccount: typeof contractGaMethods.createGeneralizedAccount;
     readonly buildAuthTxHash: typeof contractGaMethods.buildAuthTxHash;
+    readonly buildAuthTxHashByGaMetaTx: typeof contractGaMethods.buildAuthTxHashByGaMetaTx;
+    readonly createDelegationSignature: typeof createDelegationSignature;
     readonly pollForQueries: typeof oracleMethods.pollForQueries;
     readonly pollForQueryResponse: typeof oracleMethods.pollForQueryResponse;
     readonly getQueryObject: typeof oracleMethods.getQueryObject;
@@ -24,7 +25,6 @@ declare const methods: {
     readonly respondToQuery: typeof oracleMethods.respondToQuery;
     readonly getOracleObject: typeof oracleMethods.getOracleObject;
     readonly registerOracle: typeof oracleMethods.registerOracle;
-    readonly send: typeof spendMethods.send;
     readonly spend: typeof spendMethods.spend;
     readonly transferFunds: typeof spendMethods.transferFunds;
     readonly payForTransaction: typeof spendMethods.payForTransaction;
@@ -102,9 +102,7 @@ declare class AeSdkMethods {
     _getOptions(): AeSdkMethodsOptions & {
         onAccount: AccountBase;
     };
-    buildTx<TxType extends Tag>(txType: TxType, options: Omit<Parameters<any>[1], 'onNode'> & {
-        onNode?: Node;
-    }): Promise<Encoded.Transaction>;
+    buildTx(options: TxParamsAsync): Promise<Encoded.Transaction>;
     initializeContract<Methods extends ContractMethodsBase>(options?: Omit<Parameters<typeof Contract.initialize>[0], 'onNode'> & {
         onNode?: Node;
     }): Promise<Contract<Methods>>;
@@ -116,12 +114,13 @@ type OptionalIfNotRequired<T extends [
     any
 ]> = RequiredKeys<T[0]> extends never ? T | [
 ] : T;
+type ReplaceOnAccount<Options> = Options extends {
+    onAccount: any;
+} ? Omit<Options, 'onAccount'> & {
+    onAccount: OnAccount;
+} : Options;
 type MakeOptional<Options> = OptionalIfNotRequired<[
-    Omit<Options, 'onNode' | 'onCompiler' | 'onAccount'> & {
-        onNode?: Node;
-        onCompiler?: CompilerBase;
-        onAccount?: OnAccount;
-    }
+    Omit<Options, 'onNode' | 'onCompiler' | 'onAccount'> & Partial<ReplaceOnAccount<Options>>
 ]>;
 type TransformMethods<Methods extends {
     [key: string]: Function;

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

@@ -68,9 +68,13 @@ export default class Node extends Node_base {
      * @param url - Url for node API
      * @param options - Options
      * @param options.ignoreVersion - Don't check node version
+     * @param options.retryCount - Amount of extra requests to do in case of failure
+     * @param options.retryOverallDelay - Time in ms to wait between all retries
      */
-    constructor(url: string, { ignoreVersion, ...options }?: NodeOptionalParams & {
+    constructor(url: string, { ignoreVersion, retryCount, retryOverallDelay, ...options }?: NodeOptionalParams & {
         ignoreVersion?: boolean;
+        retryCount?: number;
+        retryOverallDelay?: number;
     });
     getNetworkId(): Promise<string>;
     getNodeInfo(): Promise<NodeInfo>;

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

@@ -1,6 +1,15 @@
 import { Encoded } from '../utils/encoder';
 import Node from '../Node';
 import CompilerBase from '../contract/compiler/Base';
+import { Int } from '../tx/builder/constants';
+interface AuthData {
+    fee?: Int;
+    gasLimit?: number;
+    gasPrice?: Int;
+    callData?: Encoded.ContractBytearray;
+    sourceCode?: string;
+    args?: any[];
+}
 /**
  * Account is one of the three basic building blocks of an
  * {@link AeSdk} and provides access to a signing key pair.
@@ -17,12 +26,7 @@ export default abstract class AccountBase {
     abstract signTransaction(tx: Encoded.Transaction, options: {
         innerTx?: boolean;
         networkId?: string;
-        authData?: {
-            gasLimit?: number;
-            callData?: Encoded.ContractBytearray;
-            sourceCode?: string;
-            args?: any[];
-        };
+        authData?: AuthData | ((tx: Encoded.Transaction) => Promise<AuthData>);
         onNode?: Node;
         onCompiler?: CompilerBase;
         aeppOrigin?: string;
@@ -50,3 +54,4 @@ export default abstract class AccountBase {
      */
     readonly address: Encoded.AccountAddress;
 }
+export {};

package/types-legacy/ts4.2/account/Memory.d.ts

@@ -1,5 +1,6 @@
 import AccountBase from './Base';
 import { Encoded } from '../utils/encoder';
+export declare function getBufferToSign(transaction: Encoded.Transaction, networkId: string, innerTx: boolean): Uint8Array;
 /**
  * In-memory account class
  */
@@ -14,7 +15,7 @@ export default class AccountMemory extends AccountBase {
      */
     static generate(): AccountMemory;
     sign(data: string | Uint8Array, options?: any): Promise<Uint8Array>;
-    signTransaction(tx: Encoded.Transaction, { innerTx, networkId, ...options }?: {
+    signTransaction(transaction: Encoded.Transaction, { innerTx, networkId, ...options }?: {
         innerTx?: boolean;
         networkId?: string;
     }): Promise<Encoded.Transaction>;

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

@@ -8,9 +8,8 @@
 import BigNumber from 'bignumber.js';
 import { Tag, AensName } from './tx/builder/constants';
 import { Encoded } from './utils/encoder';
-import { send, SendOptions } from './spend';
-import { getName } from './chain';
-import { BuildTxOptions } from './tx';
+import { sendTransaction, SendTransactionOptions, getName } from './chain';
+import { BuildTxOptions } from './tx/builder';
 import { TransformNodeType } from './Node';
 import { NameEntry, NamePointer } from './apis/node';
 import AccountBase from './account/Base';
@@ -39,8 +38,8 @@ interface KeyPointers {
  * await nameObject.revoke({ fee, ttl, nonce })
  * ```
  */
-export declare function aensRevoke(name: AensName, options: AensRevokeOptions): ReturnType<typeof send>;
-interface AensRevokeOptions extends BuildTxOptions<Tag.NameRevokeTx, 'nameId' | 'accountId'>, SendOptions {
+export declare function aensRevoke(name: AensName, options: AensRevokeOptions): ReturnType<typeof sendTransaction>;
+interface AensRevokeOptions extends BuildTxOptions<Tag.NameRevokeTx, 'nameId' | 'accountId' | 'onNode'>, SendTransactionOptions {
 }
 /**
  * Update a name
@@ -71,8 +70,8 @@ interface AensRevokeOptions extends BuildTxOptions<Tag.NameRevokeTx, 'nameId' |
  * await nameObject.update(pointers, { nameTtl, ttl, fee, nonce, clientTtl })
  * ```
  */
-export declare function aensUpdate(name: AensName, pointers: KeyPointers, { extendPointers, ...options }: AensUpdateOptions): ReturnType<typeof send>;
-interface AensUpdateOptions extends BuildTxOptions<Tag.NameUpdateTx, 'nameId' | 'accountId' | 'pointers' | 'clientTtl' | 'nameTtl'>, SendOptions {
+export declare function aensUpdate(name: AensName, pointers: KeyPointers, { extendPointers, ...options }: AensUpdateOptions): ReturnType<typeof sendTransaction>;
+interface AensUpdateOptions extends BuildTxOptions<Tag.NameUpdateTx, 'nameId' | 'accountId' | 'pointers' | 'clientTtl' | 'nameTtl' | 'onNode'>, SendTransactionOptions {
     extendPointers?: boolean;
     clientTtl?: number;
     nameTtl?: number;
@@ -100,8 +99,8 @@ interface AensUpdateOptions extends BuildTxOptions<Tag.NameUpdateTx, 'nameId' |
  * await nameObject.transfer(recipientPub, { ttl, fee, nonce })
  * ```
  */
-export declare function aensTransfer(name: AensName, account: Encoded.AccountAddress, options: AensTransferOptions): ReturnType<typeof send>;
-interface AensTransferOptions extends BuildTxOptions<Tag.NameTransferTx, 'nameId' | 'accountId' | 'recipientId'>, SendOptions {
+export declare function aensTransfer(name: AensName, account: Encoded.AccountAddress, options: AensTransferOptions): ReturnType<typeof sendTransaction>;
+interface AensTransferOptions extends BuildTxOptions<Tag.NameTransferTx, 'nameId' | 'accountId' | 'recipientId' | 'onNode'>, SendTransactionOptions {
 }
 /**
  * Query the AENS name info from the node
@@ -161,10 +160,10 @@ export declare function aensQuery(name: AensName, opt: Parameters<typeof getName
  * ```
  */
 export declare function aensClaim(name: AensName, salt: number, options: AensClaimOptions): Promise<AensClaimReturnType>;
-type AensClaimOptionsType = BuildTxOptions<Tag.NameClaimTx, 'accountId' | 'nameSalt' | 'name'> & SendOptions & Parameters<typeof aensQuery>[1];
+type AensClaimOptionsType = BuildTxOptions<Tag.NameClaimTx, 'accountId' | 'nameSalt' | 'name'> & SendTransactionOptions & Parameters<typeof aensQuery>[1];
 interface AensClaimOptions extends AensClaimOptionsType {
 }
-interface AensClaimReturnType extends Awaited<ReturnType<typeof send>>, Partial<Awaited<ReturnType<typeof aensQuery>>> {
+interface AensClaimReturnType extends Awaited<ReturnType<typeof sendTransaction>>, Partial<Awaited<ReturnType<typeof aensQuery>>> {
 }
 /**
  * Preclaim a name. Sends a hash of the name and a random salt to the node
@@ -190,13 +189,12 @@ interface AensClaimReturnType extends Awaited<ReturnType<typeof send>>, Partial<
  * }
  * ```
  */
-export declare function aensPreclaim(name: AensName, options: AensPreclaimOptions): Promise<Readonly<Awaited<ReturnType<typeof send>> & {
-    height: number;
+export declare function aensPreclaim(name: AensName, options: AensPreclaimOptions): Promise<Readonly<Awaited<ReturnType<typeof sendTransaction>> & {
     salt: number;
     commitmentId: string;
     claim: (opts?: Parameters<typeof aensClaim>[2]) => ReturnType<typeof aensClaim>;
 }>>;
-interface AensPreclaimOptions extends BuildTxOptions<Tag.NamePreclaimTx, 'accountId' | 'commitmentId'>, SendOptions, Omit<AensClaimOptions, 'version'> {
+interface AensPreclaimOptions extends BuildTxOptions<Tag.NamePreclaimTx, 'accountId' | 'commitmentId' | 'onNode'>, SendTransactionOptions, Omit<AensClaimOptions, 'version'> {
 }
 /**
  * Bid to name auction

package/types-legacy/ts4.2/aepp-wallet-communication/rpc/types.d.ts

@@ -1,6 +1,7 @@
-import { send } from '../../spend';
 import { Encoded } from '../../utils/encoder';
 import { METHODS, SUBSCRIPTION_TYPES, WALLET_TYPE } from '../schema';
+import { TransformNodeType } from '../../Node';
+import { SignedTx } from '../../apis/node';
 export interface WalletInfo {
     id: string;
     name: string;
@@ -64,7 +65,10 @@ export interface WalletApi {
          * @deprecated this is not a hash at all, will be removed later at the same time
          * as dropping ability to broadcast transaction by wallet
          */
-        transactionHash?: Awaited<ReturnType<typeof send>>;
+        transactionHash?: Partial<TransformNodeType<SignedTx>> & {
+            hash: Encoded.TxHash;
+            rawTx: Encoded.Transaction;
+        };
         signedTransaction?: Encoded.Transaction;
     }>);
     [METHODS.signMessage]: (p: {

package/types-legacy/ts4.2/apis/compiler/compiler.d.ts

@@ -15,7 +15,7 @@ export declare class Compiler extends coreClient.ServiceClient {
      */
     generateACI(body: Contract, options?: GenerateACIOptionalParams): Promise<GenerateACIResponse>;
     /**
-     * Compile a sophia contract from source and return byte code
+     * Compile a sophia contract from source and return byte code and ACI
      * @param body contract code
      * @param options The options parameters.
      */

package/types-legacy/ts4.2/apis/compiler/models/index.d.ts

@@ -26,9 +26,10 @@ export interface ErrorPos {
     line: number;
     col: number;
 }
-export interface ByteCode {
+export interface CompileResult {
     /** Prefixed (cb_) Base64Check encoded byte array */
     bytecode: string;
+    aci: Record<string, unknown>[];
 }
 export interface SophiaCallResultInput {
     /** (Possibly partial) Sophia contract code/interface */
@@ -131,7 +132,7 @@ export type GenerateACIResponse = Aci;
 export interface CompileContractOptionalParams extends coreClient.OperationOptions {
 }
 /** Contains response data for the compileContract operation. */
-export type CompileContractResponse = ByteCode;
+export type CompileContractResponse = CompileResult;
 /** Optional parameters. */
 export interface DecodeCallResultOptionalParams extends coreClient.OperationOptions {
 }

package/types-legacy/ts4.2/apis/compiler/models/mappers.d.ts

@@ -4,7 +4,7 @@ export declare const CompileOpts: coreClient.CompositeMapper;
 export declare const Aci: coreClient.CompositeMapper;
 export declare const CompilerError: coreClient.CompositeMapper;
 export declare const ErrorPos: coreClient.CompositeMapper;
-export declare const ByteCode: coreClient.CompositeMapper;
+export declare const CompileResult: coreClient.CompositeMapper;
 export declare const SophiaCallResultInput: coreClient.CompositeMapper;
 export declare const BytecodeCallResultInput: coreClient.CompositeMapper;
 export declare const DecodedCallresult: coreClient.CompositeMapper;

package/types-legacy/ts4.2/apis/node/models/index.d.ts

@@ -96,7 +96,7 @@ export interface SignedTx {
 /** A mix of all transaction types. */
 export interface Tx {
     /** Polymorphic discriminator, which specifies the different types this object can be */
-    type: "undefined";
+    type: "Tx";
     /** Base58Check encoded tagged pubkey */
     recipientId?: string;
     amount?: string;
@@ -808,7 +808,7 @@ export interface PayingForTx {
 export interface CheckTxInPoolResponse {
     status: string;
 }
-export type OffChainTransfer = OffChainUpdate & {
+export interface OffChainTransfer extends OffChainUpdate {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     op: "OffChainTransfer";
     /** Base58Check encoded tagged pubkey */
@@ -816,22 +816,22 @@ export type OffChainTransfer = OffChainUpdate & {
     /** Base58Check encoded tagged pubkey */
     to: string;
     amount: string;
-};
-export type OffChainWithdrawal = OffChainUpdate & {
+}
+export interface OffChainWithdrawal extends OffChainUpdate {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     op: "OffChainWithdrawal";
     /** Base58Check encoded tagged pubkey */
     to: string;
     amount: string;
-};
-export type OffChainDeposit = OffChainUpdate & {
+}
+export interface OffChainDeposit extends OffChainUpdate {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     op: "OffChainDeposit";
     /** Base58Check encoded tagged pubkey */
     from: string;
     amount: string;
-};
-export type OffChainNewContract = OffChainUpdate & {
+}
+export interface OffChainNewContract extends OffChainUpdate {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     op: "OffChainNewContract";
     /** Base58Check encoded tagged pubkey */
@@ -842,8 +842,8 @@ export type OffChainNewContract = OffChainUpdate & {
     deposit: string;
     /** Base64Check encoded tagged byte array */
     callData: string;
-};
-export type OffChainCallContract = OffChainUpdate & {
+}
+export interface OffChainCallContract extends OffChainUpdate {
     /** Polymorphic discriminator, which specifies the different types this object can be */
     op: "OffChainCallContract";
     /** Base58Check encoded tagged pubkey */
@@ -856,11 +856,11 @@ export type OffChainCallContract = OffChainUpdate & {
     gasPrice: string;
     /** Base64Check encoded tagged byte array */
     callData: string;
-};
-export type CreateContractUnsignedTx = UnsignedTx & {
+}
+export interface CreateContractUnsignedTx extends UnsignedTx {
     /** Base58Check encoded tagged pubkey */
     contractId: string;
-};
+}
 /** Defines values for TTLType. */
 export type TTLType = "delta" | "block";
 /** Defines values for TxType. */
@@ -1015,11 +1015,11 @@ export type GetOracleByPubkeyResponse = RegisteredOracle;
 /** Optional parameters. */
 export interface GetOracleQueriesByPubkeyOptionalParams extends coreClient.OperationOptions {
     /** Last query id in previous page */
-    fromParam?: string;
+    from?: string;
     /** Max number of oracle queries */
     limit?: number;
     /** The type of a query: open, closed or all */
-    typeParam?: OracleQueryType;
+    type?: OracleQueryType;
 }
 /** Contains response data for the getOracleQueriesByPubkey operation. */
 export type GetOracleQueriesByPubkeyResponse = OracleQueries;

package/types-legacy/ts4.2/apis/node/models/mappers.d.ts

@@ -85,7 +85,7 @@ export declare const OffChainNewContract: coreClient.CompositeMapper;
 export declare const OffChainCallContract: coreClient.CompositeMapper;
 export declare const CreateContractUnsignedTx: coreClient.CompositeMapper;
 export declare let discriminators: {
-    "Tx.undefined": coreClient.CompositeMapper;
+    "Tx.Tx": coreClient.CompositeMapper;
     OffChainUpdate: coreClient.CompositeMapper;
     "OffChainUpdate.OffChainTransfer": coreClient.CompositeMapper;
     "OffChainUpdate.OffChainWithdrawal": coreClient.CompositeMapper;

package/types-legacy/ts4.2/apis/node/models/parameters.d.ts

@@ -10,8 +10,8 @@ export declare const strategy: OperationQueryParameter;
 export declare const contentType: OperationParameter;
 export declare const body: OperationParameter;
 export declare const body1: OperationParameter;
-export declare const fromParam: OperationQueryParameter;
+export declare const from: OperationQueryParameter;
 export declare const limit: OperationQueryParameter;
-export declare const typeParam: OperationQueryParameter;
+export declare const type: OperationQueryParameter;
 export declare const queryId: OperationURLParameter;
 export declare const name: OperationURLParameter;

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

@@ -72,26 +72,26 @@ export declare function waitForTxConfirm(txHash: Encoded.TxHash, { confirm, onNo
     onNode: Node;
 } & Parameters<typeof awaitHeight>[1]): Promise<number>;
 /**
- * Submit a signed transaction for mining
+ * Signs and submits transaction for mining
  * @category chain
- * @param tx - Transaction to submit
+ * @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 sending
+ * @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(tx: Encoded.Transaction, { onNode, onAccount, verify, waitMined, confirm, ...options }: SendTransactionOptions): Promise<SendTransactionReturnType>;
+export declare function sendTransaction(txUnsigned: Encoded.Transaction, { onNode, onAccount, verify, waitMined, confirm, innerTx, ...options }: SendTransactionOptions): Promise<SendTransactionReturnType>;
 type SendTransactionOptionsType = {
     onNode: Node;
-    onAccount?: AccountBase;
+    onAccount: AccountBase;
     verify?: boolean;
     waitMined?: boolean;
     confirm?: boolean | number;
-} & Parameters<typeof poll>[1] & Omit<Parameters<typeof waitForTxConfirm>[1], 'confirm'>;
-interface SendTransactionOptions extends SendTransactionOptionsType {
+} & 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;
@@ -122,7 +122,7 @@ export declare function getAccount(address: Encoded.AccountAddress | Encoded.Con
  * (default: top of chain)
  * @param options.hash - The block hash on which to obtain the balance for (default: top of chain)
  */
-export declare function getBalance(address: Encoded.AccountAddress | Encoded.ContractAddress, { format, ...options }: {
+export declare function getBalance(address: Encoded.AccountAddress | Encoded.ContractAddress | Encoded.OracleAddress, { format, ...options }: {
     format?: AE_AMOUNT_FORMATS;
 } & Parameters<typeof getAccount>[1]): Promise<string>;
 /**