@aeternity/aepp-sdk 12.0.0 → 12.1.2

package/es/oracle.d.ts

@@ -5,36 +5,19 @@
  * https://github.com/aeternity/protocol/blob/master/ORACLE.md in the protocol
  * repository.
  */
+import BigNumber from 'bignumber.js';
 import { send, SendOptions } from './spend';
-import { ORACLE_TTL_TYPES, TX_TYPE } from './tx/builder/schema';
-import { EncodedData } from './utils/encoder';
+import { ORACLE_TTL_TYPES } from './tx/builder/schema';
+import { Tag } from './tx/builder/constants';
+import { Encoded } from './utils/encoder';
 import { _getPollInterval } from './chain';
 import { BuildTxOptions } from './tx';
 import Node from './Node';
-import BigNumber from 'bignumber.js';
 import AccountBase from './account/Base';
 declare type OracleQueries = Awaited<ReturnType<Node['getOracleQueriesByPubkey']>>['oracleQueries'];
-/**
- * Constructor for Oracle Object (helper object for using Oracle)
- * @param oracleId - Oracle public key
- * @param options - Options
- * @returns Oracle object
- */
-export declare function getOracleObject(oracleId: EncodedData<'ok'>, options: {
-    onNode: Node;
-    onAccount: AccountBase;
-}): Promise<GetOracleObjectReturnType>;
-interface GetOracleObjectReturnType extends Awaited<ReturnType<Node['getOracleByPubkey']>> {
-    id: EncodedData<'ok'>;
-    queries: OracleQueries;
-    pollQueries: (cb: Parameters<typeof pollForQueries>[1]) => ReturnType<typeof pollForQueries>;
-    postQuery: Function;
-    respondToQuery: Function;
-    extendOracle: Function;
-    getQuery: Function;
-}
 /**
  * Poll for oracle queries
+ * @category oracle
  * @param oracleId - Oracle public key
  * @param onQuery - OnQuery callback
  * @param options - Options object
@@ -42,61 +25,42 @@ interface GetOracleObjectReturnType extends Awaited<ReturnType<Node['getOracleBy
  * @param options.onNode - Node to use
  * @returns Callback to stop polling function
  */
-export declare function pollForQueries(oracleId: EncodedData<'ok'>, onQuery: (queries: OracleQueries) => void, { interval, onNode, ...options }: {
+export declare function pollForQueries(oracleId: Encoded.OracleAddress, onQuery: (queries: OracleQueries) => void, { interval, onNode, ...options }: {
     interval?: number;
     onNode: Node;
 } & Parameters<typeof _getPollInterval>[1]): () => void;
-/**
- * Constructor for OracleQuery Object (helper object for using OracleQuery)
- * @param oracleId - Oracle public key
- * @param queryId - Oracle Query id
- * @param options - Options
- * @returns OracleQuery object
- */
-export declare function getQueryObject(oracleId: EncodedData<'ok'>, queryId: EncodedData<'oq'>, options: RespondToQueryOptions & Parameters<typeof pollForQueryResponse>[2]): Promise<GetQueryObjectReturnType>;
-interface GetQueryObjectReturnType extends Awaited<ReturnType<Node['getOracleQueryByPubkeyAndQueryId']>> {
-    decodedQuery: string;
-    decodedResponse: string;
-    respond: (response: string, options?: Parameters<typeof respondToQuery>[3]) => ReturnType<typeof respondToQuery>;
-    pollForResponse: (options?: Parameters<typeof pollForQueryResponse>[2]) => ReturnType<typeof pollForQueryResponse>;
-}
 /**
  * Poll for oracle query response
+ * @category oracle
  * @param oracleId - Oracle public key
  * @param queryId - Oracle Query id
  * @param options - Options object
- * @param options.attempts - Poll attempts
  * @param options.interval - Poll interval
  * @param options.onNode - Node to use
  * @returns OracleQuery object
  */
-export declare function pollForQueryResponse(oracleId: EncodedData<'ok'>, queryId: EncodedData<'oq'>, { attempts, interval, onNode, ...options }: {
-    attempts?: number;
+export declare function pollForQueryResponse(oracleId: Encoded.OracleAddress, queryId: Encoded.OracleQueryId, { interval, onNode, ...options }: {
     interval?: number;
     onNode: Node;
 } & Parameters<typeof _getPollInterval>[1]): Promise<string>;
 /**
- * Register oracle
- * @param queryFormat - Format of query
- * @param responseFormat - Format of query response
+ * Constructor for OracleQuery Object (helper object for using OracleQuery)
+ * @category oracle
+ * @param oracleId - Oracle public key
+ * @param queryId - Oracle Query id
  * @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
+ * @returns OracleQuery object
  */
-export declare function registerOracle(queryFormat: string, responseFormat: string, options: RegisterOracleOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>>;
-declare type RegisterOracleOptionsType = SendOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<TX_TYPE.oracleRegister, 'accountId' | 'queryFormat' | 'responseFormat' | 'queryFee' | 'oracleTtlType' | 'oracleTtlValue'> & {
-    queryFee?: number | string | BigNumber;
-    oracleTtlType?: ORACLE_TTL_TYPES;
-    oracleTtlValue?: number;
-};
-interface RegisterOracleOptions extends RegisterOracleOptionsType {
+export declare function getQueryObject(oracleId: Encoded.OracleAddress, queryId: Encoded.OracleQueryId, options: RespondToQueryOptions & Parameters<typeof pollForQueryResponse>[2]): Promise<GetQueryObjectReturnType>;
+interface GetQueryObjectReturnType extends Awaited<ReturnType<Node['getOracleQueryByPubkeyAndQueryId']>> {
+    decodedQuery: string;
+    decodedResponse: string;
+    respond: (response: string, options?: Parameters<typeof respondToQuery>[3]) => ReturnType<typeof respondToQuery>;
+    pollForResponse: (options?: Parameters<typeof pollForQueryResponse>[2]) => ReturnType<typeof pollForQueryResponse>;
 }
 /**
  * Post query to oracle
+ * @category oracle
  * @param oracleId - Oracle public key
  * @param query - Oracle query object
  * @param options - Options object
@@ -107,8 +71,8 @@ interface RegisterOracleOptions extends RegisterOracleOptionsType {
  * @param options.ttl - Transaction time to leave
  * @returns Query object
  */
-export declare function postQueryToOracle(oracleId: EncodedData<'ok'>, query: string, options: PostQueryToOracleOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getQueryObject>>>;
-declare type PostQueryToOracleOptionsType = Parameters<typeof send>[1] & Parameters<typeof getQueryObject>[2] & BuildTxOptions<TX_TYPE.oracleQuery, 'oracleId' | 'senderId' | 'query' | 'queryTtlType' | 'queryTtlValue' | 'responseTtlType' | 'responseTtlValue'> & {
+export declare function postQueryToOracle(oracleId: Encoded.OracleAddress, query: string, options: PostQueryToOracleOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getQueryObject>>>;
+declare type PostQueryToOracleOptionsType = Parameters<typeof send>[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;
@@ -118,6 +82,7 @@ interface PostQueryToOracleOptions extends PostQueryToOracleOptionsType {
 }
 /**
  * Extend oracle ttl
+ * @category oracle
  * @param oracleId - Oracle public key
  * @param options - Options object
  * @param options.fee - fee Transaction fee
@@ -126,8 +91,8 @@ interface PostQueryToOracleOptions extends PostQueryToOracleOptionsType {
  * @param options.oracleTtlValue - Oracle time to leave for extend
  * @returns Oracle object
  */
-export declare function extendOracleTtl(oracleId: EncodedData<'ok'>, options: ExtendOracleTtlOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>>;
-declare type ExtendOracleTtlOptionsType = SendOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<TX_TYPE.oracleExtend, 'oracleTtlType' | 'oracleTtlValue' | 'callerId' | 'oracleId'> & {
+export declare function extendOracleTtl(oracleId: Encoded.OracleAddress, options: ExtendOracleTtlOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>>;
+declare type ExtendOracleTtlOptionsType = SendOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleExtendTx, 'oracleTtlType' | 'oracleTtlValue' | 'callerId' | 'oracleId'> & {
     oracleTtlType?: ORACLE_TTL_TYPES;
     oracleTtlValue?: number;
 };
@@ -135,6 +100,7 @@ interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {
 }
 /**
  * Extend oracle ttl
+ * @category oracle
  * @param oracleId - Oracle public key
  * @param queryId - Oracle query id
  * @param response - Oracle query response
@@ -144,11 +110,52 @@ interface ExtendOracleTtlOptions extends ExtendOracleTtlOptionsType {
  * @param options.ttl - Transaction time to leave
  * @returns Oracle object
  */
-export declare function respondToQuery(oracleId: EncodedData<'ok'>, queryId: EncodedData<'oq'>, response: string, options: RespondToQueryOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>>;
-declare type RespondToQueryOptionsType = SendOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<TX_TYPE.oracleResponse, 'callerId' | 'oracleId' | 'queryId' | 'response' | 'responseTtlType' | 'responseTtlValue'> & {
+export declare function respondToQuery(oracleId: Encoded.OracleAddress, queryId: Encoded.OracleQueryId, response: string, options: RespondToQueryOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>>;
+declare type RespondToQueryOptionsType = SendOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleResponseTx, 'callerId' | 'oracleId' | 'queryId' | 'response' | 'responseTtlType' | 'responseTtlValue'> & {
     responseTtlType?: ORACLE_TTL_TYPES;
     responseTtlValue?: number;
 };
 interface RespondToQueryOptions extends RespondToQueryOptionsType {
 }
+/**
+ * Constructor for Oracle Object (helper object for using Oracle)
+ * @category oracle
+ * @param oracleId - Oracle public key
+ * @param options - Options
+ * @returns Oracle object
+ */
+export declare function getOracleObject(oracleId: Encoded.OracleAddress, options: {
+    onNode: Node;
+    onAccount: AccountBase;
+}): Promise<GetOracleObjectReturnType>;
+interface GetOracleObjectReturnType extends Awaited<ReturnType<Node['getOracleByPubkey']>> {
+    id: Encoded.OracleAddress;
+    queries: OracleQueries;
+    pollQueries: (cb: Parameters<typeof pollForQueries>[1]) => ReturnType<typeof pollForQueries>;
+    postQuery: Function;
+    respondToQuery: Function;
+    extendOracle: Function;
+    getQuery: Function;
+}
+/**
+ * Register oracle
+ * @category oracle
+ * @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 declare function registerOracle(queryFormat: string, responseFormat: string, options: RegisterOracleOptions): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>>;
+declare type RegisterOracleOptionsType = SendOptions & Parameters<typeof getOracleObject>[1] & BuildTxOptions<Tag.OracleRegisterTx, 'accountId' | 'queryFormat' | 'responseFormat' | 'queryFee' | 'oracleTtlType' | 'oracleTtlValue'> & {
+    queryFee?: number | string | BigNumber;
+    oracleTtlType?: ORACLE_TTL_TYPES;
+    oracleTtlValue?: number;
+};
+interface RegisterOracleOptions extends RegisterOracleOptionsType {
+}
 export {};

package/es/oracle.mjs

@@ -24,51 +24,18 @@
  */
 import { send } from "./spend.mjs";
 import { mapObject, pause } from "./utils/other.mjs";
-import { oracleQueryId, decode, encode } from "./tx/builder/helpers.mjs";
+import { oracleQueryId } from "./tx/builder/helpers.mjs";
 import { unpackTx } from "./tx/builder/index.mjs";
-import { ORACLE_TTL, QUERY_FEE, QUERY_TTL, RESPONSE_TTL, TX_TYPE } from "./tx/builder/schema.mjs";
+import { ORACLE_TTL, QUERY_FEE, QUERY_TTL, RESPONSE_TTL } from "./tx/builder/schema.mjs";
+import { Tag } from "./tx/builder/constants.mjs";
 import { RequestTimedOutError } from "./utils/errors.mjs";
+import { decode, encode, Encoding } from "./utils/encoder.mjs";
 import { _getPollInterval } from "./chain.mjs";
 import { _buildTx } from "./tx/index.mjs";
 
-/**
- * Constructor for Oracle Object (helper object for using Oracle)
- * @param oracleId - Oracle public key
- * @param options - Options
- * @returns Oracle object
- */
-export async function getOracleObject(oracleId, options) {
-  return { ...(await options.onNode.getOracleByPubkey(oracleId)),
-    queries: (await options.onNode.getOracleQueriesByPubkey(oracleId)).oracleQueries,
-    ...mapObject({
-      pollQueries: pollForQueries,
-      postQuery: postQueryToOracle,
-      respondToQuery,
-      extendOracle: extendOracleTtl,
-      getQuery: getQueryObject
-    }, _ref => {
-      let [name, handler] = _ref;
-      return [name, function () {
-        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-          args[_key] = arguments[_key];
-        }
-
-        const lastArg = args[args.length - 1];
-
-        if (lastArg != null && typeof lastArg === 'object' && lastArg.constructor === Object) {
-          Object.assign(lastArg, { ...options,
-            ...lastArg
-          });
-        } else args.push(options);
-
-        return handler(oracleId, ...args);
-      }];
-    })
-  };
-}
-
 /**
  * Poll for oracle queries
+ * @category oracle
  * @param oracleId - Oracle public key
  * @param onQuery - OnQuery callback
  * @param options - Options object
@@ -76,30 +43,30 @@ export async function getOracleObject(oracleId, options) {
  * @param options.onNode - Node to use
  * @returns Callback to stop polling function
  */
-export function pollForQueries(oracleId, onQuery, _ref2) {
+export function pollForQueries(oracleId, onQuery, _ref) {
   var _interval;
 
   let {
     interval,
     onNode,
     ...options
-  } = _ref2;
+  } = _ref;
   (_interval = interval) !== null && _interval !== void 0 ? _interval : interval = _getPollInterval('microblock', options);
   const knownQueryIds = new Set();
 
   const checkNewQueries = async () => {
     var _await$onNode$getOrac;
 
-    const queries = ((_await$onNode$getOrac = (await onNode.getOracleQueriesByPubkey(oracleId)).oracleQueries) !== null && _await$onNode$getOrac !== void 0 ? _await$onNode$getOrac : []).filter(_ref3 => {
+    const queries = ((_await$onNode$getOrac = (await onNode.getOracleQueriesByPubkey(oracleId)).oracleQueries) !== null && _await$onNode$getOrac !== void 0 ? _await$onNode$getOrac : []).filter(_ref2 => {
       let {
         id
-      } = _ref3;
+      } = _ref2;
       return !knownQueryIds.has(id);
     });
-    queries.forEach(_ref4 => {
+    queries.forEach(_ref3 => {
       let {
         id
-      } = _ref4;
+      } = _ref3;
       return knownQueryIds.add(id);
     });
     if (queries.length > 0) onQuery(queries);
@@ -120,91 +87,70 @@ export function pollForQueries(oracleId, onQuery, _ref2) {
     stopped = true;
   };
 }
-/**
- * Constructor for OracleQuery Object (helper object for using OracleQuery)
- * @param oracleId - Oracle public key
- * @param queryId - Oracle Query id
- * @param options - Options
- * @returns OracleQuery object
- */
-
-export async function getQueryObject(oracleId, queryId, options) {
-  const record = await options.onNode.getOracleQueryByPubkeyAndQueryId(oracleId, queryId);
-  return { ...record,
-    decodedQuery: decode(record.query).toString(),
-    decodedResponse: decode(record.response).toString(),
-    respond: async (response, opt) => await respondToQuery(oracleId, queryId, response, { ...options,
-      ...opt
-    }),
-    pollForResponse: async opt => await pollForQueryResponse(oracleId, queryId, { ...options,
-      ...opt
-    })
-  };
-}
-
 /**
  * Poll for oracle query response
+ * @category oracle
  * @param oracleId - Oracle public key
  * @param queryId - Oracle Query id
  * @param options - Options object
- * @param options.attempts - Poll attempts
  * @param options.interval - Poll interval
  * @param options.onNode - Node to use
  * @returns OracleQuery object
  */
-export async function pollForQueryResponse(oracleId, queryId, _ref5) {
+
+export async function pollForQueryResponse(oracleId, queryId, _ref4) {
   var _interval2;
 
   let {
-    attempts = 20,
     interval,
     onNode,
     ...options
-  } = _ref5;
+  } = _ref4;
   (_interval2 = interval) !== null && _interval2 !== void 0 ? _interval2 : interval = _getPollInterval('microblock', options);
+  let height;
+  let ttl;
+  let response;
 
-  for (let i = 0; i < attempts; i++) {
-    if (i > 0) await pause(interval);
-    const {
-      response
-    } = await onNode.getOracleQueryByPubkeyAndQueryId(oracleId, queryId);
+  do {
+    if (height != null) await pause(interval);
+    ({
+      response,
+      ttl
+    } = await onNode.getOracleQueryByPubkeyAndQueryId(oracleId, queryId));
     const responseBuffer = decode(response);
     if (responseBuffer.length > 0) return responseBuffer.toString();
-  }
+    height = await this.getHeight();
+  } while (ttl >= height);
 
-  throw new RequestTimedOutError((attempts - 1) * interval);
+  throw new RequestTimedOutError(height);
 }
 /**
- * Register oracle
- * @param queryFormat - Format of query
- * @param responseFormat - Format of query response
+ * Constructor for OracleQuery Object (helper object for using OracleQuery)
+ * @category oracle
+ * @param oracleId - Oracle public key
+ * @param queryId - Oracle Query id
  * @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
+ * @returns OracleQuery object
  */
 
-export async function registerOracle(queryFormat, responseFormat, options) {
-  const accountId = await options.onAccount.address(options);
-  const oracleRegisterTx = await _buildTx(TX_TYPE.oracleRegister, {
-    queryFee: QUERY_FEE,
-    oracleTtlValue: ORACLE_TTL.value,
-    oracleTtlType: ORACLE_TTL.type,
-    ...options,
-    accountId,
-    queryFormat,
-    responseFormat
-  });
-  return { ...(await send(oracleRegisterTx, options)),
-    ...(await getOracleObject(encode(decode(accountId), 'ok'), options))
+export async function getQueryObject(oracleId, queryId, options) {
+  const record = await options.onNode.getOracleQueryByPubkeyAndQueryId(oracleId, queryId);
+  return { ...record,
+    decodedQuery: decode(record.query).toString(),
+    decodedResponse: decode(record.response).toString(),
+    respond: async (response, opt) => // eslint-disable-next-line @typescript-eslint/no-use-before-define
+    respondToQuery(oracleId, queryId, response, { ...options,
+      ...opt
+    }),
+    pollForResponse: async opt => pollForQueryResponse(oracleId, queryId, { ...options,
+      ...opt
+    })
   };
 }
 
 /**
  * Post query to oracle
+ * @category oracle
  * @param oracleId - Oracle public key
  * @param query - Oracle query object
  * @param options - Options object
@@ -220,7 +166,7 @@ export async function postQueryToOracle(oracleId, query, options) {
 
   (_options$queryFee = options.queryFee) !== null && _options$queryFee !== void 0 ? _options$queryFee : options.queryFee = (await options.onNode.getOracleByPubkey(oracleId)).queryFee.toString();
   const senderId = await options.onAccount.address(options);
-  const oracleQueryTx = await _buildTx(TX_TYPE.oracleQuery, {
+  const oracleQueryTx = await _buildTx(Tag.OracleQueryTx, {
     queryTtlType: QUERY_TTL.type,
     queryTtlValue: QUERY_TTL.value,
     responseTtlType: RESPONSE_TTL.type,
@@ -230,7 +176,9 @@ export async function postQueryToOracle(oracleId, query, options) {
     senderId,
     query
   });
-  const nonce = unpackTx(oracleQueryTx, TX_TYPE.oracleQuery).tx.nonce;
+  const {
+    nonce
+  } = unpackTx(oracleQueryTx, Tag.OracleQueryTx).tx;
   const queryId = oracleQueryId(senderId, nonce, oracleId);
   return { ...(await send(oracleQueryTx, options)),
     ...(await getQueryObject(oracleId, queryId, options))
@@ -239,6 +187,7 @@ export async function postQueryToOracle(oracleId, query, options) {
 
 /**
  * Extend oracle ttl
+ * @category oracle
  * @param oracleId - Oracle public key
  * @param options - Options object
  * @param options.fee - fee Transaction fee
@@ -248,7 +197,7 @@ export async function postQueryToOracle(oracleId, query, options) {
  * @returns Oracle object
  */
 export async function extendOracleTtl(oracleId, options) {
-  const oracleExtendTx = await _buildTx(TX_TYPE.oracleExtend, {
+  const oracleExtendTx = await _buildTx(Tag.OracleExtendTx, {
     oracleTtlType: ORACLE_TTL.type,
     oracleTtlValue: ORACLE_TTL.value,
     ...options,
@@ -256,12 +205,14 @@ export async function extendOracleTtl(oracleId, options) {
     oracleId
   });
   return { ...(await send(oracleExtendTx, options)),
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
     ...(await getOracleObject(oracleId, options))
   };
 }
 
 /**
  * Extend oracle ttl
+ * @category oracle
  * @param oracleId - Oracle public key
  * @param queryId - Oracle query id
  * @param response - Oracle query response
@@ -272,7 +223,7 @@ export async function extendOracleTtl(oracleId, options) {
  * @returns Oracle object
  */
 export async function respondToQuery(oracleId, queryId, response, options) {
-  const oracleRespondTx = await _buildTx(TX_TYPE.oracleResponse, {
+  const oracleRespondTx = await _buildTx(Tag.OracleResponseTx, {
     responseTtlType: RESPONSE_TTL.type,
     responseTtlValue: RESPONSE_TTL.value,
     ...options,
@@ -282,7 +233,74 @@ export async function respondToQuery(oracleId, queryId, response, options) {
     response
   });
   return { ...(await send(oracleRespondTx, options)),
+    // eslint-disable-next-line @typescript-eslint/no-use-before-define
     ...(await getOracleObject(oracleId, options))
   };
 }
+
+/**
+ * Constructor for Oracle Object (helper object for using Oracle)
+ * @category oracle
+ * @param oracleId - Oracle public key
+ * @param options - Options
+ * @returns Oracle object
+ */
+export async function getOracleObject(oracleId, options) {
+  return { ...(await options.onNode.getOracleByPubkey(oracleId)),
+    queries: (await options.onNode.getOracleQueriesByPubkey(oracleId)).oracleQueries,
+    ...mapObject({
+      pollQueries: pollForQueries,
+      postQuery: postQueryToOracle,
+      respondToQuery,
+      extendOracle: extendOracleTtl,
+      getQuery: getQueryObject
+    }, _ref5 => {
+      let [name, handler] = _ref5;
+      return [name, function () {
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        const lastArg = args[args.length - 1];
+
+        if (lastArg != null && typeof lastArg === 'object' && lastArg.constructor === Object) {
+          Object.assign(lastArg, { ...options,
+            ...lastArg
+          });
+        } else args.push(options);
+
+        return handler(oracleId, ...args);
+      }];
+    })
+  };
+}
+
+/**
+ * Register oracle
+ * @category oracle
+ * @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(queryFormat, responseFormat, options) {
+  const accountId = await options.onAccount.address(options);
+  const oracleRegisterTx = await _buildTx(Tag.OracleRegisterTx, {
+    queryFee: QUERY_FEE,
+    oracleTtlValue: ORACLE_TTL.value,
+    oracleTtlType: ORACLE_TTL.type,
+    ...options,
+    accountId,
+    queryFormat,
+    responseFormat
+  });
+  return { ...(await send(oracleRegisterTx, options)),
+    ...(await getOracleObject(encode(decode(accountId), Encoding.OracleAddress), options))
+  };
+}
 //# sourceMappingURL=oracle.mjs.map