@aeternity/aepp-sdk 13.2.2 → 13.3.0

package/src/oracle.ts

@@ -9,20 +9,13 @@
 import { mapObject, pause } from './utils/other';
 import { oracleQueryId } from './tx/builder/helpers';
 import { unpackTx, buildTxAsync, BuildTxOptions } from './tx/builder';
-import {
-  ORACLE_TTL,
-  ORACLE_TTL_TYPES,
-  QUERY_TTL,
-  RESPONSE_TTL,
-} from './tx/builder/schema';
 import { Tag } from './tx/builder/constants';
 import { RequestTimedOutError } from './utils/errors';
 import {
   decode, encode, Encoded, Encoding,
 } from './utils/encoder';
-import {
-  _getPollInterval, getHeight, sendTransaction, SendTransactionOptions,
-} from './chain';
+import { _getPollInterval, getHeight } from './chain';
+import { sendTransaction, SendTransactionOptions } from './send-transaction';
 import Node from './Node';
 import AccountBase from './account/Base';
 
@@ -93,7 +86,7 @@ export async function pollForQueryResponse(
     const responseBuffer = decode(response as Encoded.OracleResponse);
     if (responseBuffer.length > 0) return responseBuffer.toString();
     await pause(interval);
-    height = await getHeight({ onNode });
+    height = await getHeight({ ...options, onNode, cached: true });
   } while (ttl >= height);
   throw new RequestTimedOutError(height);
 }
@@ -139,11 +132,6 @@ interface GetQueryObjectReturnType extends Awaited<ReturnType<Node['getOracleQue
  * @param oracleId - Oracle public key
  * @param query - Oracle query object
  * @param options - Options object
- * @param options.queryTtl - queryTtl Oracle query time to leave
- * @param options.responseTtl - queryFee Oracle query response time to leave
- * @param options.queryFee - queryFee Oracle query fee
- * @param options.fee - fee Transaction fee
- * @param options.ttl - Transaction time to leave
  * @returns Query object
  */
 export async function postQueryToOracle(
@@ -153,14 +141,10 @@ export async function postQueryToOracle(
 ): Promise<
   Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getQueryObject>>
   > {
-  options.queryFee ??= (await options.onNode.getOracleByPubkey(oracleId)).queryFee.toString();
   const senderId = options.onAccount.address;
 
   const oracleQueryTx = await buildTxAsync({
-    queryTtlType: QUERY_TTL.type,
-    queryTtlValue: QUERY_TTL.value,
-    responseTtlType: RESPONSE_TTL.type,
-    responseTtlValue: RESPONSE_TTL.value,
+    _isInternalBuild: true,
     ...options,
     tag: Tag.OracleQueryTx,
     oracleId,
@@ -177,23 +161,13 @@ export async function postQueryToOracle(
 
 type PostQueryToOracleOptionsType = Parameters<typeof sendTransaction>[1]
 & Parameters<typeof getQueryObject>[2]
-& BuildTxOptions<Tag.OracleQueryTx, 'oracleId' | 'senderId' | 'query' | 'queryTtlType' | 'queryTtlValue' | 'responseTtlType' | 'responseTtlValue'>
-& {
-  queryTtlType?: ORACLE_TTL_TYPES;
-  queryTtlValue?: number;
-  responseTtlType?: ORACLE_TTL_TYPES;
-  responseTtlValue?: number;
-};
+& BuildTxOptions<Tag.OracleQueryTx, 'oracleId' | 'senderId' | 'query'>;
 interface PostQueryToOracleOptions extends PostQueryToOracleOptionsType {}
 
 /**
  * Extend oracle ttl
  * @category oracle
  * @param options - Options object
- * @param options.fee - fee Transaction fee
- * @param options.ttl - Transaction time to leave
- * @param options.oracleTtlType - Oracle time to leave for extend
- * @param options.oracleTtlValue - Oracle time to leave for extend
  * @returns Oracle object
  */
 export async function extendOracleTtl(options: ExtendOracleTtlOptions): Promise<
@@ -201,8 +175,7 @@ Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracl
 > {
   const oracleId = encode(decode(options.onAccount.address), Encoding.OracleAddress);
   const oracleExtendTx = await buildTxAsync({
-    oracleTtlType: ORACLE_TTL.type,
-    oracleTtlValue: ORACLE_TTL.value,
+    _isInternalBuild: true,
     ...options,
     tag: Tag.OracleExtendTx,
     oracleId,
@@ -215,8 +188,7 @@ Awaited<ReturnType<typeof sendTransaction>> & Awaited<ReturnType<typeof getOracl
 }
 
 type ExtendOracleTtlOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1]
-& BuildTxOptions<Tag.OracleExtendTx, 'oracleTtlType' | 'oracleTtlValue' | 'callerId' | 'oracleId'>
-& { oracleTtlType?: ORACLE_TTL_TYPES; oracleTtlValue?: number };
+& BuildTxOptions<Tag.OracleExtendTx, 'callerId' | 'oracleId'>;
 interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {}
 
 /**
@@ -225,9 +197,6 @@ interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {}
  * @param queryId - Oracle query id
  * @param response - Oracle query response
  * @param options - Options object
- * @param options.responseTtl - responseTtl Query response time to leave
- * @param options.fee - Transaction fee
- * @param options.ttl - Transaction time to leave
  * @returns Oracle object
  */
 export async function respondToQuery(
@@ -239,8 +208,7 @@ export async function respondToQuery(
   > {
   const oracleId = encode(decode(options.onAccount.address), Encoding.OracleAddress);
   const oracleRespondTx = await buildTxAsync({
-    responseTtlType: RESPONSE_TTL.type,
-    responseTtlValue: RESPONSE_TTL.value,
+    _isInternalBuild: true,
     ...options,
     tag: Tag.OracleResponseTx,
     oracleId,
@@ -255,8 +223,7 @@ export async function respondToQuery(
 }
 
 type RespondToQueryOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1]
-& BuildTxOptions<Tag.OracleResponseTx, 'callerId' | 'oracleId' | 'queryId' | 'response' | 'responseTtlType' | 'responseTtlValue'>
-& { responseTtlType?: ORACLE_TTL_TYPES; responseTtlValue?: number };
+& BuildTxOptions<Tag.OracleResponseTx, 'callerId' | 'oracleId' | 'queryId' | 'response'>;
 interface RespondToQueryOptions extends RespondToQueryOptionsType {}
 
 /**
@@ -315,11 +282,6 @@ interface GetOracleObjectReturnType extends Awaited<ReturnType<Node['getOracleBy
  * @param queryFormat - Format of query
  * @param responseFormat - Format of query response
  * @param options - Options
- * @param options.queryFee - Oracle query Fee
- * @param options - Options object
- * @param options.abiVersion - Always 0 (do not use virtual machine)
- * @param options.fee - Transaction fee
- * @param options.ttl - Transaction time to leave
  * @returns Oracle object
  */
 export async function registerOracle(
@@ -331,8 +293,7 @@ export async function registerOracle(
   > {
   const accountId = options.onAccount.address;
   const oracleRegisterTx = await buildTxAsync({
-    oracleTtlValue: ORACLE_TTL.value,
-    oracleTtlType: ORACLE_TTL.type,
+    _isInternalBuild: true,
     ...options,
     tag: Tag.OracleRegisterTx,
     accountId,
@@ -346,9 +307,5 @@ export async function registerOracle(
 }
 
 type RegisterOracleOptionsType = SendTransactionOptions & Parameters<typeof getOracleObject>[1]
-& BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat' | 'oracleTtlType' | 'oracleTtlValue'>
-& {
-  oracleTtlType?: ORACLE_TTL_TYPES;
-  oracleTtlValue?: number;
-};
+& BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat'>;
 interface RegisterOracleOptions extends RegisterOracleOptionsType {}

package/src/send-transaction.ts

@@ -0,0 +1,136 @@
+import verifyTransaction, { ValidatorResult } from './tx/validator';
+import { ensureError } from './utils/other';
+import { TransactionError } from './utils/errors';
+import Node, { TransformNodeType } from './Node';
+import { SignedTx } from './apis/node';
+import { Encoded } from './utils/encoder';
+import AccountBase from './account/Base';
+import { buildTxHash } from './tx/builder';
+import { poll, waitForTxConfirm } from './chain';
+
+/**
+ * @category exception
+ */
+export class InvalidTxError extends TransactionError {
+  validation: ValidatorResult[];
+
+  transaction: Encoded.Transaction;
+
+  constructor(
+    message: string,
+    validation: ValidatorResult[],
+    transaction: Encoded.Transaction,
+  ) {
+    super(message);
+    this.name = 'InvalidTxError';
+    this.validation = validation;
+    this.transaction = transaction;
+  }
+}
+
+/**
+ * Signs and submits transaction for mining
+ * @category chain
+ * @param txUnsigned - Transaction to sign and submit
+ * @param options - Options
+ * @returns Transaction details
+ */
+export async function sendTransaction(
+  txUnsigned: Encoded.Transaction,
+  {
+    onNode, onAccount, verify = true, waitMined = true, confirm, innerTx, ...options
+  }:
+  SendTransactionOptions,
+): Promise<SendTransactionReturnType> {
+  const tx = await onAccount.signTransaction(txUnsigned, {
+    ...options,
+    onNode,
+    innerTx,
+    networkId: await onNode.getNetworkId(),
+  });
+
+  if (innerTx === true) return { hash: buildTxHash(tx), rawTx: tx };
+
+  if (verify) {
+    const validation = await verifyTransaction(tx, onNode);
+    if (validation.length > 0) {
+      const message = `Transaction verification errors: ${
+        validation.map((v: { message: string }) => v.message).join(', ')}`;
+      throw new InvalidTxError(message, validation, tx);
+    }
+  }
+
+  try {
+    let __queue;
+    try {
+      __queue = onAccount != null ? `tx-${onAccount.address}` : null;
+    } catch (error) {
+      __queue = null;
+    }
+    const { txHash } = await onNode.postTransaction({ tx }, {
+      requestOptions: {
+        customHeaders: {
+          // TODO: remove __retry-code after fixing https://github.com/aeternity/aeternity/issues/3803
+          '__retry-code': '400',
+          ...__queue != null ? { __queue } : {},
+        },
+      },
+    });
+
+    if (waitMined) {
+      const pollResult = await poll(txHash, { onNode, ...options });
+      const txData = {
+        ...pollResult,
+        hash: pollResult.hash as Encoded.TxHash,
+        rawTx: tx,
+      };
+      // wait for transaction confirmation
+      if (confirm != null && +confirm > 0) {
+        const c = typeof confirm === 'boolean' ? undefined : confirm;
+        return {
+          ...txData,
+          confirmationHeight: await waitForTxConfirm(txHash, { onNode, confirm: c, ...options }),
+        };
+      }
+      return txData;
+    }
+    return { hash: txHash, rawTx: tx };
+  } catch (error) {
+    ensureError(error);
+    throw Object.assign(error, {
+      rawTx: tx,
+      verifyTx: async () => verifyTransaction(tx, onNode),
+    });
+  }
+}
+
+type SendTransactionOptionsType = {
+  /**
+   * Node to use
+   */
+  onNode: Node;
+  /**
+   * Account to use
+   */
+  onAccount: AccountBase;
+  /**
+   * Verify transaction before broadcast, throw error if not
+   */
+  verify?: boolean;
+  /**
+   * Ensure that transaction get into block
+   */
+  waitMined?: boolean;
+  /**
+   * Number of micro blocks that should be mined after tx get included
+   */
+  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;
+  // TODO: use `SignedTx.encodedTx` instead
+  rawTx: Encoded.Transaction;
+  confirmationHeight?: number;
+}

package/src/spend.ts

@@ -1,10 +1,9 @@
 import BigNumber from 'bignumber.js';
-import {
-  sendTransaction, getBalance, resolveName, SendTransactionOptions,
-} from './chain';
+import { getBalance, resolveName } from './chain';
+import { sendTransaction, SendTransactionOptions } from './send-transaction';
 import { buildTxAsync, BuildTxOptions, unpackTx } from './tx/builder';
 import { ArgumentError } from './utils/errors';
-import { Encoded, Encoding } from './utils/encoder';
+import { Encoded } from './utils/encoder';
 import { Tag, AensName } from './tx/builder/constants';
 import AccountBase from './account/Base';
 
@@ -18,15 +17,16 @@ import AccountBase from './account/Base';
  */
 export async function spend(
   amount: number | string,
-  recipientIdOrName: Encoded.AccountAddress | AensName,
+  recipientIdOrName: Encoded.AccountAddress | Encoded.ContractAddress | AensName,
   options: SpendOptions,
 ): ReturnType<typeof sendTransaction> {
   return sendTransaction(
     await buildTxAsync({
+      _isInternalBuild: true,
       ...options,
       tag: Tag.SpendTx,
       senderId: options.onAccount.address,
-      recipientId: await resolveName<Encoding.AccountAddress>(
+      recipientId: await resolveName(
         recipientIdOrName,
         'account_pubkey',
         options,
@@ -61,13 +61,13 @@ interface SpendOptions extends SpendOptionsType {}
  */
 export async function transferFunds(
   fraction: number | string, // TODO: accept only number
-  recipientIdOrName: AensName | Encoded.AccountAddress,
+  recipientIdOrName: AensName | Encoded.AccountAddress | Encoded.ContractAddress,
   options: TransferFundsOptions,
 ): ReturnType<typeof sendTransaction> {
   if (+fraction < 0 || +fraction > 1) {
     throw new ArgumentError('fraction', 'a number between 0 and 1', fraction);
   }
-  const recipientId = await resolveName<Encoding.AccountAddress>(
+  const recipientId = await resolveName(
     recipientIdOrName,
     'account_pubkey',
     options,
@@ -79,7 +79,12 @@ export async function transferFunds(
   const desiredAmount = balance.times(fraction).integerValue(BigNumber.ROUND_HALF_UP);
   const { fee } = unpackTx(
     await buildTxAsync({
-      ...options, tag: Tag.SpendTx, senderId, recipientId, amount: desiredAmount,
+      _isInternalBuild: true,
+      ...options,
+      tag: Tag.SpendTx,
+      senderId,
+      recipientId,
+      amount: desiredAmount,
     }),
     Tag.SpendTx,
   );
@@ -87,7 +92,12 @@ export async function transferFunds(
   const amount = desiredAmount.plus(fee).gt(balance) ? balance.minus(fee) : desiredAmount;
   return sendTransaction(
     await buildTxAsync({
-      ...options, tag: Tag.SpendTx, senderId, recipientId, amount,
+      _isInternalBuild: true,
+      ...options,
+      tag: Tag.SpendTx,
+      senderId,
+      recipientId,
+      amount,
     }),
     options,
   );
@@ -110,7 +120,11 @@ export async function payForTransaction(
 ): ReturnType<typeof sendTransaction> {
   return sendTransaction(
     await buildTxAsync({
-      ...options, tag: Tag.PayingForTx, payerId: options.onAccount.address, tx: transaction,
+      _isInternalBuild: true,
+      ...options,
+      tag: Tag.PayingForTx,
+      payerId: options.onAccount.address,
+      tx: transaction,
     }),
     options,
   );

package/src/tx/builder/common.ts

@@ -0,0 +1,74 @@
+import { decode as rlpDecode, encode as rlpEncode } from 'rlp';
+import { Field, BinaryData } from './field-types';
+import {
+  ArgumentError, DecodeError, SchemaNotFoundError, InternalError,
+} from '../../utils/errors';
+import {
+  Encoding, Encoded, encode, decode,
+} from '../../utils/encoder';
+import { readInt } from './helpers';
+
+type Schemas = ReadonlyArray<{
+  tag: { constValue: number } & Field;
+  version: { constValue: number; constValueOptional: boolean } & Field;
+}>;
+
+export function getSchema(
+  schemas: Schemas,
+  Tag: { [key: number]: string },
+  tag: number,
+  version: number | undefined,
+): Array<[string, Field]> {
+  const subSchemas = schemas.filter((s) => s.tag.constValue === tag);
+  if (subSchemas.length === 0) throw new SchemaNotFoundError(`${Tag[tag]} (${tag})`, 0);
+  if (version == null) {
+    const defaultSchema = subSchemas.find((schema) => schema.version.constValueOptional);
+    if (defaultSchema == null) throw new InternalError(`Can't find default schema of ${Tag[tag]} (${tag})`);
+    version = defaultSchema.version.constValue;
+  }
+  const schema = subSchemas.find((s) => s.version.constValue === version);
+  if (schema == null) throw new SchemaNotFoundError(`${Tag[tag]} (${tag})`, version);
+  return Object.entries(schema);
+}
+
+export function packRecord<E extends Encoding>(
+  schemas: Schemas,
+  Tag: { [key: number]: string },
+  params: {
+    tag: number;
+    version?: number;
+    [k: string]: unknown;
+  },
+  extraParams: { [k: string]: unknown },
+  encoding: E,
+): Encoded.Generic<E> {
+  const schema = getSchema(schemas, Tag, params.tag, params.version);
+  const binary = schema.map(([key, field]) => (
+    field.serialize(params[key], { ...params, ...extraParams }, params)
+  ));
+  return encode(rlpEncode(binary), encoding);
+}
+
+export function unpackRecord(
+  schemas: Schemas,
+  Tag: { [key: number]: string },
+  encodedRecord: Encoded.Any,
+  expectedTag: number | undefined,
+  extraParams: { [k: string]: unknown },
+): unknown {
+  const binary = rlpDecode(decode(encodedRecord));
+  const tag = +readInt(binary[0] as Buffer);
+  const version = +readInt(binary[1] as Buffer);
+  const schema = getSchema(schemas, Tag, tag, version);
+  if (expectedTag != null && expectedTag !== tag) {
+    throw new DecodeError(`Expected ${Tag[expectedTag]} tag, got ${Tag[tag]} instead`);
+  }
+  if (binary.length !== schema.length) {
+    throw new ArgumentError('RLP length', schema.length, binary.length);
+  }
+  return Object.fromEntries(
+    schema.map(([name, field], index) => [
+      name, field.deserialize(binary[index] as BinaryData, extraParams),
+    ]),
+  );
+}

package/src/tx/builder/constants.ts

@@ -1,18 +1,15 @@
 import BigNumber from 'bignumber.js';
 import { mapObject } from '../../utils/other';
 
+export const DRY_RUN_ACCOUNT = {
+  pub: 'ak_11111111111111111111111111111111273Yts',
+  amount: 100000000000000000000000000000000000n,
+} as const;
+
 export const MAX_AUTH_FUN_GAS = 50000;
 export type Int = number | string | BigNumber;
-// # AENS
 export type AensName = `${string}.chain`;
-export const NAME_TTL = 180000;
-// # max number of block into the future that the name is going to be available
-// # https://github.com/aeternity/protocol/blob/epoch-v0.22.0/AENS.md#update
-// # https://github.com/aeternity/protocol/blob/44a93d3aab957ca820183c3520b9daf6b0fedff4/AENS.md#aens-entry
-export const NAME_MAX_TTL = 36000;
-export const NAME_MAX_CLIENT_TTL = 84600;
-export const CLIENT_TTL = NAME_MAX_CLIENT_TTL;
-export const MIN_GAS_PRICE = 1e9;
+export const MIN_GAS_PRICE = 1e9; // TODO: don't use number for ae
 // # see https://github.com/aeternity/aeternity/blob/72e440b8731422e335f879a31ecbbee7ac23a1cf/apps/aecore/src/aec_governance.erl#L67
 export const NAME_FEE_MULTIPLIER = 1e14; // 100000000000000
 export const NAME_FEE_BID_INCREMENT = 0.05; // # the increment is in percentage

package/src/tx/builder/delegation/index.ts

@@ -0,0 +1,28 @@
+import { Encoded, Encoding } from '../../../utils/encoder';
+import { packRecord, unpackRecord } from '../common';
+import { DelegationTag, schemas } from './schema';
+import { DlgParams, DlgUnpacked } from './schema.generated';
+
+/**
+ * Pack delegation
+ * @category delegation signature
+ * @param params - Params of delegation
+ * @returns Encoded delegation
+ */
+export function packDelegation(params: DlgParams): Encoded.Bytearray {
+  return packRecord(schemas, DelegationTag, params, {}, Encoding.Bytearray);
+}
+
+/**
+ * Unpack delegation
+ * @category delegation signature
+ * @param encoded - Encoded delegation
+ * @param expectedTag - Expected delegation signature type
+ * @returns Params of delegation
+ */
+export function unpackDelegation<T extends DelegationTag>(
+  encoded: Encoded.Bytearray,
+  expectedTag?: T,
+): DlgUnpacked & { tag: T } {
+  return unpackRecord(schemas, DelegationTag, encoded, expectedTag, {}) as any;
+}

package/src/tx/builder/delegation/schema.generated.ts

@@ -0,0 +1,143 @@
+/* eslint-disable */
+// This file generated by `npm run build:generate`, don't edit manually.
+
+import { DlgParams as DlgParamsComplex, DlgUnpacked as DlgUnpackedComplex } from "./schema";
+import { DelegationTag as Tag } from "./schema";
+/**
+ * @category delegation signature
+ */
+type DlgParamsAensWildcard1Type = Omit<DlgParamsComplex & {
+    tag: Tag.AensWildcard;
+    version: 1;
+}, "version"> & {
+    version?: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgParamsAensWildcard1 extends DlgParamsAensWildcard1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgUnpackedAensWildcard1Type = DlgUnpackedComplex & {
+    tag: Tag.AensWildcard;
+    version: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgUnpackedAensWildcard1 extends DlgUnpackedAensWildcard1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgParamsAensName1Type = Omit<DlgParamsComplex & {
+    tag: Tag.AensName;
+    version: 1;
+}, "version"> & {
+    version?: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgParamsAensName1 extends DlgParamsAensName1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgUnpackedAensName1Type = DlgUnpackedComplex & {
+    tag: Tag.AensName;
+    version: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgUnpackedAensName1 extends DlgUnpackedAensName1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgParamsAensPreclaim1Type = Omit<DlgParamsComplex & {
+    tag: Tag.AensPreclaim;
+    version: 1;
+}, "version"> & {
+    version?: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgParamsAensPreclaim1 extends DlgParamsAensPreclaim1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgUnpackedAensPreclaim1Type = DlgUnpackedComplex & {
+    tag: Tag.AensPreclaim;
+    version: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgUnpackedAensPreclaim1 extends DlgUnpackedAensPreclaim1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgParamsOracle1Type = Omit<DlgParamsComplex & {
+    tag: Tag.Oracle;
+    version: 1;
+}, "version"> & {
+    version?: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgParamsOracle1 extends DlgParamsOracle1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgUnpackedOracle1Type = DlgUnpackedComplex & {
+    tag: Tag.Oracle;
+    version: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgUnpackedOracle1 extends DlgUnpackedOracle1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgParamsOracleResponse1Type = Omit<DlgParamsComplex & {
+    tag: Tag.OracleResponse;
+    version: 1;
+}, "version"> & {
+    version?: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgParamsOracleResponse1 extends DlgParamsOracleResponse1Type {
+}
+/**
+ * @category delegation signature
+ */
+type DlgUnpackedOracleResponse1Type = DlgUnpackedComplex & {
+    tag: Tag.OracleResponse;
+    version: 1;
+};
+/**
+ * @category delegation signature
+ */
+export interface DlgUnpackedOracleResponse1 extends DlgUnpackedOracleResponse1Type {
+}
+/**
+ * @category delegation signature
+ */
+export type DlgParams = DlgParamsAensWildcard1 | DlgParamsAensName1 | DlgParamsAensPreclaim1 | DlgParamsOracle1 | DlgParamsOracleResponse1;
+/**
+ * @category delegation signature
+ */
+export type DlgUnpacked = DlgUnpackedAensWildcard1 | DlgUnpackedAensName1 | DlgUnpackedAensPreclaim1 | DlgUnpackedOracle1 | DlgUnpackedOracleResponse1;