@arkecosystem/typescript-crypto 0.0.5 → 0.0.6

package/dist/identities/Address.js

@@ -1,7 +1,7 @@
-import { ethers, sha256 } from "ethers";
+import { ethers, sha256, toUtf8Bytes } from "ethers";
 export class Address {
     static fromPassphrase(passphrase) {
-        return this.fromPrivateKey(sha256(Buffer.from(passphrase)));
+        return this.fromPrivateKey(sha256(toUtf8Bytes(passphrase)));
     }
     static fromPublicKey(publicKey) {
         return ethers.computeAddress(`0x${publicKey}`);

package/dist/identities/PrivateKey.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PrivateKey.d.ts","sourceRoot":"","sources":["../../src/identities/PrivateKey.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAqB,MAAM,QAAQ,CAAC;AAMnD,UAAU,oBAAoB;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,qBAAa,UAAU;IACf,UAAU,EAAE,MAAM,CAAC;gBAEd,OAAO,EAAE,MAAM,CAAC,MAAM;IAIlC,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU;IAIrD,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU;IAMvC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU;IAMjC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAW1D"}
+{"version":3,"file":"PrivateKey.d.ts","sourceRoot":"","sources":["../../src/identities/PrivateKey.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,MAAM,EAAkC,MAAM,QAAQ,CAAC;AAMhE,UAAU,oBAAoB;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACV;AAED,qBAAa,UAAU;IACf,UAAU,EAAE,MAAM,CAAC;gBAEd,OAAO,EAAE,MAAM,CAAC,MAAM;IAIlC,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU;IAIrD,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU;IAMvC,MAAM,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU;IAMjC,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAW1D"}

package/dist/identities/PrivateKey.js

@@ -8,7 +8,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import * as WIF from "wif";
-import { ethers, keccak256, sha256 } from "ethers";
+import { ethers, keccak256, sha256, toUtf8Bytes } from "ethers";
 import { signAsync } from "@noble/secp256k1";
 import { Constants } from "@/enums/Constants";
 import { Network } from "@/configuration/Network";
@@ -17,7 +17,7 @@ export class PrivateKey {
         this.privateKey = keyPair.privateKey.substring(2);
     }
     static fromPassphrase(passphrase) {
-        return PrivateKey.fromHex(sha256(Buffer.from(passphrase)));
+        return PrivateKey.fromHex(sha256(toUtf8Bytes(passphrase)));
     }
     static fromHex(hex) {
         const wallet = new ethers.Wallet(hex);

package/dist/identities/PublicKey.js

@@ -1,11 +1,11 @@
-import { sha256, SigningKey } from "ethers";
+import { sha256, SigningKey, toUtf8Bytes } from "ethers";
 import { Signature } from "@noble/secp256k1";
 export class PublicKey {
     constructor(publicKey) {
         this.publicKey = publicKey;
     }
     static fromPassphrase(passphrase) {
-        const publicKey = SigningKey.computePublicKey(sha256(Buffer.from(passphrase)), true).substring(2);
+        const publicKey = SigningKey.computePublicKey(sha256(toUtf8Bytes(passphrase)), true).substring(2);
         return new PublicKey(publicKey);
     }
     static fromHex(publicKey) {

package/dist/index.js

@@ -22691,7 +22691,7 @@ var wordlists = {
 // src/identities/Address.ts
 var Address = class {
   static fromPassphrase(passphrase) {
-    return this.fromPrivateKey(sha2562(Buffer.from(passphrase)));
+    return this.fromPrivateKey(sha2562(toUtf8Bytes(passphrase)));
   }
   static fromPublicKey(publicKey) {
     return ethers_exports.computeAddress(`0x${publicKey}`);
@@ -23509,7 +23509,7 @@ var PrivateKey = class _PrivateKey {
     this.privateKey = keyPair.privateKey.substring(2);
   }
   static fromPassphrase(passphrase) {
-    return _PrivateKey.fromHex(sha2562(Buffer.from(passphrase)));
+    return _PrivateKey.fromHex(sha2562(toUtf8Bytes(passphrase)));
   }
   static fromHex(hex) {
     const wallet = new ethers_exports.Wallet(hex);
@@ -23536,7 +23536,7 @@ var PublicKey = class _PublicKey {
     this.publicKey = publicKey;
   }
   static fromPassphrase(passphrase) {
-    const publicKey = SigningKey.computePublicKey(sha2562(Buffer.from(passphrase)), true).substring(2);
+    const publicKey = SigningKey.computePublicKey(sha2562(toUtf8Bytes(passphrase)), true).substring(2);
     return new _PublicKey(publicKey);
   }
   static fromHex(publicKey) {
@@ -27809,7 +27809,7 @@ var AbiBase = class {
     const abi = this.contractAbi(type, customAbi);
     this.interface = new Interface(JSON.parse(JSON.stringify(abi)).abi);
   }
-  contractAbi(type = "consensus" /* CONSENSUS */, customAbi) {
+  contractAbi(type, customAbi) {
     switch (type) {
       case "consensus" /* CONSENSUS */:
         return Abi_Consensus_default;

package/dist/utils/AbiBase.d.ts

@@ -2,7 +2,7 @@ import { ContractAbiType } from "@/enums/ContractAbiType";
 import { Interface } from "ethers";
 export declare abstract class AbiBase {
     protected interface: Interface;
-    constructor(type?: ContractAbiType, customAbi?: string);
+    constructor(type?: ContractAbiType, customAbi?: object);
     private contractAbi;
 }
 //# sourceMappingURL=AbiBase.d.ts.map

package/dist/utils/AbiBase.js

@@ -8,7 +8,7 @@ export class AbiBase {
         const abi = this.contractAbi(type, customAbi);
         this.interface = new Interface(JSON.parse(JSON.stringify(abi)).abi);
     }
-    contractAbi(type = ContractAbiType.CONSENSUS, customAbi) {
+    contractAbi(type, customAbi) {
         switch (type) {
             case ContractAbiType.CONSENSUS:
                 return ConsensusContract;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkecosystem/typescript-crypto",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "engines": {
     "node": ">=20.12.2"
   },

package/src/identities/Address.ts

@@ -1,8 +1,8 @@
-import { ethers, sha256 } from "ethers";
+import { ethers, sha256, toUtf8Bytes } from "ethers";
 
 export class Address {
 	static fromPassphrase(passphrase: string): string {
-		return this.fromPrivateKey(sha256(Buffer.from(passphrase)));
+		return this.fromPrivateKey(sha256(toUtf8Bytes(passphrase)));
 	}
 
 	static fromPublicKey(publicKey: string): string {

package/src/identities/PrivateKey.ts

@@ -1,6 +1,6 @@
 import * as WIF from "wif";
 
-import { ethers, keccak256, sha256 } from "ethers";
+import { ethers, keccak256, sha256, toUtf8Bytes } from "ethers";
 import { signAsync } from "@noble/secp256k1";
 
 import { Constants } from "@/enums/Constants";
@@ -20,7 +20,7 @@ export class PrivateKey {
 	}
 
 	static fromPassphrase(passphrase: string): PrivateKey {
-		return PrivateKey.fromHex(sha256(Buffer.from(passphrase)));
+		return PrivateKey.fromHex(sha256(toUtf8Bytes(passphrase)));
 	}
 
 	static fromHex(hex: string): PrivateKey {

package/src/identities/PublicKey.ts

@@ -1,4 +1,4 @@
-import { sha256, SigningKey } from "ethers";
+import { sha256, SigningKey, toUtf8Bytes } from "ethers";
 import { Signature } from "@noble/secp256k1";
 
 export class PublicKey {
@@ -9,7 +9,7 @@ export class PublicKey {
 	}
 
 	static fromPassphrase(passphrase: string): PublicKey {
-		const publicKey = SigningKey.computePublicKey(sha256(Buffer.from(passphrase)), true).substring(2);
+		const publicKey = SigningKey.computePublicKey(sha256(toUtf8Bytes(passphrase)), true).substring(2);
 
 		return new PublicKey(publicKey);
 	}

package/src/utils/AbiBase.ts

@@ -7,13 +7,13 @@ import UsernamesContract from "./Abi/json/Abi.Usernames.json";
 export abstract class AbiBase {
 	protected interface: Interface;
 
-	constructor(type: ContractAbiType = ContractAbiType.CONSENSUS, customAbi?: string) {
+	constructor(type: ContractAbiType = ContractAbiType.CONSENSUS, customAbi?: object) {
 		const abi = this.contractAbi(type, customAbi);
 
 		this.interface = new Interface(JSON.parse(JSON.stringify(abi)).abi);
 	}
 
-	private contractAbi(type: ContractAbiType = ContractAbiType.CONSENSUS, customAbi?: unknown): object {
+	private contractAbi(type: ContractAbiType, customAbi?: object): object {
 		switch (type) {
 			case ContractAbiType.CONSENSUS:
 				return ConsensusContract;

package/tests/unit/utils/AbiDecoder.test.ts

@@ -1,5 +1,6 @@
 import { AbiDecoder } from "@/utils/AbiDecoder";
 import { ContractAbiType } from "@/enums/ContractAbiType";
+import MultipaymentAbi from "@/utils/Abi/json/Abi.Multipayment.json";
 
 it("should decode a vote function call", () => {
 	const decoder = new AbiDecoder();
@@ -23,8 +24,13 @@ it("should decode an unvote function call", () => {
 	expect(decodedData.args).toEqual([]);
 });
 
-it("should decode a multipayment function call", () => {
-	const decoder = new AbiDecoder(ContractAbiType.MULTIPAYMENT);
+it("should throw an error if custom abi is not passed", () => {
+	expect(() => new AbiDecoder(ContractAbiType.CUSTOM)).toThrow("Invalid contract type");
+});
+
+// We'll re-use the multipayment contract for this test
+it("should decode using a custom abi", () => {
+	const decoder = new AbiDecoder(ContractAbiType.CUSTOM, MultipaymentAbi);
 
 	const args = [
 		["0xb693449AdDa7EFc015D87944EAE8b7C37EB1690A", "0xb693449AdDa7EFc015D87944EAE8b7C37EB1690A"],
@@ -38,7 +44,3 @@ it("should decode a multipayment function call", () => {
 	expect(decodedData.args[0]).toEqual(args[0]);
 	expect(decodedData.args[1].map((value: BigInt) => value.toString())).toEqual(args[1]);
 });
-
-it("should throw an error if custom abi is not passed", () => {
-	expect(() => new AbiDecoder(ContractAbiType.CUSTOM)).toThrow("Invalid contract type");
-});

package/tests/unit/utils/AbiEncoder.test.ts

@@ -1,5 +1,6 @@
 import { AbiEncoder } from "@/utils/AbiEncoder";
 import { ContractAbiType } from "@/enums/ContractAbiType";
+import MultipaymentAbi from "@/utils/Abi/json/Abi.Multipayment.json";
 
 it("should encode a vote function call", () => {
 	const encoder = new AbiEncoder();
@@ -28,3 +29,20 @@ it("should encode a multipayment function call", () => {
 
 	expect(encodedData).toBe(expectedEncodedData);
 });
+
+// We'll re-use the multipayment contract for this test
+it("should encode using a custom abi", () => {
+	const encoder = new AbiEncoder(ContractAbiType.CUSTOM, MultipaymentAbi);
+
+	const functionName = "pay";
+	const args = [
+		["0xb693449AdDa7EFc015D87944EAE8b7C37EB1690A", "0xb693449AdDa7EFc015D87944EAE8b7C37EB1690A"],
+		["100000000", "200000000"],
+	];
+	const expectedEncodedData =
+		"084ce708000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000b693449adda7efc015d87944eae8b7c37eb1690a000000000000000000000000b693449adda7efc015d87944eae8b7c37eb1690a00000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000005f5e100000000000000000000000000000000000000000000000000000000000bebc200";
+
+	const encodedData = encoder.encodeFunctionCall(functionName, args);
+
+	expect(encodedData).toBe(expectedEncodedData);
+});

package/tests/unit/utils/TransactionUtils.test.ts

@@ -1,5 +1,4 @@
 import fixture from "@tests/fixtures/transactions/transfer.json";
-
 import { TransactionUtils } from "@/utils/TransactionUtils";
 
 it("should convert a transaction to a buffer with a signature", () => {
@@ -15,6 +14,34 @@ it("should convert a transaction to a buffer without a signature", () => {
 	expect(buffer).toBeInstanceOf(Buffer);
 });
 
+it("should convert a transaction to a buffer using fallback values if missing", () => {
+	const result = TransactionUtils.toBuffer({
+		network: undefined,
+		nonce: undefined,
+		gasPrice: undefined,
+		gasLimit: undefined,
+		recipientAddress: undefined,
+		value: undefined,
+		data: undefined,
+	}).toString("hex");
+
+	expect(result).toEqual("02c98080808080808080c0");
+});
+
+it("should convert a transaction to a buffer handling data starting with 0x", () => {
+	const result = TransactionUtils.toBuffer({
+		network: undefined,
+		nonce: undefined,
+		gasPrice: undefined,
+		gasLimit: undefined,
+		recipientAddress: undefined,
+		value: undefined,
+		data: "0x1234567890",
+	}).toString("hex");
+
+	expect(result).toEqual("02ce80808080808080851234567890c0");
+});
+
 it("should convert a transaction to a hash with a signature", () => {
 	expect(TransactionUtils.toHash(fixture.data)).toBe(fixture.data.hash);
 });

package/tests/unit/utils/UnitConverter.test.ts

@@ -35,7 +35,7 @@ it.each([
 	[1000, "1000000000000000000000"],
 	[10000, "10000000000000000000000"],
 ])("should parse units into ark [%s]", (amount, formattedAmount) => {
-	const arkValue = UnitConverter.parseUnits(amount, "ark");
+	const arkValue = UnitConverter.parseUnits(amount);
 
 	expect(arkValue.toFixed()).toEqual(formattedAmount);
 });
@@ -71,7 +71,7 @@ it.each([
 	["1000000000000000000000", 1000],
 	["10000000000000000000000", 10000],
 ])("should format units from ark [%s]", (formattedAmount, amount) => {
-	const formattedValue = UnitConverter.formatUnits(formattedAmount, "ark");
+	const formattedValue = UnitConverter.formatUnits(formattedAmount);
 
 	expect(formattedValue).toEqual(amount);
 });