@aeternity/aepp-sdk 11.0.1 → 12.1.1

package/es/account/Base.mjs

@@ -0,0 +1,123 @@
+import _buffer from "buffer";
+const {
+  Buffer: _Buffer
+} = _buffer;
+import _defineProperty from "@babel/runtime-corejs3/helpers/defineProperty";
+
+/*
+ * ISC License (ISC)
+ * Copyright (c) 2022 aeternity developers
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any
+ *  purpose with or without fee is hereby granted, provided that the above
+ *  copyright notice and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ *  PERFORMANCE OF THIS SOFTWARE.
+ */
+import { messageToHash, verifyMessage as verifyMessageCrypto, hash } from "../utils/crypto.mjs";
+import { buildTx } from "../tx/builder/index.mjs";
+import { decode } from "../utils/encoder.mjs";
+import { Tag } from "../tx/builder/constants.mjs";
+import { getNetworkId } from "../Node.mjs";
+import { concatBuffers } from "../utils/other.mjs";
+
+/**
+ * Check is provided object looks like an instance of AccountBase
+ * @param acc - Object to check
+ */
+export const isAccountBase = acc => !['sign', 'address', 'signTransaction', 'signMessage'].some(f => typeof acc[f] !== 'function');
+/**
+ * Account is one of the three basic building blocks of an
+ * {@link AeSdk} and provides access to a signing key pair.
+ */
+
+export default class AccountBase {
+  /**
+   * @param options - Options
+   * @param options.networkId - Using for signing transactions
+   */
+  constructor() {
+    var _this$networkId;
+
+    let {
+      networkId
+    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+    _defineProperty(this, "getNetworkId", getNetworkId);
+
+    (_this$networkId = this.networkId) !== null && _this$networkId !== void 0 ? _this$networkId : this.networkId = networkId;
+  }
+  /**
+   * Sign encoded transaction
+   * @param tx - Transaction to sign
+   * @param opt - Options
+   * @param opt.innerTx - Sign as inner transaction for PayingFor
+   * @returns Signed transaction
+   */
+
+
+  async signTransaction(tx) {
+    let {
+      innerTx,
+      networkId,
+      ...options
+    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const prefixes = [await this.getNetworkId({
+      networkId
+    })];
+    if (innerTx === true) prefixes.push('inner_tx');
+    const rlpBinaryTx = decode(tx);
+    const txWithNetworkId = concatBuffers([_Buffer.from(prefixes.join('-')), hash(rlpBinaryTx)]);
+    const signatures = [await this.sign(txWithNetworkId, options)];
+    return buildTx({
+      encodedTx: rlpBinaryTx,
+      signatures
+    }, Tag.SignedTx).tx;
+  }
+  /**
+   * Get network Id
+   * @returns Network Id
+   */
+
+
+  /**
+   * Sign message
+   * @param message - Message to sign
+   * @param opt - Options
+   * @returns Signature as hex string of Uint8Array
+   */
+  async signMessage(message) {
+    let {
+      returnHex = false,
+      ...options
+    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const sig = await this.sign(messageToHash(message), options);
+    return returnHex ? _Buffer.from(sig).toString('hex') : sig;
+  }
+  /**
+   * Verify message
+   * @param message - Message to verify
+   * @param signature - Signature
+   * @param options - Options
+   */
+
+
+  async verifyMessage(message, signature, options) {
+    return verifyMessageCrypto(message, typeof signature === 'string' ? _Buffer.from(signature, 'hex') : signature, decode(await this.address(options)));
+  }
+  /**
+   * Sign data blob
+   * @param data - Data blob to sign
+   * @param options - Options
+   * @returns Signed data blob
+   */
+
+
+}
+//# sourceMappingURL=Base.mjs.map

package/es/account/Base.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Base.mjs","names":["messageToHash","verifyMessage","verifyMessageCrypto","hash","buildTx","decode","Tag","getNetworkId","concatBuffers","isAccountBase","acc","some","f","AccountBase","constructor","networkId","signTransaction","tx","innerTx","options","prefixes","push","rlpBinaryTx","txWithNetworkId","from","join","signatures","sign","encodedTx","SignedTx","signMessage","message","returnHex","sig","toString","signature","address"],"sources":["../../src/account/Base.ts"],"sourcesContent":["/*\n * ISC License (ISC)\n * Copyright (c) 2022 aeternity developers\n *\n *  Permission to use, copy, modify, and/or distribute this software for any\n *  purpose with or without fee is hereby granted, provided that the above\n *  copyright notice and this permission notice appear in all copies.\n *\n *  THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\n *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\n *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\n *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\n *  PERFORMANCE OF THIS SOFTWARE.\n */\nimport { messageToHash, verifyMessage as verifyMessageCrypto, hash } from '../utils/crypto';\nimport { buildTx } from '../tx/builder';\nimport { decode, Encoded } from '../utils/encoder';\nimport { Tag } from '../tx/builder/constants';\nimport { getNetworkId } from '../Node';\nimport { concatBuffers } from '../utils/other';\nimport type { createMetaTx } from '../contract/ga';\n\n/**\n * Check is provided object looks like an instance of AccountBase\n * @param acc - Object to check\n */\nexport const isAccountBase = (acc: AccountBase | any): boolean => (\n  !['sign', 'address', 'signTransaction', 'signMessage'].some((f) => typeof acc[f] !== 'function')\n);\n\n/**\n * Account is one of the three basic building blocks of an\n * {@link AeSdk} and provides access to a signing key pair.\n */\nexport default abstract class AccountBase {\n  networkId?: string;\n\n  /**\n   * @param options - Options\n   * @param options.networkId - Using for signing transactions\n   */\n  constructor({ networkId }: { networkId?: string } = {}) {\n    this.networkId ??= networkId;\n  }\n\n  /**\n   * Sign encoded transaction\n   * @param tx - Transaction to sign\n   * @param opt - Options\n   * @param opt.innerTx - Sign as inner transaction for PayingFor\n   * @returns Signed transaction\n   */\n  async signTransaction(\n    tx: Encoded.Transaction,\n    { innerTx, networkId, ...options }: {\n      innerTx?: boolean;\n      networkId?: string;\n      authData?: Parameters<typeof createMetaTx>[1];\n      authFun?: Parameters<typeof createMetaTx>[2];\n    } & Omit<Partial<Parameters<typeof createMetaTx>[3]>, 'onAccount'> = {},\n  ): Promise<Encoded.Transaction> {\n    const prefixes = [await this.getNetworkId({ networkId })];\n    if (innerTx === true) prefixes.push('inner_tx');\n    const rlpBinaryTx = decode(tx);\n    const txWithNetworkId = concatBuffers([Buffer.from(prefixes.join('-')), hash(rlpBinaryTx)]);\n\n    const signatures = [await this.sign(txWithNetworkId, options)];\n    return buildTx({ encodedTx: rlpBinaryTx, signatures }, Tag.SignedTx).tx;\n  }\n\n  /**\n   * Get network Id\n   * @returns Network Id\n   */\n  readonly getNetworkId = getNetworkId;\n\n  /**\n   * Sign message\n   * @param message - Message to sign\n   * @param opt - Options\n   * @returns Signature as hex string of Uint8Array\n   */\n  async signMessage(\n    message: string,\n    { returnHex = false, ...options }: { returnHex?: boolean } = {},\n  ): Promise<string | Uint8Array> {\n    const sig = await this.sign(messageToHash(message), options);\n    return returnHex ? Buffer.from(sig).toString('hex') : sig;\n  }\n\n  /**\n   * Verify message\n   * @param message - Message to verify\n   * @param signature - Signature\n   * @param options - Options\n   */\n  async verifyMessage(\n    message: string,\n    signature: string | Uint8Array,\n    options?: object,\n  ): Promise<boolean> {\n    return verifyMessageCrypto(\n      message,\n      typeof signature === 'string' ? Buffer.from(signature, 'hex') : signature,\n      decode(await this.address(options)),\n    );\n  }\n\n  /**\n   * Sign data blob\n   * @param data - Data blob to sign\n   * @param options - Options\n   * @returns Signed data blob\n   */\n  abstract sign(data: string | Uint8Array, options?: any): Promise<Uint8Array>;\n\n  /**\n   * Obtain account address\n   * @returns Public account address\n   */\n  abstract address(opt?: object): Promise<Encoded.AccountAddress>;\n}\n"],"mappings":";;;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;SACSA,a,EAAeC,aAAa,IAAIC,mB,EAAqBC,I;SACrDC,O;SACAC,M;SACAC,G;SACAC,Y;SACAC,a;;AAGT;AACA;AACA;AACA;AACA,OAAO,MAAMC,aAAa,GAAIC,GAAD,IAC3B,CAAC,CAAC,MAAD,EAAS,SAAT,EAAoB,iBAApB,EAAuC,aAAvC,EAAsDC,IAAtD,CAA4DC,CAAD,IAAO,OAAOF,GAAG,CAACE,CAAD,CAAV,KAAkB,UAApF,CADI;AAIP;AACA;AACA;AACA;;AACA,eAAe,MAAeC,WAAf,CAA2B;EAGxC;AACF;AACA;AACA;EACEC,WAAW,GAA6C;IAAA;;IAAA,IAA5C;MAAEC;IAAF,CAA4C,uEAAJ,EAAI;;IAAA,sCAiChCR,YAjCgC;;IACtD,wBAAKQ,SAAL,kEAAKA,SAAL,GAAmBA,SAAnB;EACD;EAED;AACF;AACA;AACA;AACA;AACA;AACA;;;EACuB,MAAfC,eAAe,CACnBC,EADmB,EAQW;IAAA,IAN9B;MAAEC,OAAF;MAAWH,SAAX;MAAsB,GAAGI;IAAzB,CAM8B,uEADuC,EACvC;IAC9B,MAAMC,QAAQ,GAAG,CAAC,MAAM,KAAKb,YAAL,CAAkB;MAAEQ;IAAF,CAAlB,CAAP,CAAjB;IACA,IAAIG,OAAO,KAAK,IAAhB,EAAsBE,QAAQ,CAACC,IAAT,CAAc,UAAd;IACtB,MAAMC,WAAW,GAAGjB,MAAM,CAACY,EAAD,CAA1B;IACA,MAAMM,eAAe,GAAGf,aAAa,CAAC,CAAC,QAAOgB,IAAP,CAAYJ,QAAQ,CAACK,IAAT,CAAc,GAAd,CAAZ,CAAD,EAAkCtB,IAAI,CAACmB,WAAD,CAAtC,CAAD,CAArC;IAEA,MAAMI,UAAU,GAAG,CAAC,MAAM,KAAKC,IAAL,CAAUJ,eAAV,EAA2BJ,OAA3B,CAAP,CAAnB;IACA,OAAOf,OAAO,CAAC;MAAEwB,SAAS,EAAEN,WAAb;MAA0BI;IAA1B,CAAD,EAAyCpB,GAAG,CAACuB,QAA7C,CAAP,CAA8DZ,EAArE;EACD;EAED;AACF;AACA;AACA;;;EAGE;AACF;AACA;AACA;AACA;AACA;EACmB,MAAXa,WAAW,CACfC,OADe,EAGe;IAAA,IAD9B;MAAEC,SAAS,GAAG,KAAd;MAAqB,GAAGb;IAAxB,CAC8B,uEAD+B,EAC/B;IAC9B,MAAMc,GAAG,GAAG,MAAM,KAAKN,IAAL,CAAU3B,aAAa,CAAC+B,OAAD,CAAvB,EAAkCZ,OAAlC,CAAlB;IACA,OAAOa,SAAS,GAAG,QAAOR,IAAP,CAAYS,GAAZ,EAAiBC,QAAjB,CAA0B,KAA1B,CAAH,GAAsCD,GAAtD;EACD;EAED;AACF;AACA;AACA;AACA;AACA;;;EACqB,MAAbhC,aAAa,CACjB8B,OADiB,EAEjBI,SAFiB,EAGjBhB,OAHiB,EAIC;IAClB,OAAOjB,mBAAmB,CACxB6B,OADwB,EAExB,OAAOI,SAAP,KAAqB,QAArB,GAAgC,QAAOX,IAAP,CAAYW,SAAZ,EAAuB,KAAvB,CAAhC,GAAgEA,SAFxC,EAGxB9B,MAAM,CAAC,MAAM,KAAK+B,OAAL,CAAajB,OAAb,CAAP,CAHkB,CAA1B;EAKD;EAED;AACF;AACA;AACA;AACA;AACA;;;AA/E0C"}

package/es/account/Memory.d.ts

@@ -0,0 +1,26 @@
+import AccountBase from './Base';
+import { Encoded } from '../utils/encoder';
+export interface Keypair {
+    publicKey: Encoded.AccountAddress;
+    secretKey: string | Uint8Array;
+}
+/**
+ * In-memory account class
+ */
+export default class AccountMemory extends AccountBase {
+    isGa: boolean;
+    /**
+     * @param options - Options
+     * @param options.keypair - Key pair to use
+     * @param options.keypair.publicKey - Public key
+     * @param options.keypair.secretKey - Private key
+     * @param options.gaId - Address of generalized account
+     */
+    constructor({ keypair, gaId, ...options }: {
+        keypair?: Keypair;
+        gaId?: Encoded.AccountAddress;
+    } & ConstructorParameters<typeof AccountBase>[0]);
+    sign(data: string | Uint8Array): Promise<Uint8Array>;
+    signTransaction(tx: Encoded.Transaction, options?: Parameters<AccountBase['signTransaction']>[1]): Promise<Encoded.Transaction>;
+    address(): Promise<Encoded.AccountAddress>;
+}

package/es/account/Memory.mjs

@@ -0,0 +1,103 @@
+import _buffer from "buffer";
+const {
+  Buffer: _Buffer
+} = _buffer;
+
+/*
+ * ISC License (ISC)
+ * Copyright (c) 2018 aeternity developers
+ *
+ *  Permission to use, copy, modify, and/or distribute this software for any
+ *  purpose with or without fee is hereby granted, provided that the above
+ *  copyright notice and this permission notice appear in all copies.
+ *
+ *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+ *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+ *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+ *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+ *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+ *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+ *  PERFORMANCE OF THIS SOFTWARE.
+ */
+import AccountBase from "./Base.mjs";
+import { sign, isValidKeypair } from "../utils/crypto.mjs";
+import { isHex } from "../utils/string.mjs";
+import { ArgumentError, InvalidKeypairError, MissingParamError } from "../utils/errors.mjs";
+import { decode } from "../utils/encoder.mjs";
+import { createMetaTx } from "../contract/ga.mjs";
+const secrets = new WeakMap();
+
+/**
+ * In-memory account class
+ */
+export default class AccountMemory extends AccountBase {
+  /**
+   * @param options - Options
+   * @param options.keypair - Key pair to use
+   * @param options.keypair.publicKey - Public key
+   * @param options.keypair.secretKey - Private key
+   * @param options.gaId - Address of generalized account
+   */
+  constructor(_ref) {
+    let {
+      keypair,
+      gaId,
+      ...options
+    } = _ref;
+    super(options);
+    this.isGa = gaId != null;
+
+    if (this.isGa && gaId != null) {
+      decode(gaId);
+      secrets.set(this, {
+        publicKey: gaId
+      });
+      return;
+    }
+
+    if (keypair == null) throw new MissingParamError('Either gaId or keypair is required');
+    if (!_Buffer.isBuffer(keypair.secretKey) && typeof keypair.secretKey === 'string' && !isHex(keypair.secretKey)) throw new InvalidKeypairError('Secret key must be hex string or Buffer');
+    const secretKey = typeof keypair.secretKey === 'string' ? _Buffer.from(keypair.secretKey, 'hex') : keypair.secretKey;
+
+    if (!isValidKeypair(secretKey, decode(keypair.publicKey))) {
+      throw new InvalidKeypairError('Invalid Key Pair');
+    }
+
+    secrets.set(this, {
+      secretKey,
+      publicKey: keypair.publicKey
+    });
+  }
+
+  async sign(data) {
+    if (this.isGa) throw new InvalidKeypairError('You are trying to sign data using generalized account without keypair');
+    return sign(data, secrets.get(this).secretKey);
+  }
+
+  async signTransaction(tx) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    if (!this.isGa || options.innerTx === true) return super.signTransaction(tx, options);
+    const {
+      authData,
+      authFun,
+      onCompiler,
+      onNode
+    } = options;
+
+    if (authFun == null || authData == null || onCompiler == null || onNode == null) {
+      throw new ArgumentError('authData, authFun, onCompiler, onNode', 'provided', null);
+    }
+
+    return createMetaTx(tx, authData, authFun, {
+      onCompiler,
+      onNode,
+      onAccount: this
+    });
+  }
+
+  async address() {
+    return secrets.get(this).publicKey;
+  }
+
+}
+//# sourceMappingURL=Memory.mjs.map

package/es/account/Memory.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Memory.mjs","names":["AccountBase","sign","isValidKeypair","isHex","ArgumentError","InvalidKeypairError","MissingParamError","decode","createMetaTx","secrets","WeakMap","AccountMemory","constructor","keypair","gaId","options","isGa","set","publicKey","isBuffer","secretKey","from","data","get","signTransaction","tx","innerTx","authData","authFun","onCompiler","onNode","onAccount","address"],"sources":["../../src/account/Memory.ts"],"sourcesContent":["/*\n * ISC License (ISC)\n * Copyright (c) 2018 aeternity developers\n *\n *  Permission to use, copy, modify, and/or distribute this software for any\n *  purpose with or without fee is hereby granted, provided that the above\n *  copyright notice and this permission notice appear in all copies.\n *\n *  THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n *  REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\n *  AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n *  INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\n *  LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\n *  OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\n *  PERFORMANCE OF THIS SOFTWARE.\n */\nimport AccountBase from './Base';\nimport { sign, isValidKeypair } from '../utils/crypto';\nimport { isHex } from '../utils/string';\nimport { ArgumentError, InvalidKeypairError, MissingParamError } from '../utils/errors';\nimport { decode, Encoded } from '../utils/encoder';\nimport { createMetaTx } from '../contract/ga';\n\nconst secrets = new WeakMap();\n\nexport interface Keypair {\n  publicKey: Encoded.AccountAddress;\n  secretKey: string | Uint8Array;\n}\n\n/**\n * In-memory account class\n */\nexport default class AccountMemory extends AccountBase {\n  isGa: boolean;\n\n  /**\n   * @param options - Options\n   * @param options.keypair - Key pair to use\n   * @param options.keypair.publicKey - Public key\n   * @param options.keypair.secretKey - Private key\n   * @param options.gaId - Address of generalized account\n   */\n  constructor(\n    { keypair, gaId, ...options }: { keypair?: Keypair; gaId?: Encoded.AccountAddress }\n    & ConstructorParameters<typeof AccountBase>[0],\n  ) {\n    super(options);\n\n    this.isGa = gaId != null;\n    if (this.isGa && gaId != null) {\n      decode(gaId);\n      secrets.set(this, { publicKey: gaId });\n      return;\n    }\n\n    if (keypair == null) throw new MissingParamError('Either gaId or keypair is required');\n\n    if (\n      !Buffer.isBuffer(keypair.secretKey)\n      && typeof keypair.secretKey === 'string' && !isHex(keypair.secretKey)\n    ) throw new InvalidKeypairError('Secret key must be hex string or Buffer');\n    const secretKey = typeof keypair.secretKey === 'string'\n      ? Buffer.from(keypair.secretKey, 'hex')\n      : keypair.secretKey;\n    if (!isValidKeypair(secretKey, decode(keypair.publicKey))) {\n      throw new InvalidKeypairError('Invalid Key Pair');\n    }\n\n    secrets.set(this, {\n      secretKey,\n      publicKey: keypair.publicKey,\n    });\n  }\n\n  async sign(data: string | Uint8Array): Promise<Uint8Array> {\n    if (this.isGa) throw new InvalidKeypairError('You are trying to sign data using generalized account without keypair');\n    return sign(data, secrets.get(this).secretKey);\n  }\n\n  async signTransaction(\n    tx: Encoded.Transaction,\n    options: Parameters<AccountBase['signTransaction']>[1] = {},\n  ): Promise<Encoded.Transaction> {\n    if (!this.isGa || options.innerTx === true) return super.signTransaction(tx, options);\n    const {\n      authData, authFun, onCompiler, onNode,\n    } = options;\n    if (authFun == null || authData == null || onCompiler == null || onNode == null) {\n      throw new ArgumentError('authData, authFun, onCompiler, onNode', 'provided', null);\n    }\n    return createMetaTx(tx, authData, authFun, { onCompiler, onNode, onAccount: this });\n  }\n\n  async address(): Promise<Encoded.AccountAddress> {\n    return secrets.get(this).publicKey;\n  }\n}\n"],"mappings":";;;;;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;OACOA,W;SACEC,I,EAAMC,c;SACNC,K;SACAC,a,EAAeC,mB,EAAqBC,iB;SACpCC,M;SACAC,Y;AAET,MAAMC,OAAO,GAAG,IAAIC,OAAJ,EAAhB;;AAOA;AACA;AACA;AACA,eAAe,MAAMC,aAAN,SAA4BX,WAA5B,CAAwC;EAGrD;AACF;AACA;AACA;AACA;AACA;AACA;EACEY,WAAW,OAGT;IAAA,IAFA;MAAEC,OAAF;MAAWC,IAAX;MAAiB,GAAGC;IAApB,CAEA;IACA,MAAMA,OAAN;IAEA,KAAKC,IAAL,GAAYF,IAAI,IAAI,IAApB;;IACA,IAAI,KAAKE,IAAL,IAAaF,IAAI,IAAI,IAAzB,EAA+B;MAC7BP,MAAM,CAACO,IAAD,CAAN;MACAL,OAAO,CAACQ,GAAR,CAAY,IAAZ,EAAkB;QAAEC,SAAS,EAAEJ;MAAb,CAAlB;MACA;IACD;;IAED,IAAID,OAAO,IAAI,IAAf,EAAqB,MAAM,IAAIP,iBAAJ,CAAsB,oCAAtB,CAAN;IAErB,IACE,CAAC,QAAOa,QAAP,CAAgBN,OAAO,CAACO,SAAxB,CAAD,IACG,OAAOP,OAAO,CAACO,SAAf,KAA6B,QADhC,IAC4C,CAACjB,KAAK,CAACU,OAAO,CAACO,SAAT,CAFpD,EAGE,MAAM,IAAIf,mBAAJ,CAAwB,yCAAxB,CAAN;IACF,MAAMe,SAAS,GAAG,OAAOP,OAAO,CAACO,SAAf,KAA6B,QAA7B,GACd,QAAOC,IAAP,CAAYR,OAAO,CAACO,SAApB,EAA+B,KAA/B,CADc,GAEdP,OAAO,CAACO,SAFZ;;IAGA,IAAI,CAAClB,cAAc,CAACkB,SAAD,EAAYb,MAAM,CAACM,OAAO,CAACK,SAAT,CAAlB,CAAnB,EAA2D;MACzD,MAAM,IAAIb,mBAAJ,CAAwB,kBAAxB,CAAN;IACD;;IAEDI,OAAO,CAACQ,GAAR,CAAY,IAAZ,EAAkB;MAChBG,SADgB;MAEhBF,SAAS,EAAEL,OAAO,CAACK;IAFH,CAAlB;EAID;;EAES,MAAJjB,IAAI,CAACqB,IAAD,EAAiD;IACzD,IAAI,KAAKN,IAAT,EAAe,MAAM,IAAIX,mBAAJ,CAAwB,uEAAxB,CAAN;IACf,OAAOJ,IAAI,CAACqB,IAAD,EAAOb,OAAO,CAACc,GAAR,CAAY,IAAZ,EAAkBH,SAAzB,CAAX;EACD;;EAEoB,MAAfI,eAAe,CACnBC,EADmB,EAGW;IAAA,IAD9BV,OAC8B,uEAD2B,EAC3B;IAC9B,IAAI,CAAC,KAAKC,IAAN,IAAcD,OAAO,CAACW,OAAR,KAAoB,IAAtC,EAA4C,OAAO,MAAMF,eAAN,CAAsBC,EAAtB,EAA0BV,OAA1B,CAAP;IAC5C,MAAM;MACJY,QADI;MACMC,OADN;MACeC,UADf;MAC2BC;IAD3B,IAEFf,OAFJ;;IAGA,IAAIa,OAAO,IAAI,IAAX,IAAmBD,QAAQ,IAAI,IAA/B,IAAuCE,UAAU,IAAI,IAArD,IAA6DC,MAAM,IAAI,IAA3E,EAAiF;MAC/E,MAAM,IAAI1B,aAAJ,CAAkB,uCAAlB,EAA2D,UAA3D,EAAuE,IAAvE,CAAN;IACD;;IACD,OAAOI,YAAY,CAACiB,EAAD,EAAKE,QAAL,EAAeC,OAAf,EAAwB;MAAEC,UAAF;MAAcC,MAAd;MAAsBC,SAAS,EAAE;IAAjC,CAAxB,CAAnB;EACD;;EAEY,MAAPC,OAAO,GAAoC;IAC/C,OAAOvB,OAAO,CAACc,GAAR,CAAY,IAAZ,EAAkBL,SAAzB;EACD;;AA/DoD"}

package/es/account/Rpc.d.ts

@@ -0,0 +1,27 @@
+import AccountBase from './Base';
+import { Encoded } from '../utils/encoder';
+/**
+ * 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 {
+    _rpcClient: any;
+    _address: Encoded.AccountAddress;
+    constructor({ rpcClient, address, ...options }: {
+        rpcClient: any;
+        address: Encoded.AccountAddress;
+    } & ConstructorParameters<typeof AccountBase>[0]);
+    sign(): Promise<Uint8Array>;
+    address(): Promise<Encoded.AccountAddress>;
+    /**
+     * @returns Signed transaction
+     */
+    signTransaction(tx: Encoded.Transaction, { innerTx, networkId }?: Parameters<AccountBase['signTransaction']>[1]): Promise<Encoded.Transaction>;
+    /**
+     * @returns Signed message
+     */
+    signMessage(message: string, { returnHex }?: Parameters<AccountBase['signMessage']>[1]): Promise<string | Uint8Array>;
+}

package/es/account/Rpc.mjs

@@ -0,0 +1,80 @@
+import _buffer from "buffer";
+const {
+  Buffer: _Buffer
+} = _buffer;
+import AccountBase from "./Base.mjs";
+import { METHODS } from "../aepp-wallet-communication/schema.mjs";
+import { NotImplementedError } from "../utils/errors.mjs";
+
+/**
+ * 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(_ref) {
+    let {
+      rpcClient,
+      address,
+      ...options
+    } = _ref;
+    super(options);
+    this._rpcClient = rpcClient;
+    this._address = address;
+  } // eslint-disable-next-line class-methods-use-this
+
+
+  async sign() {
+    throw new NotImplementedError('RAW signing using wallet');
+  }
+
+  async address() {
+    return this._address;
+  }
+  /**
+   * @returns Signed transaction
+   */
+
+
+  async signTransaction(tx) {
+    let {
+      innerTx,
+      networkId
+    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    if (innerTx != null) throw new NotImplementedError('innerTx option in AccountRpc');
+    const res = await this._rpcClient.request(METHODS.sign, {
+      onAccount: this._address,
+      tx,
+      returnSigned: true,
+
+      /**
+       * @deprecated Wallet provided networkId will be used (current network)
+       * required to maintain backward compatibility with wallets using SDK v11.0.1 and below
+       * @see {@link https://github.com/aeternity/aepp-sdk-js/commit/153fd89a52c4eab39fcd659b356b36d32129c1ba}
+       */
+      networkId
+    });
+    return res.signedTransaction;
+  }
+  /**
+   * @returns Signed message
+   */
+
+
+  async signMessage(message) {
+    let {
+      returnHex = false
+    } = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    const {
+      signature
+    } = await this._rpcClient.request(METHODS.signMessage, {
+      onAccount: this._address,
+      message
+    });
+    return returnHex ? signature : _Buffer.from(signature, 'hex');
+  }
+
+}
+//# sourceMappingURL=Rpc.mjs.map

package/es/account/Rpc.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Rpc.mjs","names":["AccountBase","METHODS","NotImplementedError","AccountRpc","constructor","rpcClient","address","options","_rpcClient","_address","sign","signTransaction","tx","innerTx","networkId","res","request","onAccount","returnSigned","signedTransaction","signMessage","message","returnHex","signature","from"],"sources":["../../src/account/Rpc.ts"],"sourcesContent":["import AccountBase from './Base';\nimport { METHODS } from '../aepp-wallet-communication/schema';\nimport { NotImplementedError } from '../utils/errors';\nimport { Encoded } from '../utils/encoder';\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: any;\n\n  _address: Encoded.AccountAddress;\n\n  constructor(\n    { rpcClient, address, ...options }: { rpcClient: any; address: Encoded.AccountAddress }\n    & ConstructorParameters<typeof AccountBase>[0],\n  ) {\n    super(options);\n    this._rpcClient = rpcClient;\n    this._address = address;\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  async sign(): Promise<Uint8Array> {\n    throw new NotImplementedError('RAW signing using wallet');\n  }\n\n  async address(): Promise<Encoded.AccountAddress> {\n    return this._address;\n  }\n\n  /**\n   * @returns Signed transaction\n   */\n  async signTransaction(\n    tx: Encoded.Transaction,\n    { innerTx, networkId }: Parameters<AccountBase['signTransaction']>[1] = {},\n  ): Promise<Encoded.Transaction> {\n    if (innerTx != null) throw new NotImplementedError('innerTx option in AccountRpc');\n    const res = await this._rpcClient.request(METHODS.sign, {\n      onAccount: this._address,\n      tx,\n      returnSigned: true,\n      /**\n       * @deprecated Wallet provided networkId will be used (current network)\n       * required to maintain backward compatibility with wallets using SDK v11.0.1 and below\n       * @see {@link https://github.com/aeternity/aepp-sdk-js/commit/153fd89a52c4eab39fcd659b356b36d32129c1ba}\n       */\n      networkId,\n    });\n    return res.signedTransaction;\n  }\n\n  /**\n   * @returns Signed message\n   */\n  async signMessage(\n    message: string,\n    { returnHex = false }: Parameters<AccountBase['signMessage']>[1] = {},\n  ): Promise<string | Uint8Array> {\n    const { signature } = await this._rpcClient\n      .request(METHODS.signMessage, { onAccount: this._address, message });\n    return returnHex ? signature : Buffer.from(signature, 'hex');\n  }\n}\n"],"mappings":";;;;OAAOA,W;SACEC,O;SACAC,mB;;AAGT;AACA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe,MAAMC,UAAN,SAAyBH,WAAzB,CAAqC;EAKlDI,WAAW,OAGT;IAAA,IAFA;MAAEC,SAAF;MAAaC,OAAb;MAAsB,GAAGC;IAAzB,CAEA;IACA,MAAMA,OAAN;IACA,KAAKC,UAAL,GAAkBH,SAAlB;IACA,KAAKI,QAAL,GAAgBH,OAAhB;EACD,CAZiD,CAclD;;;EACU,MAAJI,IAAI,GAAwB;IAChC,MAAM,IAAIR,mBAAJ,CAAwB,0BAAxB,CAAN;EACD;;EAEY,MAAPI,OAAO,GAAoC;IAC/C,OAAO,KAAKG,QAAZ;EACD;EAED;AACF;AACA;;;EACuB,MAAfE,eAAe,CACnBC,EADmB,EAGW;IAAA,IAD9B;MAAEC,OAAF;MAAWC;IAAX,CAC8B,uEAD0C,EAC1C;IAC9B,IAAID,OAAO,IAAI,IAAf,EAAqB,MAAM,IAAIX,mBAAJ,CAAwB,8BAAxB,CAAN;IACrB,MAAMa,GAAG,GAAG,MAAM,KAAKP,UAAL,CAAgBQ,OAAhB,CAAwBf,OAAO,CAACS,IAAhC,EAAsC;MACtDO,SAAS,EAAE,KAAKR,QADsC;MAEtDG,EAFsD;MAGtDM,YAAY,EAAE,IAHwC;;MAItD;AACN;AACA;AACA;AACA;MACMJ;IATsD,CAAtC,CAAlB;IAWA,OAAOC,GAAG,CAACI,iBAAX;EACD;EAED;AACF;AACA;;;EACmB,MAAXC,WAAW,CACfC,OADe,EAGe;IAAA,IAD9B;MAAEC,SAAS,GAAG;IAAd,CAC8B,uEADqC,EACrC;IAC9B,MAAM;MAAEC;IAAF,IAAgB,MAAM,KAAKf,UAAL,CACzBQ,OADyB,CACjBf,OAAO,CAACmB,WADS,EACI;MAAEH,SAAS,EAAE,KAAKR,QAAlB;MAA4BY;IAA5B,CADJ,CAA5B;IAEA,OAAOC,SAAS,GAAGC,SAAH,GAAe,QAAOC,IAAP,CAAYD,SAAZ,EAAuB,KAAvB,CAA/B;EACD;;AAvDiD"}

package/es/aens.d.ts

@@ -0,0 +1,222 @@
+/// <reference types="node" />
+/**
+ * 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 BigNumber from 'bignumber.js';
+import { Tag, AensName } from './tx/builder/constants';
+import { Encoded } from './utils/encoder';
+import { send, SendOptions } from './spend';
+import { getName } from './chain';
+import { BuildTxOptions } from './tx';
+import { TransformNodeType } from './Node';
+import { NameEntry, NamePointer } from './apis/node';
+import AccountBase from './account/Base';
+interface KeyPointers {
+    [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
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @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 send>;
+interface AensRevokeOptions extends 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
+ * @param options.extendPointers - Get the pointers from the node and merge with provided
+ * ones. Pointers with the same type will be overwritten
+ * @param options.onAccount - Make operation on specific account from sdk (you
+ * pass publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @param options.nameTtl - Name ttl represented in number of
+ * blocks (Max value is 50000 blocks)
+ * @param options.clientTtl=84600 a suggestion as to how long any
+ * clients should cache this information
+ * @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 send>;
+interface AensUpdateOptions extends BuildTxOptions<Tag.NameUpdateTx, 'nameId' | 'accountId' | 'pointers' | 'clientTtl' | 'nameTtl'>, SendOptions {
+    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
+ * @param options.onAccount - Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @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 send>;
+interface AensTransferOptions extends 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
+ * @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
+ * @param options - options
+ * @param options.onAccount - Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @param options.nameFee - Name Fee (By default calculated by sdk)
+ * @returns the result of the claim
+ * @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>;
+declare type AensClaimOptionsType = BuildTxOptions<Tag.NameClaimTx, 'accountId' | 'nameSalt' | 'name'> & SendOptions & Parameters<typeof aensQuery>[1];
+interface AensClaimOptions extends AensClaimOptionsType {
+}
+interface AensClaimReturnType extends Awaited<ReturnType<typeof send>>, Partial<Awaited<ReturnType<typeof aensQuery>>> {
+}
+/**
+ * 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
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @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
+ * }
+ * ```
+ */
+export declare 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>;
+}>>;
+interface AensPreclaimOptions extends 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
+ * @param options.onAccount - Make operation on specific account from sdk (you pass
+ * publickKey) or using provided KeyPair(Can be keypair object or MemoryAccount)
+ * @param options.fee - fee
+ * @param options.ttl - ttl
+ * @param options.nonce - nonce
+ * @returns Transaction result
+ * @example
+ * ```js
+ * const name = 'test.chain'
+ * const bidFee = computeBidFee(name, startFee, incrementPercentage)
+ *
+ * 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 {};