Merge branch 'feat/next' into token-management-tx-parser

src/account.ts

@@ -8,7 +8,7 @@ export class Account {
  /**
  * The address of the account.
  */
- readonly address: IAddress = new Address();
+ readonly address: IAddress = Address.empty();
 
  /**
  * The nonce of the account (the account sequence number).

src/address.spec.ts

@@ -17,7 +17,7 @@ describe("test address", () => {
  });
 
  it("should create empty address", async () => {
- let nobody = new Address();
+ const nobody = Address.empty();
 
  assert.isEmpty(nobody.hex());
  assert.isEmpty(nobody.bech32());
@@ -55,4 +55,16 @@ describe("test address", () => {
  assert.isFalse(Address.isValid("xerd1l453hd0gt5gzdp7czpuall8ggt2dcv5zwmfdf3sd3lguxseux2fsmsgldz"));
  assert.isFalse(Address.isValid("erd1l453hd0gt5gzdp7czpuall8ggt2dcv5zwmfdf3sd3lguxseux2"));
  });
+
+ it("should check whether isSmartContract", () => {
+ assert.isFalse(
+ Address.fromBech32("erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th").isSmartContract(),
+ );
+ assert.isTrue(
+ Address.fromBech32("erd1qqqqqqqqqqqqqqqpqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqplllst77y4l").isSmartContract(),
+ );
+ assert.isTrue(
+ Address.fromBech32("erd1qqqqqqqqqqqqqpgqxwakt2g7u9atsnr03gqcgmhcv38pt7mkd94q6shuwt").isSmartContract(),
+ );
+ });
 });

src/address.ts

@@ -23,7 +23,7 @@ export class Address {
  /**
  * Creates an address object, given a raw string (whether a hex pubkey or a Bech32 address), a sequence of bytes, or another Address object.
  */
- public constructor(value?: Address | Buffer | string) {
+ public constructor(value: Address | Buffer | string) {
  if (!value) {
  return;
  }
@@ -48,7 +48,7 @@ export class Address {
  }
 
  private static fromValidHex(value: string): Address {
- let result = new Address();
+ let result = Address.empty();
  result.valueHex = value;
  return result;
  }
@@ -91,10 +91,11 @@ export class Address {
  }
 
  /**
- * Creates an empty address object
+ * Creates an empty address object.
+ * Generally speaking, this should not be used by client code (internal use only).
  */
  static empty(): Address {
- return new Address();
+ return new Address("");
  }
 
  /**
@@ -109,12 +110,12 @@ export class Address {
  throw new errors.ErrAddressCannotCreate(value, err);
  }
 
- let prefix = decoded.prefix;
+ const prefix = decoded.prefix;
  if (prefix != HRP) {
  throw new errors.ErrAddressBadHrp(HRP, prefix);
  }
 
- let pubkey = Buffer.from(bech32.fromWords(decoded.words));
+ const pubkey = Buffer.from(bech32.fromWords(decoded.words));
  if (pubkey.length != PUBKEY_LENGTH) {
  throw new errors.ErrAddressCannotCreate(value);
  }
@@ -138,9 +139,16 @@ export class Address {
  }
 
  /**
- * Returns the hex representation of the address (pubkey)
+ * Use {@link toHex} instead.
  */
  hex(): string {
+ return this.toHex();
+ }
+
+ /**
+ * Returns the hex representation of the address (pubkey)
+ */
+ toHex(): string {
  if (this.isEmpty()) {
  return "";
  }
@@ -149,9 +157,16 @@ export class Address {
  }
 
  /**
- * Returns the bech32 representation of the address
+ * Use {@link toBech32} instead.
  */
  bech32(): string {
+ return this.toBech32();
+ }
+
+ /**
+ * Returns the bech32 representation of the address
+ */
+ toBech32(): string {
  if (this.isEmpty()) {
  return "";
  }
@@ -162,16 +177,31 @@ export class Address {
  }
 
  /**
- * Returns the pubkey as raw bytes (buffer)
+ * Use {@link getPublicKey} instead.
  */
  pubkey(): Buffer {
+ return this.getPublicKey();
+ }
+
+ /**
+ * Returns the pubkey as raw bytes (buffer)
+ */
+ getPublicKey(): Buffer {
  if (this.isEmpty()) {
  return Buffer.from([]);
  }
 
  return Buffer.from(this.valueHex, "hex");
  }
 
+ /**
+ * Returns the human-readable-part of the bech32 addresses.
+ * The HRP is currently hardcoded to "erd".
+ */
+ getHrp(): string {
+ return HRP;
+ }
+
  /**
  * Returns whether the address is empty.
  */
@@ -194,27 +224,38 @@ export class Address {
  * Returns the bech32 representation of the address
  */
  toString(): string {
- return this.bech32();
+ return this.toBech32();
  }
 
  /**
  * Converts the address to a pretty, plain JavaScript object.
  */
  toJSON(): object {
  return {
- bech32: this.bech32(),
- pubkey: this.hex(),
+ bech32: this.toBech32(),
+ pubkey: this.toHex(),
  };
  }
 
  /**
- * Creates the Zero address (the one that should be used when deploying smart contracts)
+ * Creates the Zero address (the one that should be used when deploying smart contracts).
+ * Generally speaking, this should not be used by client code (internal use only).
  */
  static Zero(): Address {
  return new Address("0".repeat(64));
  }
 
+ /**
+ * Use {@link isSmartContract} instead.
+ */
  isContractAddress(): boolean {
- return this.hex().startsWith(SMART_CONTRACT_HEX_PUBKEY_PREFIX);
+ return this.isSmartContract();
+ }
+
+ /**
+ * Returns whether the address is a smart contract address.
+ */
+ isSmartContract(): boolean {
+ return this.toHex().startsWith(SMART_CONTRACT_HEX_PUBKEY_PREFIX);
  }
 }

src/compatibility.ts

@@ -1,26 +1,21 @@
 import { Address } from "./address";
+import { Err } from "./errors";
 import { IAddress } from "./interface";
 
 /**
  * For internal use only.
  */
 export class Compatibility {
- static areWarningsEnabled: boolean = true;
-
  /**
  * For internal use only.
  */
  static guardAddressIsSetAndNonZero(address: IAddress | undefined, context: string, resolution: string) {
- if (!this.areWarningsEnabled) {
- return;
- }
-
  if (!address || address.bech32() == "") {
- console.warn(
+ throw new Err(
  `${context}: address should be set; ${resolution}. In the future, this will throw an exception instead of emitting a WARN.`,
  );
  } else if (address.bech32() == Address.Zero().bech32()) {
- console.warn(
+ throw new Err(
  `${context}: address should not be the 'zero' address (also known as the 'contracts deployment address'); ${resolution}. In the future, this will throw an exception instead of emitting a WARN.`,
  );
  }

src/constants.ts

@@ -14,3 +14,5 @@ export const CONTRACT_DEPLOY_ADDRESS = "erd1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq
 export const DELEGATION_MANAGER_SC_ADDRESS = "erd1qqqqqqqqqqqqqqqpqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqylllslmq6y6";
 export const DEFAULT_HRP = "erd";
 export const ESDT_CONTRACT_ADDRESS = "erd1qqqqqqqqqqqqqqqpqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqzllls8a5w6u";
+export const DEFAULT_MESSAGE_VERSION = 1;
+export const MESSAGE_PREFIX = "\x17Elrond Signed Message:\n";

src/interface.ts

@@ -26,16 +26,45 @@ export interface IPlainTransactionObject {
  guardianSignature?: string;
 }
 
-export interface ISignature { hex(): string; }
-export interface IAddress { bech32(): string; }
-export interface ITransactionValue { toString(): string; }
-export interface IAccountBalance { toString(): string; }
-export interface INonce { valueOf(): number; }
-export interface IChainID { valueOf(): string; }
-export interface IGasLimit { valueOf(): number; }
-export interface IGasPrice { valueOf(): number; }
-export interface ITransactionVersion { valueOf(): number; }
-export interface ITransactionOptions { valueOf(): number; }
+export interface ISignature {
+ hex(): string;
+}
+
+export interface IAddress {
+ bech32(): string;
+}
+
+export interface ITransactionValue {
+ toString(): string;
+}
+
+export interface IAccountBalance {
+ toString(): string;
+}
+
+export interface INonce {
+ valueOf(): number;
+}
+
+export interface IChainID {
+ valueOf(): string;
+}
+
+export interface IGasLimit {
+ valueOf(): number;
+}
+
+export interface IGasPrice {
+ valueOf(): number;
+}
+
+export interface ITransactionVersion {
+ valueOf(): number;
+}
+
+export interface ITransactionOptions {
+ valueOf(): number;
+}
 
 export interface ITransactionPayload {
  length(): number;
@@ -59,17 +88,17 @@ export type ITokenPayment = ITokenTransfer;
 export interface ITransactionNext {
  sender: string;
  receiver: string;
- gasLimit: BigNumber.Value;
+ gasLimit: bigint;
  chainID: string;
- nonce: BigNumber.Value;
- value: BigNumber.Value;
+ nonce: bigint;
+ value: bigint;
  senderUsername: string;
  receiverUsername: string;
- gasPrice: BigNumber.Value;
+ gasPrice: bigint;
  data: Uint8Array;
  version: number;
  options: number;
  guardian: string;
  signature: Uint8Array;
  guardianSignature: Uint8Array;
- }
+}

src/message.spec.ts

@@ -0,0 +1,87 @@
+import { assert } from "chai";
+import { Message, MessageComputer } from "./message";
+import { loadTestWallets, TestWallet } from "./testutils";
+import { UserVerifier } from "@multiversx/sdk-wallet";
+import { DEFAULT_MESSAGE_VERSION } from "./constants";
+
+describe("test message", () => {
+ let alice: TestWallet;
+ const messageComputer = new MessageComputer();
+
+ before(async function () {
+ ({ alice } = await loadTestWallets());
+ });
+
+ it("should test message compute bytes for signing", async () => {
+ const data = Buffer.from("test message");
+
+ const message = new Message({
+ data: data,
+ });
+
+ const serialized = messageComputer.computeBytesForSigning(message);
+
+ assert.equal(
+ Buffer.from(serialized).toString("hex"),
+ "2162d6271208429e6d3e664139e98ba7c5f1870906fb113e8903b1d3f531004d",
+ );
+ });
+
+ it("should create, sign, pack, unpack and verify message", async () => {
+ const data = Buffer.from("test");
+
+ const message = new Message({
+ data: data,
+ address: alice.getAddress(),
+ });
+
+ message.signature = await alice.signer.sign(Buffer.from(messageComputer.computeBytesForSigning(message)));
+
+ assert.equal(
+ Buffer.from(message.signature).toString("hex"),
+ "7aff43cd6e3d880a65033bf0a1b16274854fd7dfa9fe5faa7fa9a665ee851afd4c449310f5f1697d348e42d1819eaef69080e33e7652d7393521ed50d7427a0e",
+ );
+
+ const packedMessage = messageComputer.packMessage(message);
+ assert.deepEqual(packedMessage, {
+ address: "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th",
+ message: "74657374",
+ signature:
+ "7aff43cd6e3d880a65033bf0a1b16274854fd7dfa9fe5faa7fa9a665ee851afd4c449310f5f1697d348e42d1819eaef69080e33e7652d7393521ed50d7427a0e",
+ version: 1,
+ });
+
+ const unpackedMessage = messageComputer.unpackMessage(packedMessage);
+ assert.deepEqual(unpackedMessage.address, alice.getAddress());
+ assert.deepEqual(unpackedMessage.data, message.data);
+ assert.deepEqual(unpackedMessage.signature, message.signature);
+ assert.deepEqual(unpackedMessage.version, message.version);
+
+ const verifier = UserVerifier.fromAddress(alice.getAddress());
+ const isValid = verifier.verify(
+ Buffer.from(messageComputer.computeBytesForVerifying(unpackedMessage)),
+ Buffer.from(unpackedMessage.signature!),
+ );
+ assert.equal(isValid, true);
+ });
+
+ it("should unpack legacy message", async () => {
+ const legacyMessage = {
+ address: "erd1qyu5wthldzr8wx5c9ucg8kjagg0jfs53s8nr3zpz3hypefsdd8ssycr6th",
+ message: "0x7468697320697320612074657374206d657373616765",
+ signature:
+ "0xb16847437049986f936dd4a0917c869730cbf29e40a0c0821ca70db33f44758c3d41bcbea446dee70dea13d50942343bb78e74979dc434bbb2b901e0f4fd1809",
+ version: 1,
+ signer: "ErdJS",
+ };
+
+ const message = messageComputer.unpackMessage(legacyMessage);
+ assert.deepEqual(message.address, alice.getAddress());
+ assert.deepEqual(Buffer.from(message.data).toString(), "this is a test message");
+ assert.deepEqual(
+ Buffer.from(message.signature!).toString("hex"),
+ "b16847437049986f936dd4a0917c869730cbf29e40a0c0821ca70db33f44758c3d41bcbea446dee70dea13d50942343bb78e74979dc434bbb2b901e0f4fd1809",
+ );
+ assert.deepEqual(message.version, DEFAULT_MESSAGE_VERSION);
+ });
+});