@aeternity/aepp-sdk 12.0.0 → 12.1.2

package/src/aens.ts

@@ -23,25 +23,28 @@
  * repository.
  */
 
-import { salt } from './utils/crypto'
-import { commitmentHash, isAuctionName, Pointer } from './tx/builder/helpers'
-import { CLIENT_TTL, NAME_TTL, TX_TYPE, AensName } from './tx/builder/schema'
-import { ArgumentError } from './utils/errors'
-import { EncodedData } from './utils/encoder'
-import BigNumber from 'bignumber.js'
-import { send, SendOptions } from './spend'
-import { getName, height } from './chain'
-import { _buildTx, BuildTxOptions } from './tx'
-import { TransformNodeType } from './Node'
-import { NameEntry } from './apis/node'
-import AccountBase from './account/Base'
+import BigNumber from 'bignumber.js';
+import { genSalt } from './utils/crypto';
+import { commitmentHash, isAuctionName } from './tx/builder/helpers';
+import {
+  CLIENT_TTL, NAME_TTL, Tag, AensName,
+} from './tx/builder/constants';
+import { ArgumentError } from './utils/errors';
+import { Encoded } from './utils/encoder';
+import { send, SendOptions } from './spend';
+import { getName, getHeight } from './chain';
+import { _buildTx, BuildTxOptions } from './tx';
+import { TransformNodeType } from './Node';
+import { NameEntry, NamePointer } from './apis/node';
+import AccountBase from './account/Base';
 
 interface KeyPointers {
-  [key: string]: string | Buffer
+  [key: string]: string | Buffer;
 }
 
 /**
  * Revoke a name
+ * @category AENS
  * @param name - Name hash
  * @param options - Options
  * @param options.onAccount - Make operation on specific account from sdk (you pass
@@ -60,23 +63,25 @@ interface KeyPointers {
  * await nameObject.revoke({ fee, ttl, nonce })
  * ```
  */
-export async function aensRevoke (
-  name: AensName, options: AensRevokeOptions
+export async function aensRevoke(
+  name: AensName,
+  options: AensRevokeOptions,
 ): ReturnType<typeof send> {
-  const nameRevokeTx = await _buildTx(TX_TYPE.nameRevoke, {
+  const nameRevokeTx = await _buildTx(Tag.NameRevokeTx, {
     ...options,
     nameId: name,
-    accountId: await options.onAccount.address(options)
-  })
-  return await send(nameRevokeTx, options)
+    accountId: await options.onAccount.address(options),
+  });
+  return send(nameRevokeTx, options);
 }
 
 interface AensRevokeOptions extends
-  BuildTxOptions<TX_TYPE.nameRevoke, 'nameId' | 'accountId'>,
+  BuildTxOptions<Tag.NameRevokeTx, 'nameId' | 'accountId'>,
   SendOptions {}
 
 /**
  * Update a name
+ * @category AENS
  * @param name - AENS name
  * @param pointers - Map of pointer keys to corresponding addresses
  * @param options - Options
@@ -103,39 +108,42 @@ interface AensRevokeOptions extends
  * await nameObject.update(pointers, { nameTtl, ttl, fee, nonce, clientTtl })
  * ```
  */
-export async function aensUpdate (
-  name: AensName, pointers: KeyPointers, { extendPointers, ...options }: AensUpdateOptions
+export async function aensUpdate(
+  name: AensName,
+  pointers: KeyPointers,
+  { extendPointers, ...options }: AensUpdateOptions,
 ): ReturnType<typeof send> {
   const allPointers = {
     ...extendPointers === true && Object.fromEntries(
       (await getName(name, options)).pointers
-        .map(({ key, id }: { key: string, id: string }) => [key, id])
+        .map(({ key, id }: { key: string; id: string }) => [key, id]),
     ),
-    ...pointers
-  }
+    ...pointers,
+  };
 
-  const nameUpdateTx = await _buildTx(TX_TYPE.nameUpdate, {
+  const nameUpdateTx = await _buildTx(Tag.NameUpdateTx, {
     clientTtl: CLIENT_TTL,
     nameTtl: NAME_TTL,
     ...options,
     nameId: name,
     accountId: await options.onAccount.address(options),
-    pointers: Object.entries(allPointers).map(([key, id]) => ({ key, id: id.toString() }))
-  })
+    pointers: Object.entries(allPointers).map(([key, id]) => ({ key, id: id.toString() })),
+  });
 
-  return await send(nameUpdateTx, options)
+  return send(nameUpdateTx, options);
 }
 
 interface AensUpdateOptions extends
-  BuildTxOptions<TX_TYPE.nameUpdate, 'nameId' | 'accountId' | 'pointers' | 'clientTtl' | 'nameTtl'>,
+  BuildTxOptions<Tag.NameUpdateTx, 'nameId' | 'accountId' | 'pointers' | 'clientTtl' | 'nameTtl'>,
   SendOptions {
-  extendPointers?: boolean
-  clientTtl?: number
-  nameTtl?: number
+  extendPointers?: boolean;
+  clientTtl?: number;
+  nameTtl?: number;
 }
 
 /**
  * Transfer a domain to another account
+ * @category AENS
  * @param name - AENS name
  * @param account - Recipient account publick key
  * @param options - Options
@@ -156,26 +164,29 @@ interface AensUpdateOptions extends
  * await nameObject.transfer(recipientPub, { ttl, fee, nonce })
  * ```
  */
-export async function aensTransfer (
-  name: AensName, account: EncodedData<'ak'>, options: AensTransferOptions
+export async function aensTransfer(
+  name: AensName,
+  account: Encoded.AccountAddress,
+  options: AensTransferOptions,
 ): ReturnType<typeof send> {
-  const nameTransferTx = await _buildTx(TX_TYPE.nameTransfer, {
+  const nameTransferTx = await _buildTx(Tag.NameTransferTx, {
     ...options,
     nameId: name,
     accountId: await options.onAccount.address(options),
-    recipientId: account
-  })
+    recipientId: account,
+  });
 
-  return await send(nameTransferTx, options)
+  return send(nameTransferTx, options);
 }
 
 interface AensTransferOptions extends
-  BuildTxOptions<TX_TYPE.nameTransfer, 'nameId' | 'accountId' | 'recipientId'>,
+  BuildTxOptions<Tag.NameTransferTx, 'nameId' | 'accountId' | 'recipientId'>,
   SendOptions {}
 
 /**
  * Query the AENS name info from the node
  * and return the object with info and predefined functions for manipulating name
+ * @category AENS
  * @param name - AENS name
  * @param opt - Options
  * @returns
@@ -193,72 +204,75 @@ interface AensTransferOptions extends
  * }
  * ```
  */
-export async function aensQuery (
+export async function aensQuery(
   name: AensName,
   opt: Parameters<typeof getName>[1] & Parameters<typeof aensUpdate>[2]
-  & Parameters<typeof aensTransfer>[2]
+  & Parameters<typeof aensTransfer>[2],
 ): Promise<Readonly<
   TransformNodeType<NameEntry> & {
-    id: EncodedData<'nm'>
-    owner: EncodedData<'ak'>
-    pointers: KeyPointers | Pointer[]
-    ttl: number
+    id: Encoded.Name;
+    owner: Encoded.AccountAddress;
+    pointers: KeyPointers | NamePointer[];
+    ttl: number;
     update: (
       pointers: KeyPointers,
       options?: Omit<Parameters<typeof aensQuery>[1], 'onNode' | 'onCompiler' | 'onAccount'> & {
-        onAccount?: AccountBase
+        onAccount?: AccountBase;
       }
-    ) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>
+    ) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>;
     transfer: (
-      account: EncodedData<'ak'>,
+      account: Encoded.AccountAddress,
       options?: Parameters<typeof aensQuery>[1]
-    ) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>
+    ) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>;
     revoke: (options?: Omit<Parameters<typeof aensRevoke>[1], 'onNode' | 'onCompiler' | 'onAccount'> & {
-      onAccount?: AccountBase
+      onAccount?: AccountBase;
     }
-    ) => ReturnType<typeof aensRevoke>
+    ) => ReturnType<typeof aensRevoke>;
     extendTtl: (
       nameTtl: number,
       options?: Omit<Parameters<typeof aensQuery>[1], 'onNode' | 'onCompiler' | 'onAccount'>
-    ) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>
+    ) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>;
   }
   >> {
-  const nameEntry = await getName(name, opt)
+  const nameEntry = await getName(name, opt);
   return Object.freeze({
     ...nameEntry,
-    id: nameEntry.id as EncodedData<'nm'>,
-    owner: nameEntry.owner as EncodedData<'ak'>,
-    async update (pointers, options) {
+    id: nameEntry.id as Encoded.Name,
+    owner: nameEntry.owner as Encoded.AccountAddress,
+    async update(pointers, options) {
       return {
         ...await aensUpdate(name, pointers, { ...opt, ...options }),
-        ...await aensQuery(name, { ...opt, ...options })
-      }
+        ...await aensQuery(name, { ...opt, ...options }),
+      };
     },
-    async transfer (account, options) {
+    async transfer(account, options) {
       return {
         ...await aensTransfer(name, account, { ...opt, ...options }),
-        ...await aensQuery(name, { ...opt, ...options })
-      }
+        ...await aensQuery(name, { ...opt, ...options }),
+      };
     },
-    async revoke (options) {
-      return await aensRevoke(name, { ...opt, ...options })
+    async revoke(options) {
+      return aensRevoke(name, { ...opt, ...options });
     },
-    async extendTtl (nameTtl = NAME_TTL, options) {
+    async extendTtl(nameTtl = NAME_TTL, options = {}) {
       if (nameTtl > NAME_TTL || nameTtl <= 0) {
-        throw new ArgumentError('nameTtl', `a number between 1 and ${NAME_TTL} blocks`, nameTtl)
+        throw new ArgumentError('nameTtl', `a number between 1 and ${NAME_TTL} blocks`, nameTtl);
       }
 
       return {
-        ...await aensUpdate(name, {}, { ...opt, ...options, nameTtl, extendPointers: true }),
-        ...await aensQuery(name, { ...opt, ...options })
-      }
-    }
-  })
+        ...await aensUpdate(name, {}, {
+          ...opt, ...options, nameTtl, extendPointers: true,
+        }),
+        ...await aensQuery(name, { ...opt, ...options }),
+      };
+    },
+  });
 }
 
 /**
  * Claim a previously preclaimed registration. This can only be done after the
  * preclaim step
+ * @category AENS
  * @param name - AENS name
  * @param salt - Salt from pre-claim, or 0 if it's a bid
  * @param options - options
@@ -277,28 +291,30 @@ export async function aensQuery (
  * await sdkInstance.aensClaim(name, salt, { ttl, fee, nonce, nameFee })
  * ```
  */
-export async function aensClaim (
-  name: AensName, salt: number, options: AensClaimOptions
+export async function aensClaim(
+  name: AensName,
+  salt: number,
+  options: AensClaimOptions,
 ): Promise<AensClaimReturnType> {
-  const claimTx = await _buildTx(TX_TYPE.nameClaim, {
+  const claimTx = await _buildTx(Tag.NameClaimTx, {
     ...options,
     accountId: await options.onAccount.address(options),
     nameSalt: salt,
-    name
-  })
+    name,
+  });
 
-  const result = await send(claimTx, options)
+  const result = await send(claimTx, options);
   if (!isAuctionName(name)) {
     const nameInter = result.blockHeight != null && result.blockHeight > 0
       ? await aensQuery(name, options)
-      : {}
-    return Object.assign(result, nameInter)
+      : {};
+    return Object.assign(result, nameInter);
   }
-  return result
+  return result;
 }
 
-type AensClaimOptionsType = BuildTxOptions<TX_TYPE.nameClaim, 'accountId' | 'nameSalt' | 'name'>
-& SendOptions & Parameters<typeof aensQuery>[1]
+type AensClaimOptionsType = BuildTxOptions<Tag.NameClaimTx, 'accountId' | 'nameSalt' | 'name'>
+& SendOptions & Parameters<typeof aensQuery>[1];
 interface AensClaimOptions extends AensClaimOptionsType {}
 interface AensClaimReturnType extends
   Awaited<ReturnType<typeof send>>,
@@ -306,6 +322,7 @@ interface AensClaimReturnType extends
 
 /**
  * Preclaim a name. Sends a hash of the name and a random salt to the node
+ * @category AENS
  * @param name - AENS name
  * @param options - Options
  * @param options.onAccount - Make operation on specific account from sdk (you pass
@@ -327,44 +344,43 @@ interface AensClaimReturnType extends
  * }
  * ```
  */
-export async function aensPreclaim (
-  name: AensName, options: AensPreclaimOptions
-): Promise<Readonly<
-  Awaited<ReturnType<typeof send>> & {
-    height: number
-    salt: number
-    commitmentId: string
-    claim: (opts?: Parameters<typeof aensClaim>[2]) => ReturnType<typeof aensClaim>
-  }
-  >> {
-  const _salt = salt()
-  const currentHeight = await height(options)
-  const commitmentId = commitmentHash(name, _salt)
+export async function aensPreclaim(name: AensName, options: AensPreclaimOptions): Promise<Readonly<
+Awaited<ReturnType<typeof send>> & {
+  height: number;
+  salt: number;
+  commitmentId: string;
+  claim: (opts?: Parameters<typeof aensClaim>[2]) => ReturnType<typeof aensClaim>;
+}
+>> {
+  const salt = genSalt();
+  const height = await getHeight(options);
+  const commitmentId = commitmentHash(name, salt);
 
-  const preclaimTx = await _buildTx(TX_TYPE.namePreClaim, {
+  const preclaimTx = await _buildTx(Tag.NamePreclaimTx, {
     ...options,
     accountId: await options.onAccount.address(options),
-    commitmentId
-  })
+    commitmentId,
+  });
 
   return Object.freeze({
     ...await send(preclaimTx, options),
-    height: currentHeight,
-    salt: _salt,
+    height,
+    salt,
     commitmentId,
-    async claim (opts?: Parameters<typeof aensClaim>[2]) {
-      return await aensClaim(name, _salt, { ...options, ...opts })
-    }
-  })
+    async claim(opts?: Parameters<typeof aensClaim>[2]) {
+      return aensClaim(name, salt, { ...options, ...opts });
+    },
+  });
 }
 
 interface AensPreclaimOptions extends
-  BuildTxOptions<TX_TYPE.namePreClaim, 'accountId' | 'commitmentId'>,
+  BuildTxOptions<Tag.NamePreclaimTx, 'accountId' | 'commitmentId'>,
   SendOptions,
   AensClaimOptions {}
 
 /**
  * Bid to name auction
+ * @category AENS
  * @param name - Domain name
  * @param nameFee - Name fee (bid fee)
  * @param options - Options
@@ -382,10 +398,10 @@ interface AensPreclaimOptions extends
  * await sdkInstance.aensBid(name, 213109412839123, { ttl, fee, nonce })
  * ```
  */
-export async function aensBid (
+export async function aensBid(
   name: AensName,
   nameFee: number | string | BigNumber,
-  options: Omit<Parameters<typeof aensClaim>[2], 'nameFee'>
+  options: Omit<Parameters<typeof aensClaim>[2], 'nameFee'>,
 ): ReturnType<typeof aensClaim> {
-  return await aensClaim(name, 0, { ...options, nameFee })
+  return aensClaim(name, 0, { ...options, nameFee });
 }

package/src/aepp-wallet-communication/connection/Browser.ts

@@ -15,16 +15,17 @@
  *  PERFORMANCE OF THIS SOFTWARE.
  */
 
-import { AlreadyConnectedError, NoWalletConnectedError } from '../../utils/errors'
+import { AlreadyConnectedError, NoWalletConnectedError } from '../../utils/errors';
 
 /**
  * Browser connection base interface
+ * @category aepp wallet communication
  */
 export default abstract class BrowserConnection {
-  debug: boolean
+  debug: boolean;
 
-  protected constructor ({ debug = false }: { debug?: boolean }) {
-    this.debug = debug
+  protected constructor({ debug = false }: { debug?: boolean }) {
+    this.debug = debug;
   }
 
   /**
@@ -32,37 +33,39 @@ export default abstract class BrowserConnection {
    * @param onMessage - Message handler
    * @param onDisconnect - trigger when runtime connection in closed
    */
-  connect (
+  connect(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
     onMessage: (message: any, origin: string, source: any) => void,
-    onDisconnect: () => void
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    onDisconnect: () => void,
   ): void {
-    if (this.isConnected()) throw new AlreadyConnectedError('You already connected')
+    if (this.isConnected()) throw new AlreadyConnectedError('You already connected');
   }
 
   /**
    * Disconnect
    */
-  disconnect (): void {
-    if (!this.isConnected()) throw new NoWalletConnectedError('You dont have connection. Please connect before')
+  disconnect(): void {
+    if (!this.isConnected()) throw new NoWalletConnectedError('You dont have connection. Please connect before');
   }
 
   /**
-   * Send message
+   * Receive message
    */
-  protected receiveMessage (message: any): void {
-    if (this.debug) console.log('Receive message:', message)
+  protected receiveMessage(message: any): void {
+    if (this.debug) console.log('Receive message:', message);
   }
 
   /**
    * Send message
    */
-  sendMessage (message: any): void {
-    if (this.debug) console.log('Send message:', message)
+  sendMessage(message: any): void {
+    if (this.debug) console.log('Send message:', message);
   }
 
   /**
    * Check if connected
    * @returns Is connected
    */
-  abstract isConnected (): boolean
+  abstract isConnected(): boolean;
 }

package/src/aepp-wallet-communication/connection/BrowserRuntime.ts

@@ -15,44 +15,45 @@
  *  PERFORMANCE OF THIS SOFTWARE.
  */
 
-import { Runtime } from 'webextension-polyfill'
-import BrowserConnection from './Browser'
+import { Runtime } from 'webextension-polyfill';
+import BrowserConnection from './Browser';
 
 /**
  * BrowserRuntimeConnection
  * Handle browser runtime communication
+ * @category aepp wallet communication
  */
 export default class BrowserRuntimeConnection extends BrowserConnection {
-  port: Runtime.Port
+  port: Runtime.Port;
 
-  constructor ({ port, ...options }: { port: Runtime.Port, debug: boolean }) {
-    super(options)
-    this.port = port
+  constructor({ port, ...options }: { port: Runtime.Port; debug: boolean }) {
+    super(options);
+    this.port = port;
   }
 
-  disconnect (): void {
-    super.disconnect()
-    this.port.disconnect()
+  disconnect(): void {
+    super.disconnect();
+    this.port.disconnect();
   }
 
-  connect (
+  connect(
     onMessage: (message: any, origin: string, source: Runtime.Port) => void,
-    onDisconnect: () => void
+    onDisconnect: () => void,
   ): void {
-    super.connect(onMessage, onDisconnect)
+    super.connect(onMessage, onDisconnect);
     this.port.onMessage.addListener((message, port) => {
-      this.receiveMessage(message)
-      onMessage(message, port.name, port)
-    })
-    this.port.onDisconnect.addListener(onDisconnect)
+      this.receiveMessage(message);
+      onMessage(message, port.name, port);
+    });
+    this.port.onDisconnect.addListener(onDisconnect);
   }
 
-  sendMessage (message: any): void {
-    super.sendMessage(message)
-    this.port.postMessage(message)
+  sendMessage(message: any): void {
+    super.sendMessage(message);
+    this.port.postMessage(message);
   }
 
-  isConnected (): boolean {
-    return this.port.onMessage.hasListeners()
+  isConnected(): boolean {
+    return this.port.onMessage.hasListeners();
   }
 }