@aeternity/aepp-sdk 13.3.2 → 14.0.0

package/es/account/Rpc.js

@@ -0,0 +1,86 @@
+import { Buffer as _Buffer } from "buffer";
+import AccountBase from './Base.js';
+import { METHODS } from '../aepp-wallet-communication/schema.js';
+import { ArgumentError, UnsupportedProtocolError } from '../utils/errors.js';
+import { Encoding, decode, encode } from '../utils/encoder.js';
+/**
+ * Account provided by wallet
+ * @param params - Params
+ * @param params.rpcClient - RpcClient instance
+ * @param params.address - RPC account address
+ * @returns AccountRpc instance
+ */
+export default class AccountRpc extends AccountBase {
+  constructor(rpcClient, address) {
+    super();
+    this._rpcClient = rpcClient;
+    this.address = address;
+  }
+  async sign(dataRaw) {
+    const data = encode(_Buffer.from(dataRaw), Encoding.Bytearray);
+    const {
+      signature
+    } = await this._rpcClient.request(METHODS.unsafeSign, {
+      onAccount: this.address,
+      data
+    });
+    return decode(signature);
+  }
+  async signTransaction(tx, {
+    innerTx,
+    networkId
+  } = {}) {
+    if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
+    const res = await this._rpcClient.request(METHODS.sign, {
+      onAccount: this.address,
+      tx,
+      returnSigned: true,
+      networkId,
+      innerTx
+    });
+    if (res.signedTransaction == null) {
+      throw new UnsupportedProtocolError('signedTransaction is missed in wallet response');
+    }
+    return res.signedTransaction;
+  }
+  async signMessage(message) {
+    const {
+      signature
+    } = await this._rpcClient.request(METHODS.signMessage, {
+      onAccount: this.address,
+      message
+    });
+    return _Buffer.from(signature, 'hex');
+  }
+  async signTypedData(data, aci, {
+    name,
+    version,
+    contractAddress,
+    networkId
+  } = {}) {
+    const {
+      signature
+    } = await this._rpcClient.request(METHODS.signTypedData, {
+      onAccount: this.address,
+      domain: {
+        name,
+        version,
+        networkId,
+        contractAddress
+      },
+      aci,
+      data
+    });
+    return signature;
+  }
+  async signDelegation(delegation) {
+    const {
+      signature
+    } = await this._rpcClient.request(METHODS.signDelegation, {
+      delegation,
+      onAccount: this.address
+    });
+    return signature;
+  }
+}
+//# sourceMappingURL=Rpc.js.map

package/es/account/Rpc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Rpc.js","names":["AccountBase","METHODS","ArgumentError","UnsupportedProtocolError","Encoding","decode","encode","AccountRpc","constructor","rpcClient","address","_rpcClient","sign","dataRaw","data","_Buffer","from","Bytearray","signature","request","unsafeSign","onAccount","signTransaction","tx","innerTx","networkId","res","returnSigned","signedTransaction","signMessage","message","signTypedData","aci","name","version","contractAddress","domain","signDelegation","delegation"],"sources":["../../src/account/Rpc.ts"],"sourcesContent":["import AccountBase from './Base.js';\nimport { METHODS } from '../aepp-wallet-communication/schema.js';\nimport { ArgumentError, UnsupportedProtocolError } from '../utils/errors.js';\nimport { Encoded, Encoding, decode, encode } from '../utils/encoder.js';\nimport RpcClient from '../aepp-wallet-communication/rpc/RpcClient.js';\nimport { AeppApi, WalletApi } from '../aepp-wallet-communication/rpc/types.js';\n\n/**\n * Account provided by wallet\n * @param params - Params\n * @param params.rpcClient - RpcClient instance\n * @param params.address - RPC account address\n * @returns AccountRpc instance\n */\nexport default class AccountRpc extends AccountBase {\n  _rpcClient: RpcClient<WalletApi, AeppApi>;\n\n  override readonly address: Encoded.AccountAddress;\n\n  constructor(rpcClient: RpcClient<WalletApi, AeppApi>, address: Encoded.AccountAddress) {\n    super();\n    this._rpcClient = rpcClient;\n    this.address = address;\n  }\n\n  async sign(dataRaw: string | Uint8Array): Promise<Uint8Array> {\n    const data = encode(Buffer.from(dataRaw), Encoding.Bytearray);\n    const { signature } = await this._rpcClient.request(METHODS.unsafeSign, {\n      onAccount: this.address,\n      data,\n    });\n    return decode(signature);\n  }\n\n  override async signTransaction(\n    tx: Encoded.Transaction,\n    { innerTx, networkId }: Parameters<AccountBase['signTransaction']>[1] = {},\n  ): Promise<Encoded.Transaction> {\n    if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);\n    const res = await this._rpcClient.request(METHODS.sign, {\n      onAccount: this.address,\n      tx,\n      returnSigned: true,\n      networkId,\n      innerTx,\n    });\n    if (res.signedTransaction == null) {\n      throw new UnsupportedProtocolError('signedTransaction is missed in wallet response');\n    }\n    return res.signedTransaction;\n  }\n\n  override async signMessage(message: string): Promise<Uint8Array> {\n    const { signature } = await this._rpcClient.request(METHODS.signMessage, {\n      onAccount: this.address,\n      message,\n    });\n    return Buffer.from(signature, 'hex');\n  }\n\n  override async signTypedData(\n    data: Encoded.ContractBytearray,\n    aci: Parameters<AccountBase['signTypedData']>[1],\n    { name, version, contractAddress, networkId }: Parameters<AccountBase['signTypedData']>[2] = {},\n  ): Promise<Encoded.Signature> {\n    const { signature } = await this._rpcClient.request(METHODS.signTypedData, {\n      onAccount: this.address,\n      domain: {\n        name,\n        version,\n        networkId,\n        contractAddress,\n      },\n      aci,\n      data,\n    });\n    return signature;\n  }\n\n  override async signDelegation(delegation: Encoded.Bytearray): Promise<Encoded.Signature> {\n    const { signature } = await this._rpcClient.request(METHODS.signDelegation, {\n      delegation,\n      onAccount: this.address,\n    });\n    return signature;\n  }\n}\n"],"mappings":";AAAA,OAAOA,WAAW,MAAM,WAAW;AACnC,SAASC,OAAO,QAAQ,wCAAwC;AAChE,SAASC,aAAa,EAAEC,wBAAwB,QAAQ,oBAAoB;AAC5E,SAAkBC,QAAQ,EAAEC,MAAM,EAAEC,MAAM,QAAQ,qBAAqB;AAIvE;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,MAAMC,UAAU,SAASP,WAAW,CAAC;EAKlDQ,WAAWA,CAACC,SAAwC,EAAEC,OAA+B,EAAE;IACrF,KAAK,CAAC,CAAC;IACP,IAAI,CAACC,UAAU,GAAGF,SAAS;IAC3B,IAAI,CAACC,OAAO,GAAGA,OAAO;EACxB;EAEA,MAAME,IAAIA,CAACC,OAA4B,EAAuB;IAC5D,MAAMC,IAAI,GAAGR,MAAM,CAACS,OAAA,CAAOC,IAAI,CAACH,OAAO,CAAC,EAAET,QAAQ,CAACa,SAAS,CAAC;IAC7D,MAAM;MAAEC;IAAU,CAAC,GAAG,MAAM,IAAI,CAACP,UAAU,CAACQ,OAAO,CAAClB,OAAO,CAACmB,UAAU,EAAE;MACtEC,SAAS,EAAE,IAAI,CAACX,OAAO;MACvBI;IACF,CAAC,CAAC;IACF,OAAOT,MAAM,CAACa,SAAS,CAAC;EAC1B;EAEA,MAAeI,eAAeA,CAC5BC,EAAuB,EACvB;IAAEC,OAAO;IAAEC;EAAyD,CAAC,GAAG,CAAC,CAAC,EAC5C;IAC9B,IAAIA,SAAS,IAAI,IAAI,EAAE,MAAM,IAAIvB,aAAa,CAAC,WAAW,EAAE,UAAU,EAAEuB,SAAS,CAAC;IAClF,MAAMC,GAAG,GAAG,MAAM,IAAI,CAACf,UAAU,CAACQ,OAAO,CAAClB,OAAO,CAACW,IAAI,EAAE;MACtDS,SAAS,EAAE,IAAI,CAACX,OAAO;MACvBa,EAAE;MACFI,YAAY,EAAE,IAAI;MAClBF,SAAS;MACTD;IACF,CAAC,CAAC;IACF,IAAIE,GAAG,CAACE,iBAAiB,IAAI,IAAI,EAAE;MACjC,MAAM,IAAIzB,wBAAwB,CAAC,gDAAgD,CAAC;IACtF;IACA,OAAOuB,GAAG,CAACE,iBAAiB;EAC9B;EAEA,MAAeC,WAAWA,CAACC,OAAe,EAAuB;IAC/D,MAAM;MAAEZ;IAAU,CAAC,GAAG,MAAM,IAAI,CAACP,UAAU,CAACQ,OAAO,CAAClB,OAAO,CAAC4B,WAAW,EAAE;MACvER,SAAS,EAAE,IAAI,CAACX,OAAO;MACvBoB;IACF,CAAC,CAAC;IACF,OAAOf,OAAA,CAAOC,IAAI,CAACE,SAAS,EAAE,KAAK,CAAC;EACtC;EAEA,MAAea,aAAaA,CAC1BjB,IAA+B,EAC/BkB,GAAgD,EAChD;IAAEC,IAAI;IAAEC,OAAO;IAAEC,eAAe;IAAEV;EAAuD,CAAC,GAAG,CAAC,CAAC,EACnE;IAC5B,MAAM;MAAEP;IAAU,CAAC,GAAG,MAAM,IAAI,CAACP,UAAU,CAACQ,OAAO,CAAClB,OAAO,CAAC8B,aAAa,EAAE;MACzEV,SAAS,EAAE,IAAI,CAACX,OAAO;MACvB0B,MAAM,EAAE;QACNH,IAAI;QACJC,OAAO;QACPT,SAAS;QACTU;MACF,CAAC;MACDH,GAAG;MACHlB;IACF,CAAC,CAAC;IACF,OAAOI,SAAS;EAClB;EAEA,MAAemB,cAAcA,CAACC,UAA6B,EAA8B;IACvF,MAAM;MAAEpB;IAAU,CAAC,GAAG,MAAM,IAAI,CAACP,UAAU,CAACQ,OAAO,CAAClB,OAAO,CAACoC,cAAc,EAAE;MAC1EC,UAAU;MACVjB,SAAS,EAAE,IAAI,CAACX;IAClB,CAAC,CAAC;IACF,OAAOQ,SAAS;EAClB;AACF","ignoreList":[]}

package/es/aens.d.ts

@@ -5,189 +5,148 @@
  * https://github.com/aeternity/protocol/blob/master/AENS.md in the protocol
  * repository.
  */
-import BigNumber from 'bignumber.js';
-import { Tag, AensName } from './tx/builder/constants';
-import { Encoded, Encoding } from './utils/encoder';
-import { getName } from './chain';
-import { sendTransaction, SendTransactionOptions } from './send-transaction';
-import { BuildTxOptions } from './tx/builder';
-import { TransformNodeType } from './Node';
-import { NameEntry, NamePointer } from './apis/node';
-import AccountBase from './account/Base';
-import { AddressEncodings } from './tx/builder/field-types/address';
+import { BigNumber } from 'bignumber.js';
+import { Tag, AensName } from './tx/builder/constants.js';
+import { Encoded, Encoding } from './utils/encoder.js';
+import { sendTransaction, SendTransactionOptions } from './send-transaction.js';
+import { Optional } from './utils/other.js';
+import { BuildTxOptions } from './tx/builder/index.js';
+import Node from './Node.js';
+import AccountBase from './account/Base.js';
+import { AddressEncodings } from './tx/builder/field-types/address.js';
+interface NameRevokeOptions extends BuildTxOptions<Tag.NameRevokeTx, 'nameId' | 'accountId'>, Optional<SendTransactionOptions, 'onAccount' | 'onNode'> {
+}
 interface KeyPointers {
     [key: string]: Encoded.Generic<AddressEncodings | Encoding.Bytearray>;
 }
-/**
- * Revoke a name
- * @category AENS
- * @param name - Name hash
- * @param options - Options
- * @returns Transaction result
- * @example
- * ```js
- * const name = 'test.chain'
- * const nameObject = await sdkInstance.aensQuery(name)
- *
- * await sdkInstance.aensRevoke(name, { fee, ttl , nonce })
- * // or
- * await nameObject.revoke({ fee, ttl, nonce })
- * ```
- */
-export declare function aensRevoke(name: AensName, options: AensRevokeOptions): ReturnType<typeof sendTransaction>;
-interface AensRevokeOptions extends BuildTxOptions<Tag.NameRevokeTx, 'nameId' | 'accountId' | 'onNode'>, SendTransactionOptions {
-}
-/**
- * Update a name
- * @category AENS
- * @param name - AENS name
- * @param pointers - Map of pointer keys to corresponding addresses
- * @param options - Options
- * @throws Invalid pointer array error
- * @example
- * ```js
- * const name = 'test.chain'
- * const pointersArray = ['ak_asd23dasdas...,' 'ct_asdf34fasdasd...']
- * const nameObject = await sdkInstance.aensQuery(name)
- *
- * await sdkInstance.aensUpdate(name, pointersArray, { nameTtl, ttl, fee, nonce, clientTtl })
- * // or
- * await nameObject.update(pointers, { nameTtl, ttl, fee, nonce, clientTtl })
- * ```
- */
-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 {
+interface NameUpdateOptions extends BuildTxOptions<Tag.NameUpdateTx, 'nameId' | 'accountId' | 'pointers'>, Optional<SendTransactionOptions, 'onAccount' | 'onNode'> {
     /**
      * Get the pointers from the node and merge with provided ones. Pointers with the same key will be
      * overwritten.
      */
     extendPointers?: boolean;
-    /**
-     * a suggestion as to how long any clients should cache this information
-     */
-    clientTtl?: number;
-    /**
-     * Name ttl represented in number of blocks (Max value is 50000 blocks)
-     */
-    nameTtl?: number;
 }
-/**
- * Transfer a domain to another account
- * @category AENS
- * @param name - AENS name
- * @param account - Recipient account publick key
- * @param options - Options
- * @returns Transaction result
- * @example
- * ```js
- * const name = 'test.chain'
- * const recipientPub = 'ak_asd23dasdas...'
- * const nameObject = await sdkInstance.aensQuery(name)
- *
- * await sdkInstance.aensTransfer(name, recipientPub, { ttl, fee, nonce })
- * // or
- * await nameObject.transfer(recipientPub, { ttl, fee, nonce })
- * ```
- */
-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 {
+interface NameTransferOptions extends BuildTxOptions<Tag.NameTransferTx, 'nameId' | 'accountId' | 'recipientId'>, Optional<SendTransactionOptions, 'onAccount' | 'onNode'> {
 }
-/**
- * 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
- * @example
- * ```js
- * const nameObject = sdkInstance.aensQuery('test.chain')
- * console.log(nameObject)
- * {
- *  id, // name hash
- *  pointers, // array of pointers
- *  update, // Update name function
- *  extendTtl, // Extend Ttl name function
- *  transfer, // Transfer name function
- *  revoke // Revoke name function
- * }
- * ```
- */
-export declare function aensQuery(name: AensName, opt: Parameters<typeof getName>[1] & Parameters<typeof aensUpdate>[2] & Parameters<typeof aensTransfer>[2]): Promise<Readonly<TransformNodeType<NameEntry> & {
-    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;
-    }) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>;
-    transfer: (account: Encoded.AccountAddress, options?: Parameters<typeof aensQuery>[1]) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>;
-    revoke: (options?: Omit<Parameters<typeof aensRevoke>[1], 'onNode' | 'onCompiler' | 'onAccount'> & {
-        onAccount?: AccountBase;
-    }) => ReturnType<typeof aensRevoke>;
-    extendTtl: (nameTtl?: number, options?: Omit<Parameters<typeof aensQuery>[1], 'onNode' | 'onCompiler' | 'onAccount'>) => ReturnType<typeof aensUpdate> & ReturnType<typeof aensQuery>;
-}>>;
-/**
- * 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 or claiming without preclaim (in Ceres)
- * @param options - options
- * @returns Transaction result
- * @example
- * ```js
- * const name = 'test.chain'
- * const salt = preclaimResult.salt // salt from pre-claim transaction
- *
- * await sdkInstance.aensClaim(name, salt, { ttl, fee, nonce, nameFee })
- * ```
- */
-export declare function aensClaim(name: AensName, salt: number, options: AensClaimOptions): Promise<AensClaimReturnType>;
-type AensClaimOptionsType = BuildTxOptions<Tag.NameClaimTx, 'accountId' | 'nameSalt' | 'name'> & SendTransactionOptions & Parameters<typeof aensQuery>[1];
-interface AensClaimOptions extends AensClaimOptionsType {
+interface NamePreclaimOptions extends BuildTxOptions<Tag.NamePreclaimTx, 'accountId' | 'commitmentId'>, Optional<SendTransactionOptions, 'onAccount' | 'onNode'> {
 }
-interface AensClaimReturnType extends Awaited<ReturnType<typeof sendTransaction>>, Partial<Awaited<ReturnType<typeof aensQuery>>> {
+interface NameClaimOptions extends BuildTxOptions<Tag.NameClaimTx, 'accountId' | 'nameSalt' | 'name'>, Optional<SendTransactionOptions, 'onAccount' | 'onNode'> {
 }
 /**
- * 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
  * @example
  * ```js
- * const name = 'test.chain'
- * const salt = preclaimResult.salt // salt from pre-claim transaction
- *
- * await sdkInstance.aensPreclaim(name, { ttl, fee, nonce })
- * {
- *   ...transactionResult,
- *   claim, // Claim function (options={}) => claimTransactionResult
- *   salt,
- *   commitmentId
- * }
+ * const name = new Name('test.chain', aeSdk.getContext())
  * ```
  */
-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' | 'onNode'>, SendTransactionOptions, Omit<AensClaimOptions, 'version'> {
+export default class Name {
+    #private;
+    readonly value: AensName;
+    options: {
+        onNode: Node;
+        onAccount: AccountBase;
+    } & Omit<NameRevokeOptions & NameUpdateOptions & NameTransferOptions & NamePreclaimOptions & NameClaimOptions, 'version'>;
+    /**
+     * @param value - AENS name
+     * @param options - Options
+     * @param options.onNode - Node to use
+     * @param options.onAccount - Account to use
+     */
+    constructor(value: AensName, options: {
+        onNode: Node;
+        onAccount: AccountBase;
+    } & Omit<NameRevokeOptions & NameUpdateOptions & NameTransferOptions & NamePreclaimOptions & NameClaimOptions, 'version'>);
+    /**
+     * Revoke a name
+     * @param options - Options
+     * @returns mined transaction details
+     * @example
+     * ```js
+     * await name.revoke({ fee, ttl, nonce })
+     * ```
+     */
+    revoke(options?: NameRevokeOptions): ReturnType<typeof sendTransaction>;
+    /**
+     * Update a name
+     * @param pointers - Map of pointer keys to corresponding addresses
+     * @param options - Options
+     * @example
+     * ```js
+     * const name = 'test.chain'
+     * const channel = 'ch_2519mBs...'
+     * const pointers = {
+     *   account_pubkey: 'ak_asd23dasdas...,',
+     *   contract_pubkey: 'ct_asdf34fasdasd...',
+     *   [getDefaultPointerKey(channel)]: channel,
+     * }
+     * await name.update(pointers, { nameTtl, ttl, fee, nonce, clientTtl })
+     * ```
+     */
+    update(pointers: KeyPointers, options?: NameUpdateOptions): ReturnType<typeof sendTransaction>;
+    /**
+     * Transfer a name to another account
+     * @param address - Recipient account public key
+     * @param options - Options
+     * @returns mined transaction details
+     * @example
+     * ```js
+     * await name.transfer('ak_asd23dasdas...', { ttl, fee, nonce })
+     * ```
+     */
+    transfer(address: Encoded.AccountAddress, options?: NameTransferOptions): ReturnType<typeof sendTransaction>;
+    /**
+     * Query the AENS name info from the node
+     * and return the object with info and predefined functions for manipulating name
+     * @param options - Options
+     * @example
+     * ```js
+     * const nameEntry = await name.getState()
+     * console.log(nameEntry.owner)
+     * ```
+     */
+    getState(options?: {
+        onNode?: Node;
+    }): Promise<Awaited<ReturnType<Node['getNameEntryByName']>> & {
+        id: Encoded.Name;
+        owner: Encoded.AccountAddress;
+    }>;
+    /**
+     *
+     * @param nameTtl - represents in number of blocks (max and default is 180000)
+     * @param options - Options
+     * @returns mined transaction details
+     */
+    extendTtl(nameTtl?: number, options?: Omit<Parameters<Name['update']>[1], 'extendPointers' | 'nameTtl'>): ReturnType<Name['update']>;
+    /**
+     * Claim a previously preclaimed registration. This can only be done after the preclaim step
+     * @param options - options
+     * @returns mined transaction details
+     * @example
+     * ```js
+     * await name.claim({ ttl, fee, nonce, nameFee })
+     * ```
+     */
+    claim(options?: NameClaimOptions): ReturnType<typeof sendTransaction>;
+    /**
+     * Preclaim a name. Sends a hash of the name and a random salt to the node
+     * @param options - Options
+     * @example
+     * ```js
+     * await name.preclaim({ ttl, fee, nonce })
+     * ```
+     */
+    preclaim(options?: NamePreclaimOptions): ReturnType<typeof sendTransaction>;
+    /**
+     * Bid to name auction
+     * @param nameFee - Name fee (bid fee)
+     * @param options - Options
+     * @returns mined transaction details
+     * @example
+     * ```js
+     * const bidFee = computeBidFee(name.value, { startFee, increment: 0.42 })
+     * await name.bid(213109412839123, { ttl, fee, nonce })
+     * ```
+     */
+    bid(nameFee: number | string | BigNumber, options?: Omit<NameClaimOptions, 'nameFee'>): ReturnType<typeof sendTransaction>;
 }
-/**
- * Bid to name auction
- * @category AENS
- * @param name - Domain name
- * @param nameFee - Name fee (bid fee)
- * @param options - Options
- * @returns Transaction result
- * @example
- * ```js
- * const name = 'test.chain'
- * const bidFee = computeBidFee(name, { startFee, increment: 0.42 })
- *
- * await sdkInstance.aensBid(name, 213109412839123, { ttl, fee, nonce })
- * ```
- */
-export declare function aensBid(name: AensName, nameFee: number | string | BigNumber, options: Omit<Parameters<typeof aensClaim>[2], 'nameFee'>): ReturnType<typeof aensClaim>;
 export {};

package/es/aens.js

@@ -0,0 +1,258 @@
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _assertClassBrand(e, t, n) { if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n; throw new TypeError("Private element is not present on this object"); }
+/**
+ * Aens methods - routines to interact with the æternity naming system
+ *
+ * The high-level description of the naming system is
+ * https://github.com/aeternity/protocol/blob/master/AENS.md in the protocol
+ * repository.
+ */
+
+import { genSalt, isAddressValid } from './utils/crypto.js';
+import { commitmentHash, isAuctionName } from './tx/builder/helpers.js';
+import { Tag } from './tx/builder/constants.js';
+import { Encoding } from './utils/encoder.js';
+import { LogicError } from './utils/errors.js';
+import { getName } from './chain.js';
+import { sendTransaction } from './send-transaction.js';
+import { buildTxAsync } from './tx/builder/index.js';
+var _salt = /*#__PURE__*/new WeakMap();
+/**
+ * @category AENS
+ * @example
+ * ```js
+ * const name = new Name('test.chain', aeSdk.getContext())
+ * ```
+ */
+export default class Name {
+  /**
+   * @param value - AENS name
+   * @param options - Options
+   * @param options.onNode - Node to use
+   * @param options.onAccount - Account to use
+   */
+  constructor(value, options) {
+    _classPrivateFieldInitSpec(this, _salt, void 0);
+    this.value = value;
+    this.options = options;
+    this.options = options;
+  }
+
+  /**
+   * Revoke a name
+   * @param options - Options
+   * @returns mined transaction details
+   * @example
+   * ```js
+   * await name.revoke({ fee, ttl, nonce })
+   * ```
+   */
+  async revoke(options = {}) {
+    const opt = {
+      ...this.options,
+      ...options
+    };
+    const tx = await buildTxAsync({
+      _isInternalBuild: true,
+      ...opt,
+      tag: Tag.NameRevokeTx,
+      nameId: this.value,
+      accountId: opt.onAccount.address
+    });
+    return sendTransaction(tx, opt);
+  }
+
+  /**
+   * Update a name
+   * @param pointers - Map of pointer keys to corresponding addresses
+   * @param options - Options
+   * @example
+   * ```js
+   * const name = 'test.chain'
+   * const channel = 'ch_2519mBs...'
+   * const pointers = {
+   *   account_pubkey: 'ak_asd23dasdas...,',
+   *   contract_pubkey: 'ct_asdf34fasdasd...',
+   *   [getDefaultPointerKey(channel)]: channel,
+   * }
+   * await name.update(pointers, { nameTtl, ttl, fee, nonce, clientTtl })
+   * ```
+   */
+  async update(pointers, options = {}) {
+    const {
+      extendPointers,
+      ...opt
+    } = {
+      ...this.options,
+      ...options
+    };
+    const allPointers = {
+      ...(extendPointers === true && Object.fromEntries((await getName(this.value, opt)).pointers.map(({
+        key,
+        id
+      }) => [key, id]))),
+      ...pointers
+    };
+    const hasRawPointers = Object.values(allPointers).some(v => isAddressValid(v, Encoding.Bytearray));
+    const tx = await buildTxAsync({
+      _isInternalBuild: true,
+      ...opt,
+      tag: Tag.NameUpdateTx,
+      version: hasRawPointers ? 2 : 1,
+      nameId: this.value,
+      accountId: opt.onAccount.address,
+      pointers: Object.entries(allPointers).map(([key, id]) => ({
+        key,
+        id
+      }))
+    });
+    return sendTransaction(tx, opt);
+  }
+
+  /**
+   * Transfer a name to another account
+   * @param address - Recipient account public key
+   * @param options - Options
+   * @returns mined transaction details
+   * @example
+   * ```js
+   * await name.transfer('ak_asd23dasdas...', { ttl, fee, nonce })
+   * ```
+   */
+  async transfer(address, options = {}) {
+    const opt = {
+      ...this.options,
+      ...options
+    };
+    const tx = await buildTxAsync({
+      _isInternalBuild: true,
+      ...opt,
+      tag: Tag.NameTransferTx,
+      nameId: this.value,
+      accountId: opt.onAccount.address,
+      recipientId: address
+    });
+    return sendTransaction(tx, opt);
+  }
+
+  /**
+   * Query the AENS name info from the node
+   * and return the object with info and predefined functions for manipulating name
+   * @param options - Options
+   * @example
+   * ```js
+   * const nameEntry = await name.getState()
+   * console.log(nameEntry.owner)
+   * ```
+   */
+  async getState(options = {}) {
+    var _this$options$onNode;
+    const onNode = (_this$options$onNode = this.options.onNode) !== null && _this$options$onNode !== void 0 ? _this$options$onNode : options.onNode;
+    const nameEntry = await onNode.getNameEntryByName(this.value);
+    return {
+      ...nameEntry,
+      id: nameEntry.id,
+      owner: nameEntry.owner
+    };
+  }
+
+  /**
+   *
+   * @param nameTtl - represents in number of blocks (max and default is 180000)
+   * @param options - Options
+   * @returns mined transaction details
+   */
+  async extendTtl(nameTtl, options = {}) {
+    return this.update({}, {
+      ...options,
+      nameTtl,
+      extendPointers: true
+    });
+  }
+
+  /**
+   * Claim a previously preclaimed registration. This can only be done after the preclaim step
+   * @param options - options
+   * @returns mined transaction details
+   * @example
+   * ```js
+   * await name.claim({ ttl, fee, nonce, nameFee })
+   * ```
+   */
+  async claim(options = {}) {
+    const opt = {
+      ...this.options,
+      ...options
+    };
+    const tx = await buildTxAsync({
+      _isInternalBuild: true,
+      ...opt,
+      tag: Tag.NameClaimTx,
+      accountId: opt.onAccount.address,
+      nameSalt: _classPrivateFieldGet(_salt, this),
+      name: this.value
+    });
+    return sendTransaction(tx, opt);
+  }
+
+  /**
+   * Preclaim a name. Sends a hash of the name and a random salt to the node
+   * @param options - Options
+   * @example
+   * ```js
+   * await name.preclaim({ ttl, fee, nonce })
+   * ```
+   */
+  async preclaim(options = {}) {
+    const opt = {
+      ...this.options,
+      ...options
+    };
+    const salt = genSalt();
+    const tx = await buildTxAsync({
+      _isInternalBuild: true,
+      ...opt,
+      tag: Tag.NamePreclaimTx,
+      accountId: opt.onAccount.address,
+      commitmentId: commitmentHash(this.value, salt)
+    });
+    const result = await sendTransaction(tx, opt);
+    _classPrivateFieldSet(_salt, this, salt);
+    return result;
+  }
+
+  /**
+   * Bid to name auction
+   * @param nameFee - Name fee (bid fee)
+   * @param options - Options
+   * @returns mined transaction details
+   * @example
+   * ```js
+   * const bidFee = computeBidFee(name.value, { startFee, increment: 0.42 })
+   * await name.bid(213109412839123, { ttl, fee, nonce })
+   * ```
+   */
+  async bid(nameFee, options = {}) {
+    if (!isAuctionName(this.value)) {
+      throw new LogicError('This is not auction name, so cant make a bid!');
+    }
+    const opt = {
+      ...this.options,
+      ...options
+    };
+    const tx = await buildTxAsync({
+      _isInternalBuild: true,
+      ...opt,
+      tag: Tag.NameClaimTx,
+      accountId: opt.onAccount.address,
+      nameSalt: 0,
+      name: this.value,
+      nameFee
+    });
+    return sendTransaction(tx, opt);
+  }
+}
+//# sourceMappingURL=aens.js.map