@aeternity/aepp-sdk 12.1.2 → 13.0.0-alpha.0

package/src/contract/ga.ts

@@ -19,52 +19,32 @@
  * Generalized Account module - routines to use generalized account
  */
 
-import { MAX_AUTH_FUN_GAS, TxSchema } from '../tx/builder/schema';
 import { Tag } from '../tx/builder/constants';
-import {
-  buildContractIdByContractTx, buildTx, BuiltTx, TxUnpacked, unpackTx,
-} from '../tx/builder';
-import {
-  _buildTx, BuildTxOptions, getVmVersion, prepareTxParams,
-} from '../tx';
+import { buildContractIdByContractTx } from '../tx/builder';
+import { _buildTx, BuildTxOptions } from '../tx';
 import { hash } from '../utils/crypto';
-import { decode, Encoded, Encoding } from '../utils/encoder';
-import { IllegalArgumentError, MissingParamError, InvalidAuthDataError } from '../utils/errors';
+import { decode, Encoded } from '../utils/encoder';
+import { IllegalArgumentError } from '../utils/errors';
 import { concatBuffers } from '../utils/other';
 import AccountBase from '../account/Base';
-import { getContractInstance } from './methods';
+import Contract from './Contract';
 import { send, SendOptions } from '../spend';
 import Node from '../Node';
 import { getAccount } from '../chain';
-import Compiler from './Compiler';
-
-/**
- * Check if account is GA
- * @category contract
- * @param address - Account address
- * @param options - Options
- * @returns if account is GA
- */
-export async function isGA(
-  address: Encoded.AccountAddress,
-  options: Parameters<typeof getAccount>[1],
-): Promise<boolean> {
-  const { contractId } = await getAccount(address, options);
-  return contractId != null;
-}
+import CompilerHttp from './CompilerHttp';
 
 /**
  * Convert current account to GA
  * @category contract
  * @param authFnName - Authorization function name
- * @param source - Auth contract source code
+ * @param sourceCode - Auth contract source code
  * @param args - init arguments
  * @param options - Options
  * @returns General Account Object
  */
 export async function createGeneralizedAccount(
   authFnName: string,
-  source: string,
+  sourceCode: string,
   args: any[],
   {
     onAccount, onCompiler, onNode, ...options
@@ -75,20 +55,22 @@ export async function createGeneralizedAccount(
     rawTx: Encoded.Transaction;
     gaContractId: Encoded.ContractAddress;
   }>> {
-  const ownerId = await onAccount.address(options);
-  if (await isGA(ownerId, { onNode })) throw new IllegalArgumentError(`Account ${ownerId} is already GA`);
+  const ownerId = onAccount.address;
+  if ((await getAccount(ownerId, { onNode })).kind === 'generalized') {
+    throw new IllegalArgumentError(`Account ${ownerId} is already GA`);
+  }
 
-  const contract = await getContractInstance({
-    onAccount, onCompiler, onNode, source,
+  const contract = await Contract.initialize<{ init: (...a: any[]) => void }>({
+    onAccount, onCompiler, onNode, sourceCode,
   });
 
   const tx = await _buildTx(Tag.GaAttachTx, {
     ...options,
     onNode,
-    code: await contract.compile(),
+    code: await contract.$compile(),
     gasLimit: options.gasLimit ?? await contract._estimateGas('init', args, options),
     ownerId,
-    callData: contract.calldata.encode(contract._name, 'init', args),
+    callData: contract._calldata.encode(contract._name, 'init', args),
     authFun: hash(authFnName),
   });
   const contractId = buildContractIdByContractTx(tx);
@@ -108,78 +90,11 @@ interface CreateGeneralizedAccountOptions extends
   BuildTxOptions<Tag.GaAttachTx, 'authFun' | 'callData' | 'code' | 'ownerId' | 'gasLimit'>,
   SendOptions {
   onAccount: AccountBase;
-  onCompiler: Compiler;
+  onCompiler: CompilerHttp;
   onNode: Node;
   gasLimit?: number;
 }
 
-/**
- * Create a metaTx transaction
- * @category contract
- * @param rawTransaction - Inner transaction
- * @param authData - Object with gaMeta params
- * @param authFnName - Authorization function name
- * @param options - Options
- * @param options.onAccount - Account to use
- * @returns Transaction string
- */
-export async function createMetaTx(
-  rawTransaction: Encoded.Transaction,
-  authData: {
-    gasLimit?: number;
-    callData?: Encoded.ContractBytearray;
-    source?: string;
-    args?: any[];
-  },
-  authFnName: string,
-  {
-    onAccount, onCompiler, onNode, ...options
-  }:
-  { onAccount: AccountBase; onCompiler: Compiler; onNode: Node }
-  & Parameters<AccountBase['address']>[0],
-): Promise<Encoded.Transaction> {
-  const wrapInEmptySignedTx = (
-    tx: Encoded.Transaction | Uint8Array | TxUnpacked<TxSchema>,
-  ): BuiltTx<TxSchema, Encoding.Transaction> => (
-    buildTx({ encodedTx: tx, signatures: [] }, Tag.SignedTx)
-  );
-
-  if (Object.keys(authData).length <= 0) throw new MissingParamError('authData is required');
-
-  const gasLimit = authData.gasLimit ?? MAX_AUTH_FUN_GAS;
-  if (gasLimit > MAX_AUTH_FUN_GAS) {
-    throw new InvalidAuthDataError(`the maximum gasLimit value for ga authFun is ${MAX_AUTH_FUN_GAS}, got ${gasLimit}`);
-  }
-
-  const authCallData = authData.callData ?? await (async () => {
-    if (authData.source == null || authData.args == null) throw new InvalidAuthDataError('Auth data must contain source code and arguments.');
-    const contract = await getContractInstance({
-      onCompiler, onNode, source: authData.source,
-    });
-    return contract.calldata.encode(contract._name, authFnName, authData.args);
-  })();
-
-  const { abiVersion } = await getVmVersion(Tag.ContractCallTx, { onNode });
-  const wrappedTx = wrapInEmptySignedTx(unpackTx<Tag.SignedTx>(rawTransaction));
-  const params = {
-    ...options,
-    tx: {
-      ...wrappedTx,
-      tx: wrappedTx.txObject,
-    },
-    // TODO: accept an address instead
-    gaId: await onAccount.address(options),
-    abiVersion,
-    authData: authCallData,
-    gasLimit,
-    vsn: 2,
-  };
-  // @ts-expect-error createMetaTx needs to be integrated into tx builder
-  const { fee } = await prepareTxParams(Tag.GaMetaTx, { ...params, onNode });
-  const { rlpEncoded: metaTxRlp } = buildTx({ ...params, fee }, Tag.GaMetaTx);
-  return wrapInEmptySignedTx(metaTxRlp).tx;
-}
-
 /**
  * Build a transaction hash the same as `Auth.tx_hash`
  * @category contract
@@ -192,8 +107,7 @@ export async function buildAuthTxHash(
   transaction: Encoded.Transaction,
   { onNode }: { onNode: Node },
 ): Promise<Uint8Array> {
-  const { networkId } = await onNode.getStatus();
   return new Uint8Array(hash(
-    concatBuffers([Buffer.from(networkId), decode(transaction)]),
+    concatBuffers([Buffer.from(await onNode.getNetworkId()), decode(transaction)]),
   ));
 }

package/src/index.ts

@@ -24,19 +24,17 @@ export * from './tx/builder';
 export * from './tx/builder/helpers';
 export * from './tx/builder/constants';
 export * from './tx/builder/schema';
-export * from './tx/builder/address';
 export * from './utils/amount-formatter';
 export * from './utils/hd-wallet';
-export {
-  sha256hash, encode, decode, Encoding,
-} from './utils/encoder';
+export { encode, decode, Encoding } from './utils/encoder';
 export * from './aens';
-export * from './contract/methods';
+export { default as Contract } from './contract/Contract';
+export type { ContractMethodsBase } from './contract/Contract';
 export * from './oracle';
 export * from './spend';
 export * from './contract/ga';
-export * from './deprecated';
 
+export { default as AeSdkMethods } from './AeSdkMethods';
 export { default as AeSdkBase } from './AeSdkBase';
 export { default as AeSdk } from './AeSdk';
 export { default as AeSdkAepp } from './AeSdkAepp';
@@ -45,8 +43,11 @@ export { default as Node } from './Node';
 export { default as verifyTransaction } from './tx/validator';
 export { default as AccountBase } from './account/Base';
 export { default as MemoryAccount } from './account/Memory';
-export { default as Compiler } from './contract/Compiler';
-export { default as Channel } from './channel';
+export { default as AccountGeneralized } from './account/Generalized';
+export { default as AccountLedger } from './account/Ledger';
+export { default as AccountLedgerFactory } from './account/LedgerFactory';
+export { default as CompilerHttp } from './contract/CompilerHttp';
+export { default as Channel } from './channel/Contract';
 
 export { default as connectionProxy } from './aepp-wallet-communication/connection-proxy';
 export * from './aepp-wallet-communication/schema';

package/src/oracle.ts

@@ -40,7 +40,7 @@ import { RequestTimedOutError } from './utils/errors';
 import {
   decode, encode, Encoded, Encoding,
 } from './utils/encoder';
-import { _getPollInterval } from './chain';
+import { _getPollInterval, getHeight } from './chain';
 import { _buildTx, BuildTxOptions } from './tx';
 import Node from './Node';
 import AccountBase from './account/Base';
@@ -106,11 +106,11 @@ export async function pollForQueryResponse(
   let ttl;
   let response;
   do {
-    if (height != null) await pause(interval);
     ({ response, ttl } = await onNode.getOracleQueryByPubkeyAndQueryId(oracleId, queryId));
     const responseBuffer = decode(response as Encoded.OracleResponse);
     if (responseBuffer.length > 0) return responseBuffer.toString();
-    height = await this.getHeight();
+    await pause(interval);
+    height = await getHeight({ onNode });
   } while (ttl >= height);
   throw new RequestTimedOutError(height);
 }
@@ -169,7 +169,7 @@ export async function postQueryToOracle(
   options: PostQueryToOracleOptions,
 ): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getQueryObject>>> {
   options.queryFee ??= (await options.onNode.getOracleByPubkey(oracleId)).queryFee.toString();
-  const senderId = await options.onAccount.address(options);
+  const senderId = options.onAccount.address;
 
   const oracleQueryTx = await _buildTx(Tag.OracleQueryTx, {
     queryTtlType: QUERY_TTL.type,
@@ -219,7 +219,7 @@ export async function extendOracleTtl(
     oracleTtlType: ORACLE_TTL.type,
     oracleTtlValue: ORACLE_TTL.value,
     ...options,
-    callerId: await options.onAccount.address(options),
+    callerId: options.onAccount.address,
     oracleId,
   });
   return {
@@ -256,7 +256,7 @@ export async function respondToQuery(
     responseTtlType: RESPONSE_TTL.type,
     responseTtlValue: RESPONSE_TTL.value,
     ...options,
-    callerId: await options.onAccount.address(options),
+    callerId: options.onAccount.address,
     oracleId,
     queryId,
     response,
@@ -338,7 +338,7 @@ export async function registerOracle(
   responseFormat: string,
   options: RegisterOracleOptions,
 ): Promise<Awaited<ReturnType<typeof send>> & Awaited<ReturnType<typeof getOracleObject>>> {
-  const accountId = await options.onAccount.address(options);
+  const accountId = options.onAccount.address;
   const oracleRegisterTx = await _buildTx(Tag.OracleRegisterTx, {
     queryFee: QUERY_FEE,
     oracleTtlValue: ORACLE_TTL.value,

package/src/spend.ts

@@ -15,9 +15,7 @@
  *  PERFORMANCE OF THIS SOFTWARE.
  */
 import BigNumber from 'bignumber.js';
-import {
-  sendTransaction, getAccount, getBalance, resolveName,
-} from './chain';
+import { sendTransaction, getBalance, resolveName } from './chain';
 import { _buildTx, BuildTxOptions } from './tx';
 import { buildTxHash, unpackTx } from './tx/builder';
 import { ArgumentError } from './utils/errors';
@@ -38,15 +36,9 @@ export async function send(
   tx: Encoded.Transaction,
   options: SendOptions,
 ): Promise<SendReturnType> {
-  // TODO: detect authFun in AccountGa
-  const authFun = options.innerTx === true
-    ? undefined
-    : (await getAccount(await options.onAccount.address(options), options)).authFun;
-
   const signed = await options.onAccount.signTransaction(tx, {
     ...options,
-    authFun,
-    networkId: (await options.onNode.getStatus()).networkId,
+    networkId: await options.onNode.getNetworkId(),
   });
 
   return options.innerTx === true
@@ -75,7 +67,7 @@ export async function spend(
   return send(
     await _buildTx(Tag.SpendTx, {
       ...options,
-      senderId: await options.onAccount.address(options),
+      senderId: options.onAccount.address,
       recipientId: await resolveName<Encoding.AccountAddress>(
         recipientIdOrName,
         'account_pubkey',
@@ -113,7 +105,7 @@ export async function transferFunds(
     'account_pubkey',
     options,
   );
-  const senderId = await options.onAccount.address(options);
+  const senderId = options.onAccount.address;
   const balance = new BigNumber(
     await getBalance.bind(options.onAccount)(senderId, options),
   );
@@ -152,7 +144,7 @@ export async function payForTransaction(
   return send(
     await _buildTx(
       Tag.PayingForTx,
-      { ...options, payerId: await options.onAccount.address(options), tx: transaction },
+      { ...options, payerId: options.onAccount.address, tx: transaction },
     ),
     options,
   );

package/src/tx/builder/constants.ts

@@ -1,6 +1,7 @@
 import BigNumber from 'bignumber.js';
 import { mapObject } from '../../utils/other';
 
+export const MAX_AUTH_FUN_GAS = 50000;
 // # AENS
 export type AensName = `${string}.chain`;
 export const NAME_TTL = 180000;

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

@@ -0,0 +1,52 @@
+import { PrefixNotFoundError, TagNotFoundError } from '../../../utils/errors';
+import { toBytes } from '../../../utils/bytes';
+import { decode, encode, Encoding } from '../../../utils/encoder';
+import { isItemOfArray } from '../../../utils/other';
+
+/**
+ * Map of prefix to ID tag constant
+ * @see {@link https://github.com/aeternity/protocol/blob/master/serializations.md#the-id-type}
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_id.erl#L97-L102}
+ * @see {@link https://github.com/aeternity/aeserialization/blob/eb68fe331bd476910394966b7f5ede7a74d37e35/src/aeser_api_encoder.erl#L163-L168}
+ */
+const idTagToEncoding = [
+  Encoding.AccountAddress,
+  Encoding.Name,
+  Encoding.Commitment,
+  Encoding.OracleAddress,
+  Encoding.ContractAddress,
+  Encoding.Channel,
+] as const;
+
+export type AddressEncodings = typeof idTagToEncoding[number];
+
+export default function genAddressField<Encoding extends AddressEncodings>(): {
+  serialize: (value: `${Encoding}_${string}`) => Buffer;
+  deserialize: (value: Buffer) => `${Encoding}_${string}`;
+} {
+  return {
+    /**
+     * Utility function to create and _id type
+     * @param hashId - Encoded hash
+     * @returns Buffer Buffer with ID tag and decoded HASh
+     */
+    serialize(hashId) {
+      const encoding = hashId.slice(0, 2);
+      if (!isItemOfArray(encoding, idTagToEncoding)) throw new TagNotFoundError(encoding);
+      const idTag = idTagToEncoding.indexOf(encoding) + 1;
+      return Buffer.from([...toBytes(idTag), ...decode(hashId)]);
+    },
+
+    /**
+     * Utility function to read and _id type
+     * @param buf - Data
+     * @returns Encoded hash string with prefix
+     */
+    deserialize(buf) {
+      const idTag = Buffer.from(buf).readUIntBE(0, 1);
+      const encoding = idTagToEncoding[idTag - 1];
+      if (encoding == null) throw new PrefixNotFoundError(idTag);
+      return encode(buf.subarray(1), encoding) as `${Encoding}_${string}`;
+    },
+  };
+}

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

@@ -0,0 +1,18 @@
+import genAddressField, { AddressEncodings } from './address';
+
+export default function genAddressesField<Encoding extends AddressEncodings>(): {
+  serialize: (value: Array<`${Encoding}_${string}`>) => Buffer[];
+  deserialize: (value: Buffer[]) => Array<`${Encoding}_${string}`>;
+} {
+  const address = genAddressField<Encoding>();
+
+  return {
+    serialize(addresses) {
+      return addresses.map(address.serialize);
+    },
+
+    deserialize(addresses) {
+      return addresses.map(address.deserialize);
+    },
+  };
+}

package/src/tx/builder/field-types/coin-amount.ts

@@ -1,6 +1,5 @@
 import uInt, { Int } from './u-int';
 import { AE_AMOUNT_FORMATS, formatAmount } from '../../../utils/amount-formatter';
-import { ArgumentError } from '../../../utils/errors';
 
 export interface Options { denomination?: AE_AMOUNT_FORMATS }
 
@@ -8,11 +7,10 @@ export default {
   ...uInt,
 
   serializeAettos(value: string | undefined): string {
-    if (value == null) throw new ArgumentError('value', 'provided', value);
-    return value;
+    return value ?? '0';
   },
 
-  serializeOptional(value: Int | undefined, { denomination, ...options }: Options): Buffer {
+  serialize(value: Int | undefined, { denomination, ...options }: Options): Buffer {
     return uInt.serialize(
       this.serializeAettos(
         value != null ? formatAmount(value, { denomination }) : value,
@@ -20,8 +18,4 @@ export default {
       ),
     );
   },
-
-  serialize(value: Int, options: Options): Buffer {
-    return this.serializeOptional(value, options);
-  },
 };

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

@@ -0,0 +1,21 @@
+import { ArgumentError } from '../../../utils/errors';
+
+export default function genEnumerationField<Enum extends number>(): {
+  serialize: (value: Enum) => Buffer;
+  deserialize: (value: Buffer) => Enum;
+} {
+  return {
+    serialize(value) {
+      if (typeof value !== 'number') throw new ArgumentError('value', 'to be a number', value);
+      if (value > 0xff) throw new ArgumentError('value', 'to be less than 256', value);
+      return Buffer.from([value]);
+    },
+
+    deserialize(buffer) {
+      if (buffer.length !== 1) {
+        throw new ArgumentError('buffer', 'to have single element', buffer.length);
+      }
+      return buffer[0] as Enum;
+    },
+  };
+}

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

@@ -109,7 +109,7 @@ export function buildFee(txType: Tag, buildTx: any): BigNumber {
  * @param txType - Transaction type
  * @param rebuildTx - Callback to get built transaction with specific fee
  */
-export function calculateMinFee(
+function calculateMinFee(
   txType: Tag,
   rebuildTx: (value: BigNumber) => any,
 ): BigNumber {
@@ -138,6 +138,4 @@ export default {
     }
     return value.toFixed();
   },
-
-  serialize: coinAmount.serializeOptional,
 };

package/src/tx/builder/field-types/gas-limit.ts

@@ -1,5 +1,5 @@
 import { IllegalArgumentError } from '../../../utils/errors';
-import { MIN_GAS_PRICE, Tag } from '../constants';
+import { MIN_GAS_PRICE, Tag, MAX_AUTH_FUN_GAS } from '../constants';
 import shortUInt from './short-u-int';
 import { buildFee } from './fee';
 
@@ -27,7 +27,7 @@ export default {
   ): Buffer {
     if (_computingGasLimit != null) return shortUInt.serialize(_computingGasLimit);
 
-    const gasLimitMax = calculateGasLimitMax(
+    const gasLimitMax = txType === Tag.GaMetaTx ? MAX_AUTH_FUN_GAS : calculateGasLimitMax(
       txType,
       gasMax,
       (gasLimit) => rebuildTx({ _computingGasLimit: gasLimit }),

package/src/tx/builder/field-types/gas-price.ts

@@ -11,6 +11,4 @@ export default {
     }
     return value;
   },
-
-  serialize: coinAmount.serializeOptional,
 };

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

@@ -2,44 +2,54 @@ import _field from './field';
 import _uInt from './u-int';
 import _shortUInt from './short-u-int';
 import _coinAmount from './coin-amount';
-
+import _address from './address';
+import _addresses from './addresses';
 import _deposit from './deposit';
+import _enumeration from './enumeration';
 import _fee from './fee';
 import _gasLimit from './gas-limit';
 import _gasPrice from './gas-price';
 import _name from './name';
 import _nameFee from './name-fee';
 import _nameId from './name-id';
+import _pointers from './pointers';
 
 // TODO: remove after fixing https://github.com/Gerrit0/typedoc-plugin-missing-exports/issues/15
 const field = _field;
 const uInt = _uInt;
 const shortUInt = _shortUInt;
 const coinAmount = _coinAmount;
-
+const address = _address;
+const addresses = _addresses;
 const deposit = _deposit;
+const enumeration = _enumeration;
 const fee = _fee;
 const gasLimit = _gasLimit;
 const gasPrice = _gasPrice;
 const name = _name;
 const nameFee = _nameFee;
 const nameId = _nameId;
+const pointers = _pointers;
 
-export type Field = typeof field | typeof uInt | typeof shortUInt | typeof coinAmount
-  | typeof deposit | typeof fee | typeof gasLimit | typeof gasPrice | typeof name | typeof nameFee
-  | typeof nameId;
+export interface Field {
+  serialize: (value: any, options: any) => Buffer | Buffer[] | Buffer[][];
+  deserialize: (value: Buffer | Buffer[] | Buffer[][]) => any;
+}
 
 export {
   field,
   uInt,
   shortUInt,
   coinAmount,
-
+  address,
+  addresses,
   deposit,
+  enumeration,
   fee,
   gasLimit,
   gasPrice,
   name,
   nameFee,
   nameId,
+  pointers,
 };

package/src/tx/builder/field-types/name-fee.ts

@@ -27,6 +27,6 @@ export default {
     value: Int | undefined,
     txFields: { name: AensName } & Parameters<typeof coinAmount['serialize']>[1],
   ): Buffer {
-    return coinAmount.serializeOptional.call(this, value, txFields);
+    return coinAmount.serialize.call(this, value, txFields);
   },
 };

package/src/tx/builder/field-types/name-id.ts

@@ -1,20 +1,17 @@
 import { AensName } from '../constants';
 import { produceNameId, isNameValid } from '../helpers';
-import { writeId, readId } from '../address';
-import { Encoded } from '../../../utils/encoder';
+import address from './address';
+import { Encoded, Encoding } from '../../../utils/encoder';
+
+const addressName = address<Encoding.Name>();
 
 export default {
+  ...addressName,
+
   /**
    * @param value - AENS name ID
    */
   serialize(value: AensName | Encoded.Name): Buffer {
-    return writeId(isNameValid(value) ? produceNameId(value) : value);
-  },
-
-  /**
-   * @param value - AENS name ID Buffer
-   */
-  deserialize(value: Buffer): Encoded.Name {
-    return readId(value) as Encoded.Name;
+    return addressName.serialize(isNameValid(value) ? produceNameId(value) : value);
   },
 };

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

@@ -0,0 +1,41 @@
+import { NamePointer as NamePointerString } from '../../../apis/node';
+import { toBytes } from '../../../utils/bytes';
+import { Encoded } from '../../../utils/encoder';
+import { IllegalArgumentError } from '../../../utils/errors';
+import address, { AddressEncodings } from './address';
+
+const addressAny = address<AddressEncodings>();
+
+// TODO: remove after fixing node types
+type NamePointer = NamePointerString & {
+  id: Encoded.Generic<AddressEncodings>;
+};
+
+export default {
+  /**
+   * Helper function to build pointers for name update TX
+   * @param pointers - Array of pointers
+   * `([ { key: 'account_pubkey', id: 'ak_32klj5j23k23j5423l434l2j3423'} ])`
+   * @returns Serialized pointers array
+   */
+  serialize(pointers: NamePointer[]): Buffer[][] {
+    if (pointers.length > 32) {
+      throw new IllegalArgumentError(`Expected 32 pointers or less, got ${pointers.length} instead`);
+    }
+
+    return pointers.map(
+      (pointer) => [toBytes(pointer.key), addressAny.serialize(pointer.id)],
+    );
+  },
+
+  /**
+   * Helper function to read pointers from name update TX
+   * @param pointers - Array of pointers
+   * @returns Deserialize pointer array
+   */
+  deserialize(pointers: Array<[key: Buffer, id: Buffer]>): NamePointer[] {
+    return pointers.map(
+      ([key, id]) => ({ key: key.toString(), id: addressAny.deserialize(id) }),
+    );
+  },
+};

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

@@ -1,13 +1,14 @@
 import BigNumber from 'bignumber.js';
-import { readInt, writeInt } from '../helpers';
+import { readInt } from '../helpers';
 import { ArgumentError } from '../../../utils/errors';
+import { toBytes } from '../../../utils/bytes';
 
 export type Int = number | string | BigNumber;
 
 export default {
   serialize(value: Int): Buffer {
     if (value < 0) throw new ArgumentError('value', 'greater or equal to 0', value);
-    return writeInt(value);
+    return toBytes(value, true);
   },
 
   deserialize(value: Buffer): string {