@aeternity/aepp-sdk 13.3.2 → 14.0.0

package/src/send-transaction.ts

@@ -1,136 +0,0 @@
-import verifyTransaction, { ValidatorResult } from './tx/validator';
-import { ensureError } from './utils/other';
-import { TransactionError } from './utils/errors';
-import Node, { TransformNodeType } from './Node';
-import { SignedTx } from './apis/node';
-import { Encoded } from './utils/encoder';
-import AccountBase from './account/Base';
-import { buildTxHash } from './tx/builder';
-import { poll, waitForTxConfirm } from './chain';
-
-/**
- * @category exception
- */
-export class InvalidTxError extends TransactionError {
-  validation: ValidatorResult[];
-
-  transaction: Encoded.Transaction;
-
-  constructor(
-    message: string,
-    validation: ValidatorResult[],
-    transaction: Encoded.Transaction,
-  ) {
-    super(message);
-    this.name = 'InvalidTxError';
-    this.validation = validation;
-    this.transaction = transaction;
-  }
-}
-
-/**
- * Signs and submits transaction for mining
- * @category chain
- * @param txUnsigned - Transaction to sign and submit
- * @param options - Options
- * @returns Transaction details
- */
-export async function sendTransaction(
-  txUnsigned: Encoded.Transaction,
-  {
-    onNode, onAccount, verify = true, waitMined = true, confirm, innerTx, ...options
-  }:
-  SendTransactionOptions,
-): Promise<SendTransactionReturnType> {
-  const tx = await onAccount.signTransaction(txUnsigned, {
-    ...options,
-    onNode,
-    innerTx,
-    networkId: await onNode.getNetworkId(),
-  });
-
-  if (innerTx === true) return { hash: buildTxHash(tx), rawTx: tx };
-
-  if (verify) {
-    const validation = await verifyTransaction(tx, onNode);
-    if (validation.length > 0) {
-      const message = `Transaction verification errors: ${
-        validation.map((v: { message: string }) => v.message).join(', ')}`;
-      throw new InvalidTxError(message, validation, tx);
-    }
-  }
-
-  try {
-    let __queue;
-    try {
-      __queue = onAccount != null ? `tx-${onAccount.address}` : null;
-    } catch (error) {
-      __queue = null;
-    }
-    const { txHash } = await onNode.postTransaction({ tx }, {
-      requestOptions: {
-        customHeaders: {
-          // TODO: remove __retry-code after fixing https://github.com/aeternity/aeternity/issues/3803
-          '__retry-code': '400',
-          ...__queue != null ? { __queue } : {},
-        },
-      },
-    });
-
-    if (waitMined) {
-      const pollResult = await poll(txHash, { onNode, ...options });
-      const txData = {
-        ...pollResult,
-        hash: pollResult.hash as Encoded.TxHash,
-        rawTx: tx,
-      };
-      // wait for transaction confirmation
-      if (confirm != null && +confirm > 0) {
-        const c = typeof confirm === 'boolean' ? undefined : confirm;
-        return {
-          ...txData,
-          confirmationHeight: await waitForTxConfirm(txHash, { onNode, confirm: c, ...options }),
-        };
-      }
-      return txData;
-    }
-    return { hash: txHash, rawTx: tx };
-  } catch (error) {
-    ensureError(error);
-    throw Object.assign(error, {
-      rawTx: tx,
-      verifyTx: async () => verifyTransaction(tx, onNode),
-    });
-  }
-}
-
-type SendTransactionOptionsType = {
-  /**
-   * Node to use
-   */
-  onNode: Node;
-  /**
-   * Account to use
-   */
-  onAccount: AccountBase;
-  /**
-   * Verify transaction before broadcast, throw error if not
-   */
-  verify?: boolean;
-  /**
-   * Ensure that transaction get into block
-   */
-  waitMined?: boolean;
-  /**
-   * Number of micro blocks that should be mined after tx get included
-   */
-  confirm?: boolean | number;
-} & Parameters<typeof poll>[1] & Omit<Parameters<typeof waitForTxConfirm>[1], 'confirm'>
-& Parameters<AccountBase['signTransaction']>[1];
-export interface SendTransactionOptions extends SendTransactionOptionsType {}
-interface SendTransactionReturnType extends Partial<TransformNodeType<SignedTx>> {
-  hash: Encoded.TxHash;
-  // TODO: use `SignedTx.encodedTx` instead
-  rawTx: Encoded.Transaction;
-  confirmationHeight?: number;
-}

package/src/spend.ts

@@ -1,136 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { getBalance, resolveName } from './chain';
-import { sendTransaction, SendTransactionOptions } from './send-transaction';
-import { buildTxAsync, BuildTxOptions, unpackTx } from './tx/builder';
-import { ArgumentError } from './utils/errors';
-import { Encoded } from './utils/encoder';
-import { Tag, AensName } from './tx/builder/constants';
-import AccountBase from './account/Base';
-
-/**
- * Send coins to another account
- * @category chain
- * @param amount - Amount to spend
- * @param recipientIdOrName - Address or name of recipient account
- * @param options - Options
- * @returns Transaction
- */
-export async function spend(
-  amount: number | string,
-  recipientIdOrName: Encoded.AccountAddress | Encoded.ContractAddress | AensName,
-  options: SpendOptions,
-): ReturnType<typeof sendTransaction> {
-  return sendTransaction(
-    await buildTxAsync({
-      _isInternalBuild: true,
-      ...options,
-      tag: Tag.SpendTx,
-      senderId: options.onAccount.address,
-      recipientId: await resolveName(
-        recipientIdOrName,
-        'account_pubkey',
-        options,
-      ),
-      amount,
-    }),
-    options,
-  );
-}
-
-type SpendOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'>
-& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendTransactionOptions;
-interface SpendOptions extends SpendOptionsType {}
-
-// TODO: Rename to spendFraction
-/**
- * Spend a fraction of coin balance to another account. Useful if needed to drain account balance
- * completely, sending funds to another account (with fraction set to 1).
- * @category chain
- * @param fraction - Fraction of balance to spend (between 0 and 1)
- * @param recipientIdOrName - Address or name of recipient account
- * @param options - Options
- * @example
- * ```js
- * // `fraction` * 100 = % of AE to be transferred (e.g. `0.42` for 42% or `1` for 100%)
- * const { blockHeight } = await aeSdk.transferFunds(
- *   0.42,
- *   'ak_21A27UVVt3hDkBE5J7rhhqnH5YNb4Y1dqo4PnSybrH85pnWo7E',
- * );
- * console.log('Transaction mined at', blockHeight);
- * ```
- */
-export async function transferFunds(
-  fraction: number | string, // TODO: accept only number
-  recipientIdOrName: AensName | Encoded.AccountAddress | Encoded.ContractAddress,
-  options: TransferFundsOptions,
-): ReturnType<typeof sendTransaction> {
-  if (+fraction < 0 || +fraction > 1) {
-    throw new ArgumentError('fraction', 'a number between 0 and 1', fraction);
-  }
-  const recipientId = await resolveName(
-    recipientIdOrName,
-    'account_pubkey',
-    options,
-  );
-  const senderId = options.onAccount.address;
-  const balance = new BigNumber(
-    await getBalance.bind(options.onAccount)(senderId, options),
-  );
-  const desiredAmount = balance.times(fraction).integerValue(BigNumber.ROUND_HALF_UP);
-  const { fee } = unpackTx(
-    await buildTxAsync({
-      _isInternalBuild: true,
-      ...options,
-      tag: Tag.SpendTx,
-      senderId,
-      recipientId,
-      amount: desiredAmount,
-    }),
-    Tag.SpendTx,
-  );
-  // Reducing of the amount may reduce transaction fee, so this is not completely accurate
-  const amount = desiredAmount.plus(fee).gt(balance) ? balance.minus(fee) : desiredAmount;
-  return sendTransaction(
-    await buildTxAsync({
-      _isInternalBuild: true,
-      ...options,
-      tag: Tag.SpendTx,
-      senderId,
-      recipientId,
-      amount,
-    }),
-    options,
-  );
-}
-
-type TransferFundsOptionsType = BuildTxOptions<Tag.SpendTx, 'senderId' | 'recipientId' | 'amount'>
-& Parameters<typeof resolveName>[2] & { onAccount: AccountBase } & SendTransactionOptions;
-interface TransferFundsOptions extends TransferFundsOptionsType {}
-
-/**
- * Submit transaction of another account paying for it (fee and gas)
- * @category chain
- * @param transaction - tx_<base64>-encoded transaction
- * @param options - Options
- * @returns Object Transaction
- */
-export async function payForTransaction(
-  transaction: Encoded.Transaction,
-  options: PayForTransactionOptions,
-): ReturnType<typeof sendTransaction> {
-  return sendTransaction(
-    await buildTxAsync({
-      _isInternalBuild: true,
-      ...options,
-      tag: Tag.PayingForTx,
-      payerId: options.onAccount.address,
-      tx: transaction,
-    }),
-    options,
-  );
-}
-
-interface PayForTransactionOptions extends
-  BuildTxOptions<Tag.PayingForTx, 'payerId' | 'tx' | 'onNode'>, SendTransactionOptions {
-  onAccount: AccountBase;
-}

package/src/tx/builder/SchemaTypes.ts

@@ -1,79 +0,0 @@
-import { Field as OriginalField } from './field-types';
-import { UnionToIntersection } from '../../utils/other';
-
-// TODO: figure out why this override is necessary
-export interface Field extends OriginalField {
-  serialize: (...args: any[]) => any;
-}
-
-type NullablePartial<
-  T,
-  NK extends keyof T = { [K in keyof T]: undefined extends T[K] ? K : never }[keyof T],
-> = Partial<Pick<T, NK>> & Omit<T, NK>;
-
-type Or<A, B> = A extends undefined ? B : A;
-
-type TxParamsBySchemaInternal<SchemaItem> = {
-  -readonly [key in keyof SchemaItem]: SchemaItem[key] extends Field
-    ? Parameters<SchemaItem[key]['serialize']>[0]
-    : never;
-};
-
-type TxParamsBySchemaInternalParams<
-  SchemaItem,
-  SchemaItemValues = SchemaItem[keyof SchemaItem],
-> = UnionToIntersection<
-SchemaItemValues extends Field
-  ? Or<Parameters<SchemaItemValues['serialize']>[2], {}> : never
->;
-
-type PickIsRec<SchemaItem, Recursive extends boolean> = {
-  [Key in keyof SchemaItem
-  as SchemaItem[Key] extends Field & { recursiveType: true }
-    ? (Recursive extends true ? Key : never)
-    : (Recursive extends true ? never : Key)]: SchemaItem[Key];
-};
-
-type TxParamsBySchema<SchemaItem> = SchemaItem extends Object
-  ? TxParamsBySchemaInternal<PickIsRec<SchemaItem, true>> &
-  NullablePartial<TxParamsBySchemaInternal<PickIsRec<SchemaItem, false>>> &
-  TxParamsBySchemaInternalParams<PickIsRec<SchemaItem, false>>
-  : never;
-
-type TxParamsAsyncBySchemaInternal<SchemaItem> = {
-  -readonly [key in keyof SchemaItem]: SchemaItem[key] extends Field & { prepare: Function }
-    ? Parameters<SchemaItem[key]['prepare']>[0]
-    : SchemaItem[key] extends Field
-      ? Parameters<SchemaItem[key]['serialize']>[0]
-      : never;
-};
-
-type TxParamsAsyncBySchemaInternalParams<
-  SchemaItem,
-  SchemaItemValues = SchemaItem[keyof SchemaItem],
-> = UnionToIntersection<
-SchemaItemValues extends Field & { prepare: Function }
-  ? Or<Parameters<SchemaItemValues['prepare']>[2], {}> : {}
->;
-
-type TxParamsAsyncBySchema<SchemaItem> = SchemaItem extends Object
-  ? TxParamsAsyncBySchemaInternal<PickIsRec<SchemaItem, true>>
-  & NullablePartial<TxParamsAsyncBySchemaInternal<PickIsRec<SchemaItem, false>>>
-  & TxParamsAsyncBySchemaInternalParams<PickIsRec<SchemaItem, false>>
-  & TxParamsBySchemaInternalParams<PickIsRec<SchemaItem, false>>
-  : never;
-
-type TxUnpackedBySchema<SchemaItem> = {
-  -readonly [key in keyof SchemaItem]: SchemaItem[key] extends Field
-    ? ReturnType<SchemaItem[key]['deserialize']>
-    : never;
-};
-
-export default interface SchemaTypes<
-  Schema extends readonly any[],
-  SchemaItems = Schema[number],
-> {
-  TxParams: TxParamsBySchema<SchemaItems>;
-  TxParamsAsync: TxParamsAsyncBySchema<SchemaItems>;
-  TxUnpacked: TxUnpackedBySchema<SchemaItems>;
-}

package/src/tx/builder/common.ts

@@ -1,74 +0,0 @@
-import { decode as rlpDecode, encode as rlpEncode } from 'rlp';
-import { Field, BinaryData } from './field-types';
-import {
-  ArgumentError, DecodeError, SchemaNotFoundError, InternalError,
-} from '../../utils/errors';
-import {
-  Encoding, Encoded, encode, decode,
-} from '../../utils/encoder';
-import { readInt } from './helpers';
-
-type Schemas = ReadonlyArray<{
-  tag: { constValue: number } & Field;
-  version: { constValue: number; constValueOptional: boolean } & Field;
-}>;
-
-export function getSchema(
-  schemas: Schemas,
-  Tag: { [key: number]: string },
-  tag: number,
-  version: number | undefined,
-): Array<[string, Field]> {
-  const subSchemas = schemas.filter((s) => s.tag.constValue === tag);
-  if (subSchemas.length === 0) throw new SchemaNotFoundError(`${Tag[tag]} (${tag})`, 0);
-  if (version == null) {
-    const defaultSchema = subSchemas.find((schema) => schema.version.constValueOptional);
-    if (defaultSchema == null) throw new InternalError(`Can't find default schema of ${Tag[tag]} (${tag})`);
-    version = defaultSchema.version.constValue;
-  }
-  const schema = subSchemas.find((s) => s.version.constValue === version);
-  if (schema == null) throw new SchemaNotFoundError(`${Tag[tag]} (${tag})`, version);
-  return Object.entries(schema);
-}
-
-export function packRecord<E extends Encoding>(
-  schemas: Schemas,
-  Tag: { [key: number]: string },
-  params: {
-    tag: number;
-    version?: number;
-    [k: string]: unknown;
-  },
-  extraParams: { [k: string]: unknown },
-  encoding: E,
-): Encoded.Generic<E> {
-  const schema = getSchema(schemas, Tag, params.tag, params.version);
-  const binary = schema.map(([key, field]) => (
-    field.serialize(params[key], { ...params, ...extraParams }, params)
-  ));
-  return encode(rlpEncode(binary), encoding);
-}
-
-export function unpackRecord(
-  schemas: Schemas,
-  Tag: { [key: number]: string },
-  encodedRecord: Encoded.Any,
-  expectedTag: number | undefined,
-  extraParams: { [k: string]: unknown },
-): unknown {
-  const binary = rlpDecode(decode(encodedRecord));
-  const tag = +readInt(binary[0] as Buffer);
-  const version = +readInt(binary[1] as Buffer);
-  const schema = getSchema(schemas, Tag, tag, version);
-  if (expectedTag != null && expectedTag !== tag) {
-    throw new DecodeError(`Expected ${Tag[expectedTag]} tag, got ${Tag[tag]} instead`);
-  }
-  if (binary.length !== schema.length) {
-    throw new ArgumentError('RLP length', schema.length, binary.length);
-  }
-  return Object.fromEntries(
-    schema.map(([name, field], index) => [
-      name, field.deserialize(binary[index] as BinaryData, extraParams),
-    ]),
-  );
-}

package/src/tx/builder/constants.ts

@@ -1,155 +0,0 @@
-import BigNumber from 'bignumber.js';
-import { mapObject } from '../../utils/other';
-
-export const DRY_RUN_ACCOUNT = {
-  pub: 'ak_11111111111111111111111111111111273Yts',
-  amount: 100000000000000000000000000000000000n,
-} as const;
-
-export const MAX_AUTH_FUN_GAS = 50000;
-export type Int = number | string | BigNumber;
-export type AensName = `${string}.chain`;
-export const MIN_GAS_PRICE = 1e9; // TODO: don't use number for ae
-// # see https://github.com/aeternity/aeternity/blob/72e440b8731422e335f879a31ecbbee7ac23a1cf/apps/aecore/src/aec_governance.erl#L67
-export const NAME_FEE_MULTIPLIER = 1e14; // 100000000000000
-export const NAME_FEE_BID_INCREMENT = 0.05; // # the increment is in percentage
-// # see https://github.com/aeternity/aeternity/blob/72e440b8731422e335f879a31ecbbee7ac23a1cf/apps/aecore/src/aec_governance.erl#L272
-export const NAME_BID_TIMEOUT_BLOCKS = 480; // # ~1 day
-// # this is the max length for a domain that requires a base fee to be paid
-export const NAME_MAX_LENGTH_FEE = 31;
-// # https://github.com/aeternity/aeternity/blob/72e440b8731422e335f879a31ecbbee7ac23a1cf/apps/aecore/src/aec_governance.erl#L290
-// # https://github.com/aeternity/protocol/blob/master/AENS.md#protocol-fees-and-protection-times
-// # bid ranges:
-export const NAME_BID_RANGES = mapObject({
-  31: 3,
-  30: 5,
-  29: 8,
-  28: 13,
-  27: 21,
-  26: 34,
-  25: 55,
-  24: 89,
-  23: 144,
-  22: 233,
-  21: 377,
-  20: 610,
-  19: 987,
-  18: 1597,
-  17: 2584,
-  16: 4181,
-  15: 6765,
-  14: 10946,
-  13: 17711,
-  12: 28657,
-  11: 46368,
-  10: 75025,
-  9: 121393,
-  8: 196418,
-  7: 317811,
-  6: 514229,
-  5: 832040,
-  4: 1346269,
-  3: 2178309,
-  2: 3524578,
-  1: 5702887,
-}, ([key, value]) => [key, new BigNumber(value).times(NAME_FEE_MULTIPLIER)]);
-
-export enum ConsensusProtocolVersion {
-  Iris = 5,
-  Ceres = 6,
-}
-
-/**
- * @category transaction builder
- * @see {@link https://github.com/aeternity/protocol/blob/0f6dee3d9d1e8e2469816798f5c7587a6c918f94/contracts/contract_vms.md#virtual-machines-on-the-%C3%A6ternity-blockchain}
- */
-export enum VmVersion {
-  NoVm = 0,
-  Sophia = 1,
-  SophiaImprovementsMinerva = 3,
-  SophiaImprovementsFortuna = 4,
-  Fate = 5,
-  SophiaImprovementsLima = 6,
-  Fate2 = 7,
-  Fate3 = 8,
-}
-
-/**
- * @category transaction builder
- * @see {@link https://github.com/aeternity/protocol/blob/0f6dee3d9d1e8e2469816798f5c7587a6c918f94/contracts/contract_vms.md#virtual-machines-on-the-%C3%A6ternity-blockchain}
- */
-export enum AbiVersion {
-  NoAbi = 0,
-  Sophia = 1,
-  Fate = 3,
-}
-
-/**
- * Enum with tag types
- * @category transaction builder
- * @see {@link https://github.com/aeternity/protocol/blob/0f6dee3d9d1e8e2469816798f5c7587a6c918f94/serializations.md#binary-serialization}
- * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_chain_objects.erl#L39-L97}
- */
-// TODO: implement serialisation for commented-out tags
-export enum Tag {
-  Account = 10,
-  SignedTx = 11,
-  SpendTx = 12,
-  Oracle = 20,
-  // OracleQuery = 21,
-  OracleRegisterTx = 22,
-  OracleQueryTx = 23,
-  OracleResponseTx = 24,
-  OracleExtendTx = 25,
-  Name = 30,
-  // NameCommitment = 31,
-  NameClaimTx = 32,
-  NamePreclaimTx = 33,
-  NameUpdateTx = 34,
-  NameRevokeTx = 35,
-  NameTransferTx = 36,
-  // NameAuction = 37,
-  Contract = 40,
-  ContractCall = 41,
-  ContractCreateTx = 42,
-  ContractCallTx = 43,
-  ChannelCreateTx = 50,
-  // ChannelSetDelegatesTx = 501,
-  ChannelDepositTx = 51,
-  ChannelWithdrawTx = 52,
-  ChannelForceProgressTx = 521,
-  ChannelCloseMutualTx = 53,
-  ChannelCloseSoloTx = 54,
-  ChannelSlashTx = 55,
-  ChannelSettleTx = 56,
-  ChannelOffChainTx = 57,
-  ChannelOffChainUpdateTransfer = 570,
-  ChannelOffChainUpdateDeposit = 571,
-  ChannelOffChainUpdateWithdraw = 572,
-  ChannelOffChainUpdateCreateContract = 573,
-  ChannelOffChainUpdateCallContract = 574,
-  // ChannelOffChainUpdateMeta = 576,
-  ChannelClientReconnectTx = 575,
-  Channel = 58,
-  ChannelSnapshotSoloTx = 59,
-  TreesPoi = 60,
-  // TreesDb = 61,
-  StateTrees = 62,
-  Mtree = 63,
-  MtreeValue = 64,
-  ContractsMtree = 621,
-  CallsMtree = 622,
-  ChannelsMtree = 623,
-  NameserviceMtree = 624,
-  OraclesMtree = 625,
-  AccountsMtree = 626,
-  // CompilerSophia = 70,
-  GaAttachTx = 80,
-  GaMetaTx = 81,
-  PayingForTx = 82,
-  GaMetaTxAuthData = 810,
-  // KeyBlock = 100,
-  // MicroBlock = 101,
-  // LightMicroBlock = 102,
-  // Pof = 200,
-}

package/src/tx/builder/delegation/index.ts

@@ -1,28 +0,0 @@
-import { Encoded, Encoding } from '../../../utils/encoder';
-import { packRecord, unpackRecord } from '../common';
-import { DelegationTag, schemas } from './schema';
-import { DlgParams, DlgUnpacked } from './schema.generated';
-
-/**
- * Pack delegation
- * @category delegation signature
- * @param params - Params of delegation
- * @returns Encoded delegation
- */
-export function packDelegation(params: DlgParams): Encoded.Bytearray {
-  return packRecord(schemas, DelegationTag, params, {}, Encoding.Bytearray);
-}
-
-/**
- * Unpack delegation
- * @category delegation signature
- * @param encoded - Encoded delegation
- * @param expectedTag - Expected delegation signature type
- * @returns Params of delegation
- */
-export function unpackDelegation<T extends DelegationTag>(
-  encoded: Encoded.Bytearray,
-  expectedTag?: T,
-): DlgUnpacked & { tag: T } {
-  return unpackRecord(schemas, DelegationTag, encoded, expectedTag, {}) as any;
-}