@aeternity/aepp-sdk 13.3.3 → 14.0.0

package/es/account/Memory.js

@@ -0,0 +1,97 @@
+import { Buffer as _Buffer } from "buffer";
+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 _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+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"); }
+import nacl from 'tweetnacl';
+import AccountBase from './Base.js';
+import { hash, messageToHash, messagePrefixLength } from '../utils/crypto.js';
+import { ArgumentError } from '../utils/errors.js';
+import { decode, encode, Encoding } from '../utils/encoder.js';
+import { concatBuffers } from '../utils/other.js';
+import { hashTypedData } from '../utils/typed-data.js';
+import { buildTx } from '../tx/builder/index.js';
+import { Tag } from '../tx/builder/constants.js';
+export function getBufferToSign(transaction, networkId, innerTx) {
+  const prefixes = [networkId];
+  if (innerTx) prefixes.push('inner_tx');
+  const rlpBinaryTx = decode(transaction);
+  return concatBuffers([_Buffer.from(prefixes.join('-')), hash(rlpBinaryTx)]);
+}
+
+/**
+ * In-memory account class
+ */
+var _secretKeyDecoded = /*#__PURE__*/new WeakMap();
+export default class AccountMemory extends AccountBase {
+  /**
+   * @param secretKey - Secret key
+   */
+  constructor(secretKey) {
+    super();
+    _classPrivateFieldInitSpec(this, _secretKeyDecoded, void 0);
+    this.secretKey = secretKey;
+    const keyPair = nacl.sign.keyPair.fromSeed(decode(secretKey));
+    _classPrivateFieldSet(_secretKeyDecoded, this, keyPair.secretKey);
+    this.address = encode(keyPair.publicKey, Encoding.AccountAddress);
+  }
+
+  /**
+   * Generates a new AccountMemory using a random secret key
+   */
+  static generate() {
+    const secretKey = encode(nacl.randomBytes(32), Encoding.AccountSecretKey);
+    return new AccountMemory(secretKey);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async sign(data, options) {
+    return nacl.sign.detached(_Buffer.from(data), _classPrivateFieldGet(_secretKeyDecoded, this));
+  }
+  async signTransaction(transaction, {
+    innerTx,
+    networkId,
+    ...options
+  } = {}) {
+    if (networkId == null) {
+      throw new ArgumentError('networkId', 'provided', networkId);
+    }
+    const rlpBinaryTx = decode(transaction);
+    const txWithNetworkId = getBufferToSign(transaction, networkId, innerTx === true);
+    const signatures = [await this.sign(txWithNetworkId, options)];
+    return buildTx({
+      tag: Tag.SignedTx,
+      encodedTx: rlpBinaryTx,
+      signatures
+    });
+  }
+  async signMessage(message, options) {
+    return this.sign(messageToHash(message), options);
+  }
+  async signTypedData(data, aci, {
+    name,
+    version,
+    networkId,
+    contractAddress,
+    ...options
+  } = {}) {
+    const dHash = hashTypedData(data, aci, {
+      name,
+      version,
+      networkId,
+      contractAddress
+    });
+    const signature = await this.sign(dHash, options);
+    return encode(signature, Encoding.Signature);
+  }
+  async signDelegation(delegation, {
+    networkId
+  } = {}) {
+    if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
+    const payload = concatBuffers([messagePrefixLength, new Uint8Array([1]), _Buffer.from(networkId), decode(delegation)]);
+    const signature = await this.sign(payload);
+    return encode(signature, Encoding.Signature);
+  }
+}
+//# sourceMappingURL=Memory.js.map

package/es/account/Memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Memory.js","names":["nacl","AccountBase","hash","messageToHash","messagePrefixLength","ArgumentError","decode","encode","Encoding","concatBuffers","hashTypedData","buildTx","Tag","getBufferToSign","transaction","networkId","innerTx","prefixes","push","rlpBinaryTx","_Buffer","from","join","_secretKeyDecoded","WeakMap","AccountMemory","constructor","secretKey","_classPrivateFieldInitSpec","keyPair","sign","fromSeed","_classPrivateFieldSet","address","publicKey","AccountAddress","generate","randomBytes","AccountSecretKey","data","options","detached","_classPrivateFieldGet","signTransaction","txWithNetworkId","signatures","tag","SignedTx","encodedTx","signMessage","message","signTypedData","aci","name","version","contractAddress","dHash","signature","Signature","signDelegation","delegation","payload","Uint8Array"],"sources":["../../src/account/Memory.ts"],"sourcesContent":["import nacl from 'tweetnacl';\nimport AccountBase from './Base.js';\nimport { hash, messageToHash, messagePrefixLength } from '../utils/crypto.js';\nimport { ArgumentError } from '../utils/errors.js';\nimport { decode, encode, Encoded, Encoding } from '../utils/encoder.js';\nimport { concatBuffers } from '../utils/other.js';\nimport { hashTypedData, AciValue } from '../utils/typed-data.js';\nimport { buildTx } from '../tx/builder/index.js';\nimport { Tag } from '../tx/builder/constants.js';\n\nexport function getBufferToSign(\n  transaction: Encoded.Transaction,\n  networkId: string,\n  innerTx: boolean,\n): Uint8Array {\n  const prefixes = [networkId];\n  if (innerTx) prefixes.push('inner_tx');\n  const rlpBinaryTx = decode(transaction);\n  return concatBuffers([Buffer.from(prefixes.join('-')), hash(rlpBinaryTx)]);\n}\n\n/**\n * In-memory account class\n */\nexport default class AccountMemory extends AccountBase {\n  override readonly address: Encoded.AccountAddress;\n\n  readonly #secretKeyDecoded: Uint8Array;\n\n  /**\n   * @param secretKey - Secret key\n   */\n  constructor(public readonly secretKey: Encoded.AccountSecretKey) {\n    super();\n    const keyPair = nacl.sign.keyPair.fromSeed(decode(secretKey));\n    this.#secretKeyDecoded = keyPair.secretKey;\n    this.address = encode(keyPair.publicKey, Encoding.AccountAddress);\n  }\n\n  /**\n   * Generates a new AccountMemory using a random secret key\n   */\n  static generate(): AccountMemory {\n    const secretKey = encode(nacl.randomBytes(32), Encoding.AccountSecretKey);\n    return new AccountMemory(secretKey);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unused-vars\n  override async sign(data: string | Uint8Array, options?: any): Promise<Uint8Array> {\n    return nacl.sign.detached(Buffer.from(data), this.#secretKeyDecoded);\n  }\n\n  override async signTransaction(\n    transaction: Encoded.Transaction,\n    { innerTx, networkId, ...options }: { innerTx?: boolean; networkId?: string } = {},\n  ): Promise<Encoded.Transaction> {\n    if (networkId == null) {\n      throw new ArgumentError('networkId', 'provided', networkId);\n    }\n    const rlpBinaryTx = decode(transaction);\n    const txWithNetworkId = getBufferToSign(transaction, networkId, innerTx === true);\n\n    const signatures = [await this.sign(txWithNetworkId, options)];\n    return buildTx({ tag: Tag.SignedTx, encodedTx: rlpBinaryTx, signatures });\n  }\n\n  override async signMessage(message: string, options?: any): Promise<Uint8Array> {\n    return this.sign(messageToHash(message), options);\n  }\n\n  override async signTypedData(\n    data: Encoded.ContractBytearray,\n    aci: AciValue,\n    {\n      name,\n      version,\n      networkId,\n      contractAddress,\n      ...options\n    }: Parameters<AccountBase['signTypedData']>[2] = {},\n  ): Promise<Encoded.Signature> {\n    const dHash = hashTypedData(data, aci, {\n      name,\n      version,\n      networkId,\n      contractAddress,\n    });\n    const signature = await this.sign(dHash, options);\n    return encode(signature, Encoding.Signature);\n  }\n\n  override async signDelegation(\n    delegation: Encoded.Bytearray,\n    { networkId }: { networkId?: string } = {},\n  ): Promise<Encoded.Signature> {\n    if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);\n    const payload = concatBuffers([\n      messagePrefixLength,\n      new Uint8Array([1]),\n      Buffer.from(networkId),\n      decode(delegation),\n    ]);\n    const signature = await this.sign(payload);\n    return encode(signature, Encoding.Signature);\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/es/account/Metamask.d.ts

@@ -0,0 +1,26 @@
+import type { BaseProvider } from '@metamask/providers';
+import AccountBase from './Base.js';
+import { Encoded } from '../utils/encoder.js';
+export declare const snapId = "npm:@aeternity-snap/plugin";
+export declare function invokeSnap<R>(provider: BaseProvider, method: string, params: unknown, key: string): Promise<R>;
+/**
+ * Account connected to Aeternity Snap for MetaMask
+ * https://www.npmjs.com/package/\@aeternity-snap/plugin
+ */
+export default class AccountMetamask extends AccountBase {
+    readonly provider: BaseProvider;
+    readonly index: number;
+    readonly address: Encoded.AccountAddress;
+    /**
+     * @param address - Address of account
+     */
+    constructor(provider: BaseProvider, index: number, address: Encoded.AccountAddress);
+    sign(): Promise<Uint8Array>;
+    signTypedData(): Promise<Encoded.Signature>;
+    signDelegation(): Promise<Encoded.Signature>;
+    signTransaction(tx: Encoded.Transaction, { innerTx, networkId }?: {
+        innerTx?: boolean;
+        networkId?: string;
+    }): Promise<Encoded.Transaction>;
+    signMessage(message: string): Promise<Uint8Array>;
+}

package/es/account/Metamask.js

@@ -0,0 +1,76 @@
+import { Buffer as _Buffer } from "buffer";
+import AccountBase from './Base.js';
+import { ArgumentError, InternalError, NotImplementedError } from '../utils/errors.js';
+export const snapId = 'npm:@aeternity-snap/plugin';
+export async function invokeSnap(provider, method, params, key) {
+  const response = await provider.request({
+    method: 'wallet_invokeSnap',
+    params: {
+      snapId,
+      request: {
+        method,
+        params
+      }
+    }
+  });
+  if (response == null) throw new InternalError('Empty MetaMask response');
+  if (!(key in response)) {
+    throw new InternalError(`Key ${key} missed in response ${JSON.stringify(response)}`);
+  }
+  return response[key];
+}
+
+/**
+ * Account connected to Aeternity Snap for MetaMask
+ * https://www.npmjs.com/package/\@aeternity-snap/plugin
+ */
+export default class AccountMetamask extends AccountBase {
+  /**
+   * @param address - Address of account
+   */
+  constructor(provider, index, address) {
+    super();
+    this.provider = provider;
+    this.index = index;
+    this.address = address;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async sign() {
+    throw new NotImplementedError('RAW signing using MetaMask');
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async signTypedData() {
+    throw new NotImplementedError('Typed data signing using MetaMask');
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async signDelegation() {
+    throw new NotImplementedError('signing delegation using MetaMask');
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async signTransaction(tx, {
+    innerTx,
+    networkId
+  } = {}) {
+    if (innerTx != null) throw new NotImplementedError('innerTx option in AccountMetamask');
+    if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
+    return invokeSnap(this.provider, 'signTransaction', {
+      derivationPath: [`${this.index}'`, "0'", "0'"],
+      tx,
+      networkId
+    }, 'signedTx');
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async signMessage(message) {
+    const signature = await invokeSnap(this.provider, 'signMessage', {
+      derivationPath: [`${this.index}'`, "0'", "0'"],
+      message: _Buffer.from(message).toString('base64')
+    }, 'signature');
+    return _Buffer.from(signature, 'base64');
+  }
+}
+//# sourceMappingURL=Metamask.js.map

package/es/account/Metamask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Metamask.js","names":["AccountBase","ArgumentError","InternalError","NotImplementedError","snapId","invokeSnap","provider","method","params","key","response","request","JSON","stringify","AccountMetamask","constructor","index","address","sign","signTypedData","signDelegation","signTransaction","tx","innerTx","networkId","derivationPath","signMessage","message","signature","_Buffer","from","toString"],"sources":["../../src/account/Metamask.ts"],"sourcesContent":["import type { BaseProvider } from '@metamask/providers';\nimport AccountBase from './Base.js';\nimport { Encoded } from '../utils/encoder.js';\nimport { ArgumentError, InternalError, NotImplementedError } from '../utils/errors.js';\n\nexport const snapId = 'npm:@aeternity-snap/plugin';\n\nexport async function invokeSnap<R>(\n  provider: BaseProvider,\n  method: string,\n  params: unknown,\n  key: string,\n): Promise<R> {\n  const response = await provider.request<{ [k in string]: unknown }>({\n    method: 'wallet_invokeSnap',\n    params: { snapId, request: { method, params } },\n  });\n  if (response == null) throw new InternalError('Empty MetaMask response');\n  if (!(key in response)) {\n    throw new InternalError(`Key ${key} missed in response ${JSON.stringify(response)}`);\n  }\n  return response[key] as R;\n}\n\n/**\n * Account connected to Aeternity Snap for MetaMask\n * https://www.npmjs.com/package/\\@aeternity-snap/plugin\n */\nexport default class AccountMetamask extends AccountBase {\n  readonly provider: BaseProvider;\n\n  readonly index: number;\n\n  override readonly address: Encoded.AccountAddress;\n\n  /**\n   * @param address - Address of account\n   */\n  constructor(provider: BaseProvider, index: number, address: Encoded.AccountAddress) {\n    super();\n    this.provider = provider;\n    this.index = index;\n    this.address = address;\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  override async sign(): Promise<Uint8Array> {\n    throw new NotImplementedError('RAW signing using MetaMask');\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  override async signTypedData(): Promise<Encoded.Signature> {\n    throw new NotImplementedError('Typed data signing using MetaMask');\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  override async signDelegation(): Promise<Encoded.Signature> {\n    throw new NotImplementedError('signing delegation using MetaMask');\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  override async signTransaction(\n    tx: Encoded.Transaction,\n    { innerTx, networkId }: { innerTx?: boolean; networkId?: string } = {},\n  ): Promise<Encoded.Transaction> {\n    if (innerTx != null) throw new NotImplementedError('innerTx option in AccountMetamask');\n    if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);\n\n    return invokeSnap<Encoded.Transaction>(\n      this.provider,\n      'signTransaction',\n      { derivationPath: [`${this.index}'`, \"0'\", \"0'\"], tx, networkId },\n      'signedTx',\n    );\n  }\n\n  // eslint-disable-next-line class-methods-use-this\n  override async signMessage(message: string): Promise<Uint8Array> {\n    const signature = await invokeSnap<string>(\n      this.provider,\n      'signMessage',\n      {\n        derivationPath: [`${this.index}'`, \"0'\", \"0'\"],\n        message: Buffer.from(message).toString('base64'),\n      },\n      'signature',\n    );\n    return Buffer.from(signature, 'base64');\n  }\n}\n"],"mappings":";AACA,OAAOA,WAAW,MAAM,WAAW;AAEnC,SAASC,aAAa,EAAEC,aAAa,EAAEC,mBAAmB,QAAQ,oBAAoB;AAEtF,OAAO,MAAMC,MAAM,GAAG,4BAA4B;AAElD,OAAO,eAAeC,UAAUA,CAC9BC,QAAsB,EACtBC,MAAc,EACdC,MAAe,EACfC,GAAW,EACC;EACZ,MAAMC,QAAQ,GAAG,MAAMJ,QAAQ,CAACK,OAAO,CAA6B;IAClEJ,MAAM,EAAE,mBAAmB;IAC3BC,MAAM,EAAE;MAAEJ,MAAM;MAAEO,OAAO,EAAE;QAAEJ,MAAM;QAAEC;MAAO;IAAE;EAChD,CAAC,CAAC;EACF,IAAIE,QAAQ,IAAI,IAAI,EAAE,MAAM,IAAIR,aAAa,CAAC,yBAAyB,CAAC;EACxE,IAAI,EAAEO,GAAG,IAAIC,QAAQ,CAAC,EAAE;IACtB,MAAM,IAAIR,aAAa,CAAC,OAAOO,GAAG,uBAAuBG,IAAI,CAACC,SAAS,CAACH,QAAQ,CAAC,EAAE,CAAC;EACtF;EACA,OAAOA,QAAQ,CAACD,GAAG,CAAC;AACtB;;AAEA;AACA;AACA;AACA;AACA,eAAe,MAAMK,eAAe,SAASd,WAAW,CAAC;EAOvD;AACF;AACA;EACEe,WAAWA,CAACT,QAAsB,EAAEU,KAAa,EAAEC,OAA+B,EAAE;IAClF,KAAK,CAAC,CAAC;IACP,IAAI,CAACX,QAAQ,GAAGA,QAAQ;IACxB,IAAI,CAACU,KAAK,GAAGA,KAAK;IAClB,IAAI,CAACC,OAAO,GAAGA,OAAO;EACxB;;EAEA;EACA,MAAeC,IAAIA,CAAA,EAAwB;IACzC,MAAM,IAAIf,mBAAmB,CAAC,4BAA4B,CAAC;EAC7D;;EAEA;EACA,MAAegB,aAAaA,CAAA,EAA+B;IACzD,MAAM,IAAIhB,mBAAmB,CAAC,mCAAmC,CAAC;EACpE;;EAEA;EACA,MAAeiB,cAAcA,CAAA,EAA+B;IAC1D,MAAM,IAAIjB,mBAAmB,CAAC,mCAAmC,CAAC;EACpE;;EAEA;EACA,MAAekB,eAAeA,CAC5BC,EAAuB,EACvB;IAAEC,OAAO;IAAEC;EAAqD,CAAC,GAAG,CAAC,CAAC,EACxC;IAC9B,IAAID,OAAO,IAAI,IAAI,EAAE,MAAM,IAAIpB,mBAAmB,CAAC,mCAAmC,CAAC;IACvF,IAAIqB,SAAS,IAAI,IAAI,EAAE,MAAM,IAAIvB,aAAa,CAAC,WAAW,EAAE,UAAU,EAAEuB,SAAS,CAAC;IAElF,OAAOnB,UAAU,CACf,IAAI,CAACC,QAAQ,EACb,iBAAiB,EACjB;MAAEmB,cAAc,EAAE,CAAC,GAAG,IAAI,CAACT,KAAK,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC;MAAEM,EAAE;MAAEE;IAAU,CAAC,EACjE,UACF,CAAC;EACH;;EAEA;EACA,MAAeE,WAAWA,CAACC,OAAe,EAAuB;IAC/D,MAAMC,SAAS,GAAG,MAAMvB,UAAU,CAChC,IAAI,CAACC,QAAQ,EACb,aAAa,EACb;MACEmB,cAAc,EAAE,CAAC,GAAG,IAAI,CAACT,KAAK,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC;MAC9CW,OAAO,EAAEE,OAAA,CAAOC,IAAI,CAACH,OAAO,CAAC,CAACI,QAAQ,CAAC,QAAQ;IACjD,CAAC,EACD,WACF,CAAC;IACD,OAAOF,OAAA,CAAOC,IAAI,CAACF,SAAS,EAAE,QAAQ,CAAC;EACzC;AACF","ignoreList":[]}

package/es/account/MetamaskFactory.d.ts

@@ -0,0 +1,40 @@
+import type { BaseProvider } from '@metamask/providers';
+import AccountBaseFactory from './BaseFactory.js';
+import AccountMetamask, { snapId } from './Metamask.js';
+interface SnapDetails {
+    blocked: boolean;
+    enabled: boolean;
+    id: typeof snapId;
+    version: string;
+    initialPermissions: Record<string, unknown>;
+}
+/**
+ * A factory class that generates instances of AccountMetamask.
+ */
+export default class AccountMetamaskFactory extends AccountBaseFactory {
+    #private;
+    readonly provider: BaseProvider;
+    /**
+     * @param provider - Connection to MetaMask to use
+     */
+    constructor(provider?: BaseProvider);
+    /**
+     * Request MetaMask to install Aeternity snap.
+     */
+    installSnap(): Promise<SnapDetails>;
+    /**
+     * It throws an exception if MetaMask or Aeternity snap has an incompatible version or is not
+     * installed.
+     */
+    ensureReady(): Promise<void>;
+    /**
+     * @returns the version of snap installed in MetaMask
+     */
+    getSnapVersion(): Promise<string>;
+    /**
+     * Get an instance of AccountMetaMask for a given account index.
+     * @param accountIndex - Index of account
+     */
+    initialize(accountIndex: number): Promise<AccountMetamask>;
+}
+export {};

package/es/account/MetamaskFactory.js

@@ -0,0 +1,110 @@
+function _classPrivateFieldInitSpec(e, t, a) { _checkPrivateRedeclaration(e, t), t.set(e, a); }
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+function _checkPrivateRedeclaration(e, t) { if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object"); }
+function _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+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"); }
+import { InternalError, UnsupportedPlatformError, UnsupportedVersionError } from '../utils/errors.js';
+import semverSatisfies from '../utils/semver-satisfies.js';
+import AccountBaseFactory from './BaseFactory.js';
+import AccountMetamask, { invokeSnap, snapId } from './Metamask.js';
+const snapMinVersion = '0.0.9';
+const snapMaxVersion = '0.1.0';
+var _AccountMetamaskFactory_brand = /*#__PURE__*/new WeakSet();
+var _ensureReadyPromise = /*#__PURE__*/new WeakMap();
+/**
+ * A factory class that generates instances of AccountMetamask.
+ */
+export default class AccountMetamaskFactory extends AccountBaseFactory {
+  /**
+   * @param provider - Connection to MetaMask to use
+   */
+  constructor(provider) {
+    super();
+    /**
+     * It throws an exception if MetaMask has an incompatible version.
+     */
+    _classPrivateMethodInitSpec(this, _AccountMetamaskFactory_brand);
+    _classPrivateFieldInitSpec(this, _ensureReadyPromise, void 0);
+    if (provider != null) {
+      this.provider = provider;
+      return;
+    }
+    if (window == null) {
+      throw new UnsupportedPlatformError('Window object not found, you can run AccountMetamaskFactory only in browser or setup a provider');
+    }
+    if (!('ethereum' in window) || window.ethereum == null) {
+      throw new UnsupportedPlatformError('`ethereum` object not found, you can run AccountMetamaskFactory only with Metamask enabled or setup a provider');
+    }
+    this.provider = window.ethereum;
+  }
+  /**
+   * Request MetaMask to install Aeternity snap.
+   */
+  async installSnap() {
+    await _assertClassBrand(_AccountMetamaskFactory_brand, this, _ensureMetamaskSupported).call(this);
+    const details = await this.provider.request({
+      method: 'wallet_requestSnaps',
+      params: {
+        [snapId]: {
+          version: snapMinVersion
+        }
+      }
+    });
+    _classPrivateFieldSet(_ensureReadyPromise, this, Promise.resolve());
+    return details[snapId];
+  }
+
+  /**
+   * It throws an exception if MetaMask or Aeternity snap has an incompatible version or is not
+   * installed.
+   */
+  async ensureReady() {
+    const snapVersion = await this.getSnapVersion();
+    const args = [snapVersion, snapMinVersion, snapMaxVersion];
+    if (!semverSatisfies(...args)) throw new UnsupportedVersionError('Aeternity snap in MetaMask', ...args);
+    _classPrivateFieldSet(_ensureReadyPromise, this, Promise.resolve());
+  }
+  /**
+   * @returns the version of snap installed in MetaMask
+   */
+  async getSnapVersion() {
+    await _assertClassBrand(_AccountMetamaskFactory_brand, this, _ensureMetamaskSupported).call(this);
+    const snaps = await this.provider.request({
+      method: 'wallet_getSnaps'
+    });
+    const version = snaps[snapId]?.version;
+    if (version == null) throw new UnsupportedPlatformError('Aeternity snap is not installed to MetaMask');
+    return version;
+  }
+
+  /**
+   * Get an instance of AccountMetaMask for a given account index.
+   * @param accountIndex - Index of account
+   */
+  async initialize(accountIndex) {
+    await _assertClassBrand(_AccountMetamaskFactory_brand, this, _ensureReady).call(this);
+    const address = await invokeSnap(this.provider, 'getPublicKey', {
+      derivationPath: [`${accountIndex}'`, "0'", "0'"]
+    }, 'publicKey');
+    return new AccountMetamask(this.provider, accountIndex, address);
+  }
+}
+async function _ensureMetamaskSupported() {
+  const version = await this.provider.request({
+    method: 'web3_clientVersion'
+  });
+  if (version == null) throw new InternalError("Can't get Ethereum Provider version");
+  const metamaskPrefix = 'MetaMask/v';
+  if (!version.startsWith(metamaskPrefix)) {
+    throw new UnsupportedPlatformError(`Expected Metamask, got ${version} instead`);
+  }
+  const args = [version.slice(metamaskPrefix.length), '12.2.4'];
+  if (!semverSatisfies(...args)) throw new UnsupportedVersionError('Metamask', ...args);
+}
+async function _ensureReady() {
+  var _classPrivateFieldGet2;
+  (_classPrivateFieldGet2 = _classPrivateFieldGet(_ensureReadyPromise, this)) !== null && _classPrivateFieldGet2 !== void 0 ? _classPrivateFieldGet2 : _classPrivateFieldSet(_ensureReadyPromise, this, this.ensureReady());
+  return _classPrivateFieldGet(_ensureReadyPromise, this);
+}
+//# sourceMappingURL=MetamaskFactory.js.map

package/es/account/MetamaskFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetamaskFactory.js","names":["InternalError","UnsupportedPlatformError","UnsupportedVersionError","semverSatisfies","AccountBaseFactory","AccountMetamask","invokeSnap","snapId","snapMinVersion","snapMaxVersion","_AccountMetamaskFactory_brand","WeakSet","_ensureReadyPromise","WeakMap","AccountMetamaskFactory","constructor","provider","_classPrivateMethodInitSpec","_classPrivateFieldInitSpec","window","ethereum","installSnap","_assertClassBrand","_ensureMetamaskSupported","call","details","request","method","params","version","_classPrivateFieldSet","Promise","resolve","ensureReady","snapVersion","getSnapVersion","args","snaps","initialize","accountIndex","_ensureReady","address","derivationPath","metamaskPrefix","startsWith","slice","length","_classPrivateFieldGet2","_classPrivateFieldGet"],"sources":["../../src/account/MetamaskFactory.ts"],"sourcesContent":["import type { BaseProvider } from '@metamask/providers';\nimport {\n  InternalError,\n  UnsupportedPlatformError,\n  UnsupportedVersionError,\n} from '../utils/errors.js';\nimport { Encoded } from '../utils/encoder.js';\nimport semverSatisfies from '../utils/semver-satisfies.js';\nimport AccountBaseFactory from './BaseFactory.js';\nimport AccountMetamask, { invokeSnap, snapId } from './Metamask.js';\n\nconst snapMinVersion = '0.0.9';\nconst snapMaxVersion = '0.1.0';\n\ninterface SnapDetails {\n  blocked: boolean;\n  enabled: boolean;\n  id: typeof snapId;\n  version: string;\n  initialPermissions: Record<string, unknown>;\n}\n\n/**\n * A factory class that generates instances of AccountMetamask.\n */\nexport default class AccountMetamaskFactory extends AccountBaseFactory {\n  readonly provider: BaseProvider;\n\n  /**\n   * @param provider - Connection to MetaMask to use\n   */\n  constructor(provider?: BaseProvider) {\n    super();\n    if (provider != null) {\n      this.provider = provider;\n      return;\n    }\n    if (window == null) {\n      throw new UnsupportedPlatformError(\n        'Window object not found, you can run AccountMetamaskFactory only in browser or setup a provider',\n      );\n    }\n    if (!('ethereum' in window) || window.ethereum == null) {\n      throw new UnsupportedPlatformError(\n        '`ethereum` object not found, you can run AccountMetamaskFactory only with Metamask enabled or setup a provider',\n      );\n    }\n    this.provider = window.ethereum as BaseProvider;\n  }\n\n  /**\n   * It throws an exception if MetaMask has an incompatible version.\n   */\n  async #ensureMetamaskSupported(): Promise<void> {\n    const version = await this.provider.request<string>({ method: 'web3_clientVersion' });\n    if (version == null) throw new InternalError(\"Can't get Ethereum Provider version\");\n    const metamaskPrefix = 'MetaMask/v';\n    if (!version.startsWith(metamaskPrefix)) {\n      throw new UnsupportedPlatformError(`Expected Metamask, got ${version} instead`);\n    }\n    const args = [version.slice(metamaskPrefix.length), '12.2.4'] as const;\n    if (!semverSatisfies(...args)) throw new UnsupportedVersionError('Metamask', ...args);\n  }\n\n  #ensureReadyPromise?: Promise<void>;\n\n  /**\n   * Request MetaMask to install Aeternity snap.\n   */\n  async installSnap(): Promise<SnapDetails> {\n    await this.#ensureMetamaskSupported();\n    const details = (await this.provider.request({\n      method: 'wallet_requestSnaps',\n      params: { [snapId]: { version: snapMinVersion } },\n    })) as { [key in typeof snapId]: SnapDetails };\n    this.#ensureReadyPromise = Promise.resolve();\n    return details[snapId];\n  }\n\n  /**\n   * It throws an exception if MetaMask or Aeternity snap has an incompatible version or is not\n   * installed.\n   */\n  async ensureReady(): Promise<void> {\n    const snapVersion = await this.getSnapVersion();\n    const args = [snapVersion, snapMinVersion, snapMaxVersion] as const;\n    if (!semverSatisfies(...args))\n      throw new UnsupportedVersionError('Aeternity snap in MetaMask', ...args);\n    this.#ensureReadyPromise = Promise.resolve();\n  }\n\n  async #ensureReady(): Promise<void> {\n    this.#ensureReadyPromise ??= this.ensureReady();\n    return this.#ensureReadyPromise;\n  }\n\n  /**\n   * @returns the version of snap installed in MetaMask\n   */\n  async getSnapVersion(): Promise<string> {\n    await this.#ensureMetamaskSupported();\n    const snaps = (await this.provider.request({ method: 'wallet_getSnaps' })) as Record<\n      string,\n      { version: string }\n    >;\n    const version = snaps[snapId]?.version;\n    if (version == null)\n      throw new UnsupportedPlatformError('Aeternity snap is not installed to MetaMask');\n    return version;\n  }\n\n  /**\n   * Get an instance of AccountMetaMask for a given account index.\n   * @param accountIndex - Index of account\n   */\n  async initialize(accountIndex: number): Promise<AccountMetamask> {\n    await this.#ensureReady();\n    const address = await invokeSnap<Encoded.AccountAddress>(\n      this.provider,\n      'getPublicKey',\n      { derivationPath: [`${accountIndex}'`, \"0'\", \"0'\"] },\n      'publicKey',\n    );\n    return new AccountMetamask(this.provider, accountIndex, address);\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/es/account/MnemonicFactory.d.ts

@@ -0,0 +1,35 @@
+import AccountBaseFactory from './BaseFactory.js';
+import AccountMemory from './Memory.js';
+import { Encoded } from '../utils/encoder.js';
+export declare const ED25519_CURVE: Buffer;
+interface KeyTreeNode {
+    secretKey: Uint8Array;
+    chainCode: Uint8Array;
+}
+export declare function deriveKey(message: Uint8Array, key: Uint8Array): KeyTreeNode;
+export declare function derivePathFromKey(key: KeyTreeNode, segments: readonly number[]): KeyTreeNode;
+interface Wallet {
+    secretKey: Encoded.Bytearray;
+    chainCode: Encoded.Bytearray;
+}
+/**
+ * A factory class that generates instances of AccountMemory based on provided mnemonic phrase.
+ */
+export default class AccountMnemonicFactory extends AccountBaseFactory {
+    #private;
+    /**
+     * @param mnemonicOrWallet - BIP39-compatible mnemonic phrase or a wallet derived from mnemonic
+     */
+    constructor(mnemonicOrWallet: string | Wallet);
+    /**
+     * Get a wallet to initialize AccountMnemonicFactory instead mnemonic phrase.
+     * In comparison with mnemonic, the wallet can be used to derive aeternity accounts only.
+     */
+    getWallet(): Promise<Wallet>;
+    /**
+     * Get an instance of AccountMemory for a given account index.
+     * @param accountIndex - Index of account
+     */
+    initialize(accountIndex: number): Promise<AccountMemory>;
+}
+export {};

package/es/account/MnemonicFactory.js

@@ -0,0 +1,88 @@
+import { Buffer as _Buffer } from "buffer";
+function _classPrivateMethodInitSpec(e, a) { _checkPrivateRedeclaration(e, a), a.add(e); }
+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 _classPrivateFieldGet(s, a) { return s.get(_assertClassBrand(s, a)); }
+function _classPrivateFieldSet(s, a, r) { return s.set(_assertClassBrand(s, a), r), r; }
+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"); }
+import { mnemonicToSeed } from '@scure/bip39';
+import tweetnaclAuth from 'tweetnacl-auth';
+import AccountBaseFactory from './BaseFactory.js';
+import AccountMemory from './Memory.js';
+import { encode, Encoding, decode } from '../utils/encoder.js';
+import { concatBuffers } from '../utils/other.js';
+import { InternalError } from '../utils/errors.js';
+export const ED25519_CURVE = _Buffer.from('ed25519 seed');
+const HARDENED_OFFSET = 0x80000000;
+export function deriveKey(message, key) {
+  const I = tweetnaclAuth.full(message, key);
+  const IL = I.slice(0, 32);
+  const IR = I.slice(32);
+  return {
+    secretKey: IL,
+    chainCode: IR
+  };
+}
+export function derivePathFromKey(key, segments) {
+  return segments.reduce(({
+    secretKey,
+    chainCode
+  }, segment) => {
+    const indexBuffer = _Buffer.allocUnsafe(4);
+    indexBuffer.writeUInt32BE(segment + HARDENED_OFFSET, 0);
+    const data = concatBuffers([_Buffer.alloc(1, 0), secretKey, indexBuffer]);
+    return deriveKey(data, chainCode);
+  }, key);
+}
+var _mnemonic = /*#__PURE__*/new WeakMap();
+var _wallet = /*#__PURE__*/new WeakMap();
+var _AccountMnemonicFactory_brand = /*#__PURE__*/new WeakSet();
+/**
+ * A factory class that generates instances of AccountMemory based on provided mnemonic phrase.
+ */
+export default class AccountMnemonicFactory extends AccountBaseFactory {
+  /**
+   * @param mnemonicOrWallet - BIP39-compatible mnemonic phrase or a wallet derived from mnemonic
+   */
+  constructor(mnemonicOrWallet) {
+    super();
+    _classPrivateMethodInitSpec(this, _AccountMnemonicFactory_brand);
+    _classPrivateFieldInitSpec(this, _mnemonic, void 0);
+    _classPrivateFieldInitSpec(this, _wallet, void 0);
+    if (typeof mnemonicOrWallet === 'string') _classPrivateFieldSet(_mnemonic, this, mnemonicOrWallet);else _classPrivateFieldSet(_wallet, this, mnemonicOrWallet);
+  }
+
+  /**
+   * Get a wallet to initialize AccountMnemonicFactory instead mnemonic phrase.
+   * In comparison with mnemonic, the wallet can be used to derive aeternity accounts only.
+   */
+  async getWallet() {
+    if (_classPrivateFieldGet(_wallet, this) != null) return _classPrivateFieldGet(_wallet, this);
+    if (_classPrivateFieldGet(_mnemonic, this) == null) throw new InternalError('AccountMnemonicFactory should be initialized with mnemonic or wallet');
+    const seed = await mnemonicToSeed(_classPrivateFieldGet(_mnemonic, this));
+    const masterKey = deriveKey(seed, ED25519_CURVE);
+    const walletKey = derivePathFromKey(masterKey, [44, 457]);
+    _classPrivateFieldSet(_wallet, this, {
+      secretKey: encode(walletKey.secretKey, Encoding.Bytearray),
+      chainCode: encode(walletKey.chainCode, Encoding.Bytearray)
+    });
+    return _classPrivateFieldGet(_wallet, this);
+  }
+  /**
+   * Get an instance of AccountMemory for a given account index.
+   * @param accountIndex - Index of account
+   */
+  async initialize(accountIndex) {
+    return new AccountMemory(await _assertClassBrand(_AccountMnemonicFactory_brand, this, _getAccountSecretKey).call(this, accountIndex));
+  }
+}
+async function _getAccountSecretKey(accountIndex) {
+  const wallet = await this.getWallet();
+  const walletKey = {
+    secretKey: decode(wallet.secretKey),
+    chainCode: decode(wallet.chainCode)
+  };
+  const raw = derivePathFromKey(walletKey, [accountIndex, 0, 0]).secretKey;
+  return encode(raw, Encoding.AccountSecretKey);
+}
+//# sourceMappingURL=MnemonicFactory.js.map

package/es/account/MnemonicFactory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MnemonicFactory.js","names":["mnemonicToSeed","tweetnaclAuth","AccountBaseFactory","AccountMemory","encode","Encoding","decode","concatBuffers","InternalError","ED25519_CURVE","_Buffer","from","HARDENED_OFFSET","deriveKey","message","key","I","full","IL","slice","IR","secretKey","chainCode","derivePathFromKey","segments","reduce","segment","indexBuffer","allocUnsafe","writeUInt32BE","data","alloc","_mnemonic","WeakMap","_wallet","_AccountMnemonicFactory_brand","WeakSet","AccountMnemonicFactory","constructor","mnemonicOrWallet","_classPrivateMethodInitSpec","_classPrivateFieldInitSpec","_classPrivateFieldSet","getWallet","_classPrivateFieldGet","seed","masterKey","walletKey","Bytearray","initialize","accountIndex","_assertClassBrand","_getAccountSecretKey","call","wallet","raw","AccountSecretKey"],"sources":["../../src/account/MnemonicFactory.ts"],"sourcesContent":["import { mnemonicToSeed } from '@scure/bip39';\nimport tweetnaclAuth from 'tweetnacl-auth';\nimport AccountBaseFactory from './BaseFactory.js';\nimport AccountMemory from './Memory.js';\nimport { encode, Encoding, Encoded, decode } from '../utils/encoder.js';\nimport { concatBuffers } from '../utils/other.js';\nimport { InternalError } from '../utils/errors.js';\n\nexport const ED25519_CURVE = Buffer.from('ed25519 seed');\nconst HARDENED_OFFSET = 0x80000000;\n\ninterface KeyTreeNode {\n  secretKey: Uint8Array;\n  chainCode: Uint8Array;\n}\n\nexport function deriveKey(message: Uint8Array, key: Uint8Array): KeyTreeNode {\n  const I = tweetnaclAuth.full(message, key);\n  const IL = I.slice(0, 32);\n  const IR = I.slice(32);\n  return {\n    secretKey: IL,\n    chainCode: IR,\n  };\n}\n\nexport function derivePathFromKey(key: KeyTreeNode, segments: readonly number[]): KeyTreeNode {\n  return segments.reduce(({ secretKey, chainCode }, segment) => {\n    const indexBuffer = Buffer.allocUnsafe(4);\n    indexBuffer.writeUInt32BE(segment + HARDENED_OFFSET, 0);\n    const data = concatBuffers([Buffer.alloc(1, 0), secretKey, indexBuffer]);\n    return deriveKey(data, chainCode);\n  }, key);\n}\n\ninterface Wallet {\n  secretKey: Encoded.Bytearray;\n  chainCode: Encoded.Bytearray;\n}\n\n/**\n * A factory class that generates instances of AccountMemory based on provided mnemonic phrase.\n */\nexport default class AccountMnemonicFactory extends AccountBaseFactory {\n  readonly #mnemonic: string | undefined;\n\n  #wallet: Wallet | undefined;\n\n  /**\n   * @param mnemonicOrWallet - BIP39-compatible mnemonic phrase or a wallet derived from mnemonic\n   */\n  constructor(mnemonicOrWallet: string | Wallet) {\n    super();\n    if (typeof mnemonicOrWallet === 'string') this.#mnemonic = mnemonicOrWallet;\n    else this.#wallet = mnemonicOrWallet;\n  }\n\n  /**\n   * Get a wallet to initialize AccountMnemonicFactory instead mnemonic phrase.\n   * In comparison with mnemonic, the wallet can be used to derive aeternity accounts only.\n   */\n  async getWallet(): Promise<Wallet> {\n    if (this.#wallet != null) return this.#wallet;\n    if (this.#mnemonic == null)\n      throw new InternalError(\n        'AccountMnemonicFactory should be initialized with mnemonic or wallet',\n      );\n    const seed = await mnemonicToSeed(this.#mnemonic);\n    const masterKey = deriveKey(seed, ED25519_CURVE);\n    const walletKey = derivePathFromKey(masterKey, [44, 457]);\n    this.#wallet = {\n      secretKey: encode(walletKey.secretKey, Encoding.Bytearray),\n      chainCode: encode(walletKey.chainCode, Encoding.Bytearray),\n    };\n    return this.#wallet;\n  }\n\n  async #getAccountSecretKey(accountIndex: number): Promise<Encoded.AccountSecretKey> {\n    const wallet = await this.getWallet();\n    const walletKey = {\n      secretKey: decode(wallet.secretKey),\n      chainCode: decode(wallet.chainCode),\n    };\n    const raw = derivePathFromKey(walletKey, [accountIndex, 0, 0]).secretKey;\n    return encode(raw, Encoding.AccountSecretKey);\n  }\n\n  /**\n   * Get an instance of AccountMemory for a given account index.\n   * @param accountIndex - Index of account\n   */\n  async initialize(accountIndex: number): Promise<AccountMemory> {\n    return new AccountMemory(await this.#getAccountSecretKey(accountIndex));\n  }\n}\n"],"mappings":"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","ignoreList":[]}

package/es/account/Rpc.d.ts

@@ -1,8 +1,7 @@
-import AccountBase from './Base';
-import { Encoded } from '../utils/encoder';
-import RpcClient from '../aepp-wallet-communication/rpc/RpcClient';
-import { AeppApi, WalletApi } from '../aepp-wallet-communication/rpc/types';
-import { AensName, ConsensusProtocolVersion } from '../tx/builder/constants';
+import AccountBase from './Base.js';
+import { Encoded } from '../utils/encoder.js';
+import RpcClient from '../aepp-wallet-communication/rpc/RpcClient.js';
+import { AeppApi, WalletApi } from '../aepp-wallet-communication/rpc/types.js';
 /**
  * Account provided by wallet
  * @param params - Params
@@ -17,19 +16,6 @@ export default class AccountRpc extends AccountBase {
     sign(dataRaw: string | Uint8Array): Promise<Uint8Array>;
     signTransaction(tx: Encoded.Transaction, { innerTx, networkId }?: Parameters<AccountBase['signTransaction']>[1]): Promise<Encoded.Transaction>;
     signMessage(message: string): Promise<Uint8Array>;
-    signTypedData(data: Encoded.ContractBytearray, aci: Parameters<AccountBase['signTypedData']>[1], { name, version, contractAddress, networkId, }?: Parameters<AccountBase['signTypedData']>[2]): Promise<Encoded.Signature>;
-    signDelegationToContract(contractAddress: Encoded.ContractAddress, { consensusProtocolVersion, isOracle }?: {
-        consensusProtocolVersion?: ConsensusProtocolVersion;
-        isOracle?: boolean;
-    }): Promise<Encoded.Signature>;
-    signNameDelegationToContract(contractAddress: Encoded.ContractAddress, name: AensName, { consensusProtocolVersion }?: {
-        consensusProtocolVersion?: ConsensusProtocolVersion;
-    }): Promise<Encoded.Signature>;
-    signAllNamesDelegationToContract(contractAddress: Encoded.ContractAddress, { consensusProtocolVersion }?: {
-        consensusProtocolVersion?: ConsensusProtocolVersion;
-    }): Promise<Encoded.Signature>;
-    signOracleQueryDelegationToContract(contractAddress: Encoded.ContractAddress, oracleQueryId: Encoded.OracleQueryId, { consensusProtocolVersion }?: {
-        consensusProtocolVersion?: ConsensusProtocolVersion;
-    }): Promise<Encoded.Signature>;
+    signTypedData(data: Encoded.ContractBytearray, aci: Parameters<AccountBase['signTypedData']>[1], { name, version, contractAddress, networkId }?: Parameters<AccountBase['signTypedData']>[2]): Promise<Encoded.Signature>;
     signDelegation(delegation: Encoded.Bytearray): Promise<Encoded.Signature>;
 }