@aeternity/aepp-sdk 13.1.0 → 13.2.0

package/src/AeSdkBase.ts

@@ -6,6 +6,7 @@ import {
 import { Encoded } from './utils/encoder';
 import CompilerBase from './contract/compiler/Base';
 import AeSdkMethods, { OnAccount, getValueOrErrorProxy, AeSdkMethodsOptions } from './AeSdkMethods';
+import { AensName } from './tx/builder/constants';
 
 type NodeInfo = Awaited<ReturnType<Node['getNodeInfo']>> & { name: string };
 
@@ -176,6 +177,41 @@ export default class AeSdkBase extends AeSdkMethods {
     return this._resolveAccount(onAccount).signTypedData(data, aci, 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;
+    return this._resolveAccount(onAccount)
+      .signDelegationToContract(contractAddress, 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;
+    return this._resolveAccount(onAccount)
+      .signNameDelegationToContract(contractAddress, name, 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;
+    return this._resolveAccount(onAccount)
+      .signOracleQueryDelegationToContract(contractAddress, oracleQueryId, options);
+  }
+
   override _getOptions(callOptions: AeSdkMethodsOptions = {}): {
     onNode: Node;
     onAccount: AccountBase;

package/src/AeSdkWallet.ts

@@ -106,12 +106,23 @@ export default class AeSdkWallet extends AeSdk {
     this._type = type;
   }
 
+  _getAccountsForClient({ addressSubscription }: RpcClientsInfo): Accounts {
+    const { current, connected } = this.getAccounts();
+    return {
+      current: addressSubscription.has('current') || addressSubscription.has('connected')
+        ? current : {},
+      connected: addressSubscription.has('connected') ? connected : {},
+    };
+  }
+
   _pushAccountsToApps(): void {
     if (this._clients == null) return;
     Array.from(this._clients.keys())
-      .filter((clientId) => this._isRpcClientSubscribed(clientId))
-      .map((clientId) => this._getClient(clientId).rpc)
-      .forEach((client) => client.notify(METHODS.updateAddress, this.getAccounts()));
+      .filter((clientId) => this._isRpcClientConnected(clientId))
+      .map((clientId) => this._getClient(clientId))
+      .filter((client) => client.addressSubscription.size !== 0)
+      .forEach((client) => client.rpc
+        .notify(METHODS.updateAddress, this._getAccountsForClient(client)));
   }
 
   override selectAccount(address: Encoded.AccountAddress): void {
@@ -149,11 +160,6 @@ export default class AeSdkWallet extends AeSdk {
     return client;
   }
 
-  _isRpcClientSubscribed(clientId: string): boolean {
-    return this._isRpcClientConnected(clientId)
-      && this._getClient(clientId).addressSubscription.size !== 0;
-  }
-
   _isRpcClientConnected(clientId: string): boolean {
     return RPC_STATUS.CONNECTED === this._getClient(clientId).status
       && this._getClient(clientId).rpc.connection.isConnected();
@@ -219,10 +225,10 @@ export default class AeSdkWallet extends AeSdk {
           [METHODS.subscribeAddress]: async ({ type, value }, origin) => {
             if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
 
-            await this.onSubscription(id, { type, value }, origin);
-
             switch (type) {
               case SUBSCRIPTION_TYPES.subscribe:
+                // TODO: remove `type` as it always subscribe
+                await this.onSubscription(id, { type, value }, origin);
                 client.addressSubscription.add(value);
                 break;
               case SUBSCRIPTION_TYPES.unsubscribe:
@@ -234,11 +240,11 @@ export default class AeSdkWallet extends AeSdk {
 
             return {
               subscription: Array.from(client.addressSubscription),
-              address: this.getAccounts(),
+              address: this._getAccountsForClient(client),
             };
           },
           [METHODS.address]: async (params, origin) => {
-            if (!this._isRpcClientSubscribed(id)) throw new RpcNotAuthorizeError();
+            if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
             await this.onAskAccounts(id, params, origin);
             return this.addresses();
           },
@@ -295,6 +301,24 @@ export default class AeSdkWallet extends AeSdk {
               signature: await this.signTypedData(data, aci, parameters),
             };
           },
+          [METHODS.signDelegationToContract]: async ({
+            contractAddress, name, oracleQueryId, onAccount = this.address,
+          }, origin) => {
+            if (!this._isRpcClientConnected(id)) throw new RpcNotAuthorizeError();
+            if (!this.addresses().includes(onAccount)) {
+              throw new RpcPermissionDenyError(onAccount);
+            }
+
+            const parameters = { onAccount, aeppOrigin: origin, aeppRpcClientId: id };
+            const signature = await (
+              (name == null ? null : this
+                .signNameDelegationToContract(contractAddress, name, parameters))
+              ?? (oracleQueryId == null ? null : this
+                .signOracleQueryDelegationToContract(contractAddress, oracleQueryId, parameters))
+              ?? this.signDelegationToContract(contractAddress, parameters)
+            );
+            return { signature };
+          },
         },
       ),
     };

package/src/account/Base.ts

@@ -1,8 +1,9 @@
 import { Encoded } from '../utils/encoder';
 import Node from '../Node';
 import CompilerBase from '../contract/compiler/Base';
-import { Int } from '../tx/builder/constants';
+import { AensName, Int } from '../tx/builder/constants';
 import { AciValue, Domain } from '../utils/typed-data';
+import { NotImplementedError } from '../utils/errors';
 
 interface AuthData {
   fee?: Int;
@@ -60,14 +61,94 @@ export default abstract class AccountBase {
    * @param options - Options
    * @returns Signature
    */
-  abstract signTypedData(
+  // TODO: make abstract in the next major release
+  // eslint-disable-next-line class-methods-use-this
+  async signTypedData(
+    /* eslint-disable @typescript-eslint/no-unused-vars */
     data: Encoded.ContractBytearray,
     aci: AciValue,
     options?: Domain & {
       aeppOrigin?: string;
       aeppRpcClientId?: string;
     },
-  ): Promise<Encoded.Signature>;
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  ): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signTypedData method');
+  }
+
+  /**
+   * Sign delegation of AENS, oracle operations to a contract
+   * @param contractAddress - Address of a contract to delegate permissions to
+   * @param options - Options
+   * @returns Signature
+   */
+  // TODO: make abstract in the next major release
+  // eslint-disable-next-line class-methods-use-this
+  async signDelegationToContract(
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    contractAddress: Encoded.ContractAddress,
+    options?: {
+      networkId?: string;
+      aeppOrigin?: string;
+      aeppRpcClientId?: string;
+    },
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  ): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signDelegationToContract method');
+  }
+
+  /**
+   * Sign delegation of an AENS name to a contract
+   * @param contractAddress - Address of a contract to delegate permissions to
+   * @param name - AENS name to manage by a contract
+   * @param options - Options
+   * @returns Signature
+   */
+  // TODO: make abstract in the next major release
+  // eslint-disable-next-line class-methods-use-this
+  async signNameDelegationToContract(
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    contractAddress: Encoded.ContractAddress,
+    name: AensName,
+    options?: {
+      networkId?: string;
+      aeppOrigin?: string;
+      aeppRpcClientId?: string;
+    },
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  ): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signNameDelegationToContract method');
+  }
+
+  /**
+   * Sign delegation of oracle query to a contract
+   *
+   * Warning! Implementations needs to ensure that decoded oracle query id is not equal to decoded
+   * current account address unless https://github.com/aeternity/aesophia/issues/475 is fixed.
+   *
+   * Warning! Implementations needs to ensure that oracle query and contract exists unless
+   * https://github.com/aeternity/aesophia/issues/474 is fixed.
+   *
+   * @param contractAddress - Address of a contract to delegate permissions to
+   * @param oracleQueryId - Oracle query ID to reply by a contract
+   * @param options - Options
+   * @returns Signature
+   */
+  // TODO: make abstract in the next major release
+  // eslint-disable-next-line class-methods-use-this
+  async signOracleQueryDelegationToContract(
+    /* eslint-disable @typescript-eslint/no-unused-vars */
+    contractAddress: Encoded.ContractAddress,
+    oracleQueryId: Encoded.OracleQueryId,
+    options?: {
+      networkId?: string;
+      aeppOrigin?: string;
+      aeppRpcClientId?: string;
+    },
+    /* eslint-enable @typescript-eslint/no-unused-vars */
+  ): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signOracleQueryDelegationToContract method');
+  }
 
   /**
    * Sign data blob

package/src/account/Generalized.ts

@@ -43,6 +43,21 @@ export default class AccountGeneralized extends AccountBase {
     throw new NotImplementedError('Can\'t sign using generalized account');
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  override async signDelegationToContract(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation to contract using generalized account');
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override async signNameDelegationToContract(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation to contract using generalized account');
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override async signOracleQueryDelegationToContract(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation to contract using generalized account');
+  }
+
   override async signTransaction(
     tx: Encoded.Transaction,
     { authData, onCompiler, onNode }: Parameters<AccountBase['signTransaction']>[1],

package/src/account/Ledger.ts

@@ -45,6 +45,21 @@ export default class AccountLedger extends AccountBase {
     throw new NotImplementedError('Typed data signing using Ledger HW');
   }
 
+  // eslint-disable-next-line class-methods-use-this
+  override async signDelegationToContract(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation to contract using Ledger HW');
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override async signNameDelegationToContract(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation to contract using Ledger HW');
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  override async signOracleQueryDelegationToContract(): Promise<Encoded.Signature> {
+    throw new NotImplementedError('signing delegation to contract using Ledger HW');
+  }
+
   override async signTransaction(
     tx: Encoded.Transaction,
     { innerTx, networkId }: { innerTx?: boolean; networkId?: string } = {},

package/src/account/Memory.ts

@@ -9,7 +9,8 @@ import {
 import { concatBuffers } from '../utils/other';
 import { hashTypedData, AciValue } from '../utils/typed-data';
 import { buildTx } from '../tx/builder';
-import { Tag } from '../tx/builder/constants';
+import { Tag, AensName } from '../tx/builder/constants';
+import { produceNameId } from '../tx/builder/helpers';
 
 const secretKeys = new WeakMap();
 
@@ -89,4 +90,55 @@ export default class AccountMemory extends AccountBase {
     const signature = await this.sign(dHash, options);
     return encode(signature, Encoding.Signature);
   }
+
+  override async signDelegationToContract(
+    contractAddress: Encoded.ContractAddress,
+    { networkId }: { networkId?: string } = {},
+  ): Promise<Encoded.Signature> {
+    if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
+    const payload = concatBuffers([
+      Buffer.from(networkId),
+      decode(this.address),
+      decode(contractAddress),
+    ]);
+    const signature = await this.sign(payload);
+    return encode(signature, Encoding.Signature);
+  }
+
+  override async signNameDelegationToContract(
+    contractAddress: Encoded.ContractAddress,
+    name: AensName,
+    { networkId }: { networkId?: string } = {},
+  ): Promise<Encoded.Signature> {
+    if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
+    const payload = concatBuffers([
+      Buffer.from(networkId),
+      decode(this.address),
+      decode(produceNameId(name)),
+      decode(contractAddress),
+    ]);
+    const signature = await this.sign(payload);
+    return encode(signature, Encoding.Signature);
+  }
+
+  override async signOracleQueryDelegationToContract(
+    contractAddress: Encoded.ContractAddress,
+    oracleQueryId: Encoded.OracleQueryId,
+    { networkId }: { networkId?: string } = {},
+  ): Promise<Encoded.Signature> {
+    const oracleQueryIdDecoded = decode(oracleQueryId);
+    const addressDecoded = decode(this.address);
+    // TODO: remove after fixing https://github.com/aeternity/aesophia/issues/475
+    if (oracleQueryIdDecoded.compare(addressDecoded) === 0) {
+      throw new ArgumentError('oracleQueryId', 'not equal to account address', oracleQueryId);
+    }
+    if (networkId == null) throw new ArgumentError('networkId', 'provided', networkId);
+    const payload = concatBuffers([
+      Buffer.from(networkId),
+      oracleQueryIdDecoded,
+      decode(contractAddress),
+    ]);
+    const signature = await this.sign(payload);
+    return encode(signature, Encoding.Signature);
+  }
 }

package/src/account/Rpc.ts

@@ -4,6 +4,7 @@ import { ArgumentError, NotImplementedError, UnsupportedProtocolError } from '..
 import { Encoded } from '../utils/encoder';
 import RpcClient from '../aepp-wallet-communication/rpc/RpcClient';
 import { AeppApi, WalletApi } from '../aepp-wallet-communication/rpc/types';
+import { AensName } from '../tx/builder/constants';
 
 /**
  * Account provided by wallet
@@ -69,4 +70,38 @@ export default class AccountRpc extends AccountBase {
     });
     return signature;
   }
+
+  override async signDelegationToContract(
+    contractAddress: Encoded.ContractAddress,
+  ): Promise<Encoded.Signature> {
+    const { signature } = await this._rpcClient.request(METHODS.signDelegationToContract, {
+      onAccount: this.address,
+      contractAddress,
+    });
+    return signature;
+  }
+
+  override async signNameDelegationToContract(
+    contractAddress: Encoded.ContractAddress,
+    name: AensName,
+  ): Promise<Encoded.Signature> {
+    const { signature } = await this._rpcClient.request(METHODS.signDelegationToContract, {
+      onAccount: this.address,
+      contractAddress,
+      name,
+    });
+    return signature;
+  }
+
+  override async signOracleQueryDelegationToContract(
+    contractAddress: Encoded.ContractAddress,
+    oracleQueryId: Encoded.OracleQueryId,
+  ): Promise<Encoded.Signature> {
+    const { signature } = await this._rpcClient.request(METHODS.signDelegationToContract, {
+      onAccount: this.address,
+      contractAddress,
+      oracleQueryId,
+    });
+    return signature;
+  }
 }

package/src/aepp-wallet-communication/rpc/types.ts

@@ -3,6 +3,7 @@ import { Domain, AciValue } from '../../utils/typed-data';
 import { METHODS, SUBSCRIPTION_TYPES, WALLET_TYPE } from '../schema';
 import { TransformNodeType } from '../../Node';
 import { SignedTx } from '../../apis/node';
+import { AensName } from '../../tx/builder/constants';
 
 export interface WalletInfo {
   id: string;
@@ -82,6 +83,15 @@ export interface WalletApi {
       onAccount: Encoded.AccountAddress;
     },
   ) => Promise<{ signature: Encoded.Signature }>;
+
+  [METHODS.signDelegationToContract]: (
+    p: {
+      contractAddress: Encoded.ContractAddress;
+      name?: AensName;
+      oracleQueryId?: Encoded.OracleQueryId;
+      onAccount: Encoded.AccountAddress;
+    },
+  ) => Promise<{ signature: Encoded.Signature }>;
 }
 
 export interface AeppApi {

package/src/aepp-wallet-communication/schema.ts

@@ -37,6 +37,7 @@ export const enum METHODS {
   sign = 'transaction.sign',
   signMessage = 'message.sign',
   signTypedData = 'typedData.sign',
+  signDelegationToContract = 'delegationToContract.sign',
   subscribeAddress = 'address.subscribe',
   updateNetwork = 'networkId.update',
   closeConnection = 'connection.close',

package/src/chain.ts

@@ -197,7 +197,7 @@ export async function sendTransaction(
         rawTx: tx,
       };
       // wait for transaction confirmation
-      if (confirm != null && (confirm === true || confirm > 0)) {
+      if (confirm != null && +confirm > 0) {
         const c = typeof confirm === 'boolean' ? undefined : confirm;
         return {
           ...txData,

package/src/contract/Contract.ts

@@ -312,7 +312,7 @@ class Contract<M extends ContractMethodsBase> {
 
     if (fn == null) throw new MissingFunctionNameError();
     if (fn === 'init' && callStatic !== true) throw new InvalidMethodInvocationError('"init" can be called only via dryRun');
-    if (fn !== 'init' && opt.amount != null && opt.amount > 0 && !fnAci.payable) {
+    if (fn !== 'init' && opt.amount != null && +opt.amount > 0 && !fnAci.payable) {
       throw new NotPayableFunctionError(opt.amount, fn);
     }
 

package/src/contract/delegation-signature.ts

@@ -1,10 +1,14 @@
 import { decode, Encoded } from '../utils/encoder';
+import { ArgumentError } from '../utils/errors';
 import { AensName } from '../tx/builder/constants';
 import AccountBase from '../account/Base';
-import { concatBuffers } from '../utils/other';
-import { isNameValid, produceNameId } from '../tx/builder/helpers';
+import { isNameValid } from '../tx/builder/helpers';
 import Node from '../Node';
 
+function ensureOracleQuery(oq: string): asserts oq is Encoded.OracleQueryId {
+  if (!oq.startsWith('oq_')) throw new ArgumentError('oq', 'oracle query', oq);
+}
+
 /**
  * Helper to generate a signature to delegate
  *  - pre-claim/claim/transfer/revoke of a name to a contract.
@@ -17,6 +21,7 @@ import Node from '../Node';
  * @param options.onAccount - Account to use
  * @param options.onNode - Node to use
  * @returns Signature
+ * @deprecated use methods `sign*DelegationToContract` of Account instance instead
  * @example
  * ```js
  * const aeSdk = new AeSdk({ ... })
@@ -42,15 +47,36 @@ import Node from '../Node';
 export default async function createDelegationSignature(
   contractAddress: Encoded.ContractAddress,
   ids: Array<Encoded.Any | AensName>,
-  options: { omitAddress?: boolean; onAccount: AccountBase; onNode: Node },
+  { onAccount, omitAddress, ...options }: {
+    omitAddress?: boolean;
+    onAccount: AccountBase;
+    onNode: Node;
+  },
 ): Promise<Uint8Array> {
-  return options.onAccount.sign(
-    concatBuffers([
-      Buffer.from(await options.onNode.getNetworkId()),
-      ...options.omitAddress === true ? [] : [decode(options.onAccount.address)],
-      ...ids.map((e) => (isNameValid(e) ? produceNameId(e) : e)).map((e) => decode(e)),
-      decode(contractAddress),
-    ]),
-    options,
+  if (ids.length > 1) throw new ArgumentError('ids', 'shorter than 2', ids);
+  const networkId = await options.onNode.getNetworkId();
+  if (ids.length === 0) {
+    if (omitAddress === true) {
+      throw new ArgumentError('omitAddress', 'equal false', omitAddress);
+    }
+    return decode(await onAccount.signDelegationToContract(contractAddress, { networkId }));
+  }
+
+  const [payload] = ids;
+  if (isNameValid(payload)) {
+    if (omitAddress === true) {
+      throw new ArgumentError('omitAddress', 'equal false', omitAddress);
+    }
+    return decode(
+      await onAccount.signNameDelegationToContract(contractAddress, payload, { networkId }),
+    );
+  }
+
+  ensureOracleQuery(payload);
+  if (omitAddress !== true) {
+    throw new ArgumentError('omitAddress', 'equal true', omitAddress);
+  }
+  return decode(
+    await onAccount.signOracleQueryDelegationToContract(contractAddress, payload, { networkId }),
   );
 }

package/src/spend.ts

@@ -60,11 +60,11 @@ interface SpendOptions extends SpendOptionsType {}
  * ```
  */
 export async function transferFunds(
-  fraction: number | string,
+  fraction: number | string, // TODO: accept only number
   recipientIdOrName: AensName | Encoded.AccountAddress,
   options: TransferFundsOptions,
 ): ReturnType<typeof sendTransaction> {
-  if (fraction < 0 || fraction > 1) {
+  if (+fraction < 0 || +fraction > 1) {
     throw new ArgumentError('fraction', 'a number between 0 and 1', fraction);
   }
   const recipientId = await resolveName<Encoding.AccountAddress>(

package/src/tx/builder/field-types/index.ts

@@ -1,61 +1,31 @@
-import _abiVersion from './abi-version';
-import _address from './address';
-import _array from './array';
-import _boolean from './boolean';
-import _coinAmount from './coin-amount';
-import _ctVersion from './ct-version';
-import _deposit from './deposit';
-import _encoded from './encoded';
-import _entry from './entry';
-import _enumeration from './enumeration';
-import _fee from './fee';
-import _field from './field';
-import _gasLimit from './gas-limit';
-import _gasPrice from './gas-price';
-import _map from './map';
-import _mptree from './mptree';
-import _name from './name';
-import _nameFee from './name-fee';
-import _nameId from './name-id';
-import _nonce from './nonce';
-import _pointers from './pointers';
-import _raw from './raw';
-import _shortUInt from './short-u-int';
-import _shortUIntConst from './short-u-int-const';
-import _string from './string';
-import _ttl from './ttl';
-import _uInt from './u-int';
-import _wrapped from './wrapped';
-
-// TODO: remove after fixing https://github.com/Gerrit0/typedoc-plugin-missing-exports/issues/15
-const abiVersion = _abiVersion;
-const address = _address;
-const array = _array;
-const boolean = _boolean;
-const coinAmount = _coinAmount;
-const ctVersion = _ctVersion;
-const deposit = _deposit;
-const encoded = _encoded;
-const entry = _entry;
-const enumeration = _enumeration;
-const fee = _fee;
-const field = _field;
-const gasLimit = _gasLimit;
-const gasPrice = _gasPrice;
-const map = _map;
-const mptree = _mptree;
-const name = _name;
-const nameFee = _nameFee;
-const nameId = _nameId;
-const nonce = _nonce;
-const pointers = _pointers;
-const raw = _raw;
-const shortUInt = _shortUInt;
-const shortUIntConst = _shortUIntConst;
-const string = _string;
-const ttl = _ttl;
-const uInt = _uInt;
-const wrapped = _wrapped;
+import abiVersion from './abi-version';
+import address from './address';
+import array from './array';
+import boolean from './boolean';
+import coinAmount from './coin-amount';
+import ctVersion from './ct-version';
+import deposit from './deposit';
+import encoded from './encoded';
+import entry from './entry';
+import enumeration from './enumeration';
+import fee from './fee';
+import field from './field';
+import gasLimit from './gas-limit';
+import gasPrice from './gas-price';
+import map from './map';
+import mptree from './mptree';
+import name from './name';
+import nameFee from './name-fee';
+import nameId from './name-id';
+import nonce from './nonce';
+import pointers from './pointers';
+import raw from './raw';
+import shortUInt from './short-u-int';
+import shortUIntConst from './short-u-int-const';
+import string from './string';
+import ttl from './ttl';
+import uInt from './u-int';
+import wrapped from './wrapped';
 
 export type BinaryData = Buffer | Buffer[] | Buffer[][]
 | Array<[Buffer, Array<[Buffer, Buffer[]]>]>;

package/src/tx/builder/field-types/u-int.ts

@@ -5,7 +5,7 @@ import { toBytes } from '../../../utils/bytes';
 
 export default {
   serialize(value: Int): Buffer {
-    if (value < 0) throw new ArgumentError('value', 'greater or equal to 0', value);
+    if (+value < 0) throw new ArgumentError('value', 'greater or equal to 0', value);
     return toBytes(value, true);
   },