@aeternity/aepp-sdk 13.3.3 → 14.1.0

package/src/AeSdkBase.ts

@@ -1,315 +0,0 @@
-import Node from './Node';
-import AccountBase from './account/Base';
-import {
-  CompilerError, DuplicateNodeError, NodeNotFoundError, NotImplementedError, TypeError,
-} from './utils/errors';
-import { Encoded } from './utils/encoder';
-import { wrapWithProxy } from './utils/wrap-proxy';
-import CompilerBase from './contract/compiler/Base';
-import AeSdkMethods, { OnAccount, AeSdkMethodsOptions, WrappedOptions } from './AeSdkMethods';
-import { AensName } from './tx/builder/constants';
-
-type NodeInfo = Awaited<ReturnType<Node['getNodeInfo']>> & { name: string };
-
-/**
- * Basic AeSdk class implements:
- * - node selector,
- * - integrated compiler support,
- * - wrappers of account methods mapped to the current account.
- */
-export default class AeSdkBase extends AeSdkMethods {
-  pool: Map<string, Node> = new Map();
-
-  selectedNodeName?: string;
-
-  readonly #wrappedOptions: WrappedOptions;
-
-  /**
-   * @param options - Options
-   * @param options.nodes - Array of nodes
-   */
-  constructor(
-    { nodes = [], ...options }: AeSdkMethodsOptions & {
-      nodes?: Array<{ name: string; instance: Node }>;
-    } = {},
-  ) {
-    super(options);
-
-    nodes.forEach(({ name, instance }, i) => this.addNode(name, instance, i === 0));
-
-    this.#wrappedOptions = {
-      onNode: wrapWithProxy(() => this.api),
-      onCompiler: wrapWithProxy(() => this.compilerApi),
-      onAccount: wrapWithProxy(() => this._resolveAccount()),
-    };
-  }
-
-  // TODO: consider dropping this getter, because:
-  // compiler is not intended to be used separately any more (functionality limited to sdk needs)
-  // and user creates its instance by himself
-  get compilerApi(): CompilerBase {
-    if (this._options.onCompiler == null) {
-      throw new CompilerError('You can\'t use Compiler API. Compiler is not ready!');
-    }
-    return this._options.onCompiler;
-  }
-
-  get api(): Node {
-    this.ensureNodeConnected();
-    return this.pool.get(this.selectedNodeName) as Node;
-  }
-
-  /**
-   * Add Node
-   * @param name - Node name
-   * @param node - Node instance
-   * @param select - Select this node as current
-   * @example
-   * ```js
-   * // add and select new node with name 'testNode'
-   * aeSdkBase.addNode('testNode', new Node({ url }), true)
-   * ```
-   */
-  addNode(name: string, node: Node, select = false): void {
-    if (this.pool.has(name)) throw new DuplicateNodeError(name);
-
-    this.pool.set(name, node);
-    if (select || this.selectedNodeName == null) {
-      this.selectNode(name);
-    }
-  }
-
-  /**
-   * Select Node
-   * @param name - Node name
-   * @example
-   * nodePool.selectNode('testNode')
-   */
-  selectNode(name: string): void {
-    if (!this.pool.has(name)) throw new NodeNotFoundError(`Node with name ${name} not in pool`);
-    this.selectedNodeName = name;
-  }
-
-  /**
-   * Check if you have selected node
-   * @example
-   * nodePool.isNodeConnected()
-   */
-  isNodeConnected(): this is AeSdkBase & { selectedNodeName: string } {
-    return this.selectedNodeName != null;
-  }
-
-  protected ensureNodeConnected(): asserts this is AeSdkBase & { selectedNodeName: string } {
-    if (!this.isNodeConnected()) {
-      throw new NodeNotFoundError('You can\'t use Node API. Node is not connected or not defined!');
-    }
-  }
-
-  /**
-   * Get information about node
-   * @example
-   * ```js
-   * nodePool.getNodeInfo() // { name, version, networkId, protocol, ... }
-   * ```
-   */
-  async getNodeInfo(): Promise<NodeInfo> {
-    this.ensureNodeConnected();
-    return {
-      name: this.selectedNodeName,
-      ...await this.api.getNodeInfo(),
-    };
-  }
-
-  /**
-   * Get array of available nodes
-   * @example
-   * nodePool.getNodesInPool()
-   */
-  async getNodesInPool(): Promise<NodeInfo[]> {
-    return Promise.all(
-      Array.from(this.pool.entries()).map(async ([name, node]) => ({
-        name,
-        ...await node.getNodeInfo(),
-      })),
-    );
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  addresses(): Encoded.AccountAddress[] {
-    return [];
-  }
-
-  /**
-   * Resolves an account
-   * @param account - ak-address, instance of AccountBase, or keypair
-   */
-  _resolveAccount(account: OnAccount = this._options.onAccount): AccountBase {
-    if (typeof account === 'string') throw new NotImplementedError('Address in AccountResolver');
-    if (typeof account === 'object') return account;
-    throw new TypeError(
-      'Account should be an address (ak-prefixed string), '
-      + `or instance of AccountBase, got ${String(account)} instead`,
-    );
-  }
-
-  get address(): Encoded.AccountAddress {
-    return this._resolveAccount().address;
-  }
-
-  /**
-   * Sign data blob
-   * @param data - Data to sign
-   * @param options - Options
-   */
-  async sign(
-    data: string | Uint8Array,
-    { onAccount, ...options }: { onAccount?: OnAccount } = {},
-  ): Promise<Uint8Array> {
-    return this._resolveAccount(onAccount).sign(data, options);
-  }
-
-  /**
-   * Sign encoded transaction
-   * @param tx - Transaction to sign
-   * @param options - Options
-   */
-  async signTransaction(
-    tx: Encoded.Transaction,
-    { onAccount, ...options }: { onAccount?: OnAccount } & Parameters<AccountBase['signTransaction']>[1] = {},
-  ): Promise<Encoded.Transaction> {
-    const networkId = this.selectedNodeName !== null ? await this.api.getNetworkId() : undefined;
-    return this._resolveAccount(onAccount).signTransaction(tx, { networkId, ...options });
-  }
-
-  /**
-   * Sign message
-   * @param message - Message to sign
-   * @param options - Options
-   */
-  async signMessage(
-    message: string,
-    { onAccount, ...options }: { onAccount?: OnAccount } & Parameters<AccountBase['signMessage']>[1] = {},
-  ): Promise<Uint8Array> {
-    return this._resolveAccount(onAccount).signMessage(message, options);
-  }
-
-  /**
-   * Sign typed data
-   * @param data - Encoded data to sign
-   * @param aci - Type of data to sign
-   * @param options - Options
-   */
-  async signTypedData(
-    data: Encoded.ContractBytearray,
-    aci: Parameters<AccountBase['signTypedData']>[1],
-    { onAccount, ...options }: { onAccount?: OnAccount } & Parameters<AccountBase['signTypedData']>[2] = {},
-  ): Promise<Encoded.Signature> {
-    return this._resolveAccount(onAccount).signTypedData(data, aci, options);
-  }
-
-  /**
-   * @deprecated use AeSdkBase:signDelegation in Ceres
-   * @param contractAddress - Contract address
-   * @param options - Options
-   */
-  async signDelegationToContract(
-    contractAddress: Encoded.ContractAddress,
-    { onAccount, ...options }: { onAccount?: OnAccount }
-    & Parameters<AccountBase['signDelegationToContract']>[1] = {},
-  ): Promise<Encoded.Signature> {
-    options.networkId ??= this.selectedNodeName !== null
-      ? await this.api.getNetworkId() : undefined;
-    options.consensusProtocolVersion ??= this.selectedNodeName !== null
-      ? (await this.api.getNodeInfo()).consensusProtocolVersion : undefined;
-    return this._resolveAccount(onAccount)
-      .signDelegationToContract(contractAddress, options);
-  }
-
-  /**
-   * @deprecated use AeSdkBase:signDelegation in Ceres
-   * @param contractAddress - Contract address
-   * @param name - AENS name
-   * @param options - Options
-   */
-  async signNameDelegationToContract(
-    contractAddress: Encoded.ContractAddress,
-    name: AensName,
-    { onAccount, ...options }: { onAccount?: OnAccount }
-    & Parameters<AccountBase['signNameDelegationToContract']>[2] = {},
-  ): Promise<Encoded.Signature> {
-    options.networkId ??= this.selectedNodeName !== null
-      ? await this.api.getNetworkId() : undefined;
-    options.consensusProtocolVersion ??= this.selectedNodeName !== null
-      ? (await this.api.getNodeInfo()).consensusProtocolVersion : undefined;
-    return this._resolveAccount(onAccount)
-      .signNameDelegationToContract(contractAddress, name, options);
-  }
-
-  /**
-   * @deprecated use AeSdkBase:signDelegation in Ceres
-   * @param contractAddress - Contract address
-   * @param options - Options
-   */
-  async signAllNamesDelegationToContract(
-    contractAddress: Encoded.ContractAddress,
-    { onAccount, ...options }: { onAccount?: OnAccount }
-    & Parameters<AccountBase['signAllNamesDelegationToContract']>[1] = {},
-  ): Promise<Encoded.Signature> {
-    options.networkId ??= this.selectedNodeName !== null
-      ? await this.api.getNetworkId() : undefined;
-    options.consensusProtocolVersion ??= this.selectedNodeName !== null
-      ? (await this.api.getNodeInfo()).consensusProtocolVersion : undefined;
-    return this._resolveAccount(onAccount)
-      .signAllNamesDelegationToContract(contractAddress, options);
-  }
-
-  /**
-   * @deprecated use AeSdkBase:signDelegation in Ceres
-   * @param contractAddress - Contract address
-   * @param oracleQueryId - Oracle query id
-   * @param options - Options
-   */
-  async signOracleQueryDelegationToContract(
-    contractAddress: Encoded.ContractAddress,
-    oracleQueryId: Encoded.OracleQueryId,
-    { onAccount, ...options }: { onAccount?: OnAccount }
-    & Parameters<AccountBase['signOracleQueryDelegationToContract']>[2] = {},
-  ): Promise<Encoded.Signature> {
-    options.networkId ??= this.selectedNodeName !== null
-      ? await this.api.getNetworkId() : undefined;
-    options.consensusProtocolVersion ??= this.selectedNodeName !== null
-      ? (await this.api.getNodeInfo()).consensusProtocolVersion : undefined;
-    return this._resolveAccount(onAccount)
-      .signOracleQueryDelegationToContract(contractAddress, oracleQueryId, options);
-  }
-
-  /**
-   * Sign delegation, works only in Ceres
-   * @param delegation - Delegation to sign
-   * @param options - Options
-   */
-  async signDelegation(
-    delegation: Encoded.Bytearray,
-    { onAccount, ...options }: { onAccount?: OnAccount }
-    & Parameters<AccountBase['signDelegation']>[1] = {},
-  ): Promise<Encoded.Signature> {
-    options.networkId ??= this.selectedNodeName !== null
-      ? await this.api.getNetworkId() : undefined;
-    return this._resolveAccount(onAccount).signDelegation(delegation, options);
-  }
-
-  /**
-   * The same as AeSdkMethods:getContext, but it would resolve ak_-prefixed address in
-   * `mergeWith.onAccount` to AccountBase.
-   */
-  override getContext(mergeWith: AeSdkMethodsOptions = {}): AeSdkMethodsOptions & WrappedOptions {
-    return {
-      ...this._options,
-      ...this.#wrappedOptions,
-      ...mergeWith,
-      ...mergeWith.onAccount != null && {
-        onAccount: this._resolveAccount(mergeWith.onAccount),
-      },
-    };
-  }
-}

package/src/AeSdkMethods.ts

@@ -1,149 +0,0 @@
-import * as chainMethods from './chain';
-import { sendTransaction } from './send-transaction';
-import * as aensMethods from './aens';
-import * as spendMethods from './spend';
-import * as oracleMethods from './oracle';
-import Contract, { ContractMethodsBase } from './contract/Contract';
-import createDelegationSignature from './contract/delegation-signature';
-import * as contractGaMethods from './contract/ga';
-import { buildTxAsync } from './tx/builder';
-import { mapObject, UnionToIntersection } from './utils/other';
-import { wrapWithProxy } from './utils/wrap-proxy';
-import Node from './Node';
-import { TxParamsAsync } from './tx/builder/schema.generated';
-import AccountBase from './account/Base';
-import { Encoded } from './utils/encoder';
-import CompilerBase from './contract/compiler/Base';
-
-export type OnAccount = Encoded.AccountAddress | AccountBase | undefined;
-
-const methods = {
-  ...chainMethods,
-  sendTransaction,
-  ...aensMethods,
-  ...spendMethods,
-  ...oracleMethods,
-  createDelegationSignature,
-  ...contractGaMethods,
-} as const;
-
-type Decrement<Number extends number> = [-1, 0, 1, 2, 3, 4, 5][Number];
-type GetMethodsOptions <Methods extends { [key: string]: Function }> =
-  {
-    [Name in keyof Methods]:
-    Methods[Name] extends (...args: infer Args) => any
-      ? Args[Decrement<Args['length']>] : never
-  };
-type MethodsOptions = GetMethodsOptions<typeof methods>;
-export interface AeSdkMethodsOptions
-  extends Partial<UnionToIntersection<MethodsOptions[keyof MethodsOptions]>> {
-}
-
-export interface WrappedOptions {
-  onAccount: AccountBase;
-  onCompiler: CompilerBase;
-  onNode: Node;
-}
-
-/**
- * AeSdkMethods is the composition of:
- * - chain methods
- * - tx methods
- * - aens methods
- * - spend methods
- * - oracle methods
- * - contract methods
- * - contract ga methods
- *
- * While these methods can be used separately, this class provides a handy way to store
- * their context (current account, network, and compiler to use).
- */
-class AeSdkMethods {
-  _options: AeSdkMethodsOptions = {};
-
-  readonly #wrappedOptions: WrappedOptions;
-
-  /**
-   * @param options - Options
-   */
-  constructor(options: AeSdkMethodsOptions = {}) {
-    Object.assign(this._options, options);
-    this.#wrappedOptions = {
-      onAccount: wrapWithProxy(() => this._options.onAccount),
-      onNode: wrapWithProxy(() => this._options.onNode),
-      onCompiler: wrapWithProxy(() => this._options.onCompiler),
-    };
-  }
-
-  /**
-   * Returns sdk instance options with references to current account, node, compiler.
-   * Used to create an instance (Contract, Oracle) bound to AeSdk state.
-   * @param mergeWith - Merge context with these extra options
-   * @returns Context object
-   */
-  getContext(mergeWith: AeSdkMethodsOptions = {}): AeSdkMethodsOptions & WrappedOptions {
-    return {
-      ...this._options,
-      ...this.#wrappedOptions,
-      ...mergeWith,
-    };
-  }
-
-  // TODO: omit onNode from options, because it is already in context
-  async buildTx(options: TxParamsAsync): Promise<Encoded.Transaction> {
-    return buildTxAsync({ ...this.getContext(), ...options });
-  }
-
-  async initializeContract<Methods extends ContractMethodsBase>(
-    options?: Omit<Parameters<typeof Contract.initialize>[0], 'onNode'> & { onNode?: Node },
-  ): Promise<Contract<Methods>> {
-    return Contract.initialize<Methods>(this.getContext(options as AeSdkMethodsOptions));
-  }
-}
-
-type RequiredKeys<T> = {
-  [K in keyof T]-?: {} extends Pick<T, K> ? never : K
-}[keyof T];
-
-type OptionalIfNotRequired<T extends [any]> = RequiredKeys<T[0]> extends never ? T | [] : T;
-
-type ReplaceOnAccount<Options> = Options extends { onAccount: any }
-  ? Omit<Options, 'onAccount'> & {
-    /**
-     * Make operation on specific account by providing address (to use account from sdk) or instance
-     * of AccountBase (like MemoryAccount)
-     */
-    onAccount: OnAccount;
-  } : Options;
-
-type MakeOptional<Options> = OptionalIfNotRequired<[
-  Omit<Options, 'onNode' | 'onCompiler' | 'onAccount'> & Partial<ReplaceOnAccount<Options>>,
-]>;
-
-type TransformMethods <Methods extends { [key: string]: Function }> =
-  {
-    [Name in keyof Methods]:
-    Methods[Name] extends (...args: [...infer Args, infer Options]) => infer Ret
-      ? (...args: [...Args, ...MakeOptional<Options>]) => Ret
-      : never
-  };
-
-interface AeSdkMethodsTransformed extends TransformMethods<typeof methods> {}
-
-Object.assign(AeSdkMethods.prototype, mapObject<Function, Function>(
-  methods,
-  ([name, handler]) => [
-    name,
-    function methodWrapper(this: AeSdkMethods, ...args: any[]) {
-      args.length = handler.length;
-      const options = args[args.length - 1];
-      args[args.length - 1] = this.getContext(options);
-      return handler(...args);
-    },
-  ],
-));
-
-type AeSdkMethodsTyped = AeSdkMethods & AeSdkMethodsTransformed;
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-const AeSdkMethodsTyped = AeSdkMethods as new (options?: AeSdkMethodsOptions) => AeSdkMethodsTyped;
-export default AeSdkMethodsTyped;