@sravankumar02/sdk-core 1.0.0

package/out/accounts/account.d.ts

@@ -0,0 +1,94 @@
+/// <reference types="node" />
+import { PathLike } from "fs";
+import { Address, IAccount, Message, Transaction } from "../core";
+import { KeyPair, UserPublicKey, UserSecretKey } from "../wallet";
+/**
+ * An abstraction representing an account (user or Smart Contract) on the Network.
+ */
+export declare class Account implements IAccount {
+    /**
+     * The address of the account.
+     */
+    readonly address: Address;
+    /**
+     * Local copy of the account nonce.
+     * Must be explicitly managed by client code.
+     */
+    nonce: bigint;
+    /**
+     * The secret key of the account.
+     */
+    readonly secretKey: UserSecretKey;
+    /**
+     * The public key of the account.
+     */
+    readonly publicKey: UserPublicKey;
+    /**
+     * Creates an account object from a secret key
+     */
+    constructor(secretKey: UserSecretKey, hrp?: string);
+    /**
+     * Named constructor
+     * Loads a secret key from a PEM file. PEM files may contain multiple accounts - thus, an (optional) "index" is used to select the desired secret key.
+     * Returns an Account object, initialized with the secret key.
+     */
+    static newFromPem(path: PathLike, index?: number, hrp?: string): Promise<Account>;
+    /**
+     * Named constructor
+     * Loads a secret key from an encrypted keystore file. Handles both keystores that hold a mnemonic and ones that hold a secret key (legacy).
+     * For keystores that hold an encrypted mnemonic, the optional "addressIndex" parameter is used to derive the desired secret key.
+     * Returns an Account object, initialized with the secret key.
+     */
+    static newFromKeystore(filePath: string, password: string, addressIndex?: number, hrp?: string): Account;
+    /**
+     * Named constructor
+     * Loads (derives) a secret key from a mnemonic. The optional "addressIndex" parameter is used to guide the derivation.
+     * Returns an Account object, initialized with the secret key.
+     */
+    static newFromMnemonic(mnemonic: string, addressIndex?: number, hrp?: string): Account;
+    /**
+     * Named constructor
+     * Returns an Account object, initialized with the secret key.
+     */
+    static newFromKeypair(keypair: KeyPair, hrp?: string): Account;
+    /**
+     * Increments (locally) the nonce (the account sequence number).
+     */
+    incrementNonce(): void;
+    /**
+     * Signs using the secret key of the account.
+     */
+    sign(data: Uint8Array): Promise<Uint8Array>;
+    /**
+     * Verifies the signature using the public key of the account.
+     */
+    verify(data: Uint8Array, signature: Uint8Array): Promise<boolean>;
+    /**
+     * Serializes the transaction, computes the signature and returns it.
+     */
+    signTransaction(transaction: Transaction): Promise<Uint8Array>;
+    /**
+     * Verifies the transaction signature using the public key of the account.
+     */
+    verifyTransactionSignature(transaction: Transaction, signature: Uint8Array): Promise<boolean>;
+    /**
+     * Serializes the message, computes the signature and returns it.
+     */
+    signMessage(message: Message): Promise<Uint8Array>;
+    /**
+     * Verifies the message signature using the public key of the account.
+     */
+    verifyMessageSignature(message: Message, signature: Uint8Array): Promise<boolean>;
+    /**
+     * Gets the nonce (the one from the object's state) and increments it.
+     */
+    getNonceThenIncrement(): bigint;
+    /**
+     * Saves the wallet to a pem file
+     */
+    saveToPem(path: string): void;
+    /**
+     * Saves the wallet to a keystore file
+     */
+    saveToKeystore(path: PathLike, password: string): void;
+}

package/out/accounts/account.js

@@ -0,0 +1,154 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Account = void 0;
+const fs = __importStar(require("fs"));
+const core_1 = require("../core");
+const wallet_1 = require("../wallet");
+/**
+ * An abstraction representing an account (user or Smart Contract) on the Network.
+ */
+class Account {
+    /**
+     * Creates an account object from a secret key
+     */
+    constructor(secretKey, hrp = core_1.LibraryConfig.DefaultAddressHrp) {
+        /**
+         * Local copy of the account nonce.
+         * Must be explicitly managed by client code.
+         */
+        this.nonce = 0n;
+        this.secretKey = secretKey;
+        this.publicKey = secretKey.generatePublicKey();
+        this.address = this.publicKey.toAddress(hrp);
+    }
+    /**
+     * Named constructor
+     * Loads a secret key from a PEM file. PEM files may contain multiple accounts - thus, an (optional) "index" is used to select the desired secret key.
+     * Returns an Account object, initialized with the secret key.
+     */
+    static async newFromPem(path, index = 0, hrp = core_1.LibraryConfig.DefaultAddressHrp) {
+        const text = await fs.promises.readFile(path, { encoding: "utf8" });
+        const userSigner = wallet_1.UserSigner.fromPem(text, index);
+        return new Account(userSigner.secretKey, hrp);
+    }
+    /**
+     * Named constructor
+     * Loads a secret key from an encrypted keystore file. Handles both keystores that hold a mnemonic and ones that hold a secret key (legacy).
+     * For keystores that hold an encrypted mnemonic, the optional "addressIndex" parameter is used to derive the desired secret key.
+     * Returns an Account object, initialized with the secret key.
+     */
+    static newFromKeystore(filePath, password, addressIndex, hrp = core_1.LibraryConfig.DefaultAddressHrp) {
+        const secretKey = wallet_1.UserWallet.loadSecretKey(filePath, password, addressIndex);
+        return new Account(secretKey, hrp);
+    }
+    /**
+     * Named constructor
+     * Loads (derives) a secret key from a mnemonic. The optional "addressIndex" parameter is used to guide the derivation.
+     * Returns an Account object, initialized with the secret key.
+     */
+    static newFromMnemonic(mnemonic, addressIndex = 0, hrp = core_1.LibraryConfig.DefaultAddressHrp) {
+        const mnemonicHandler = wallet_1.Mnemonic.fromString(mnemonic);
+        const secretKey = mnemonicHandler.deriveKey(addressIndex);
+        return new Account(secretKey, hrp);
+    }
+    /**
+     * Named constructor
+     * Returns an Account object, initialized with the secret key.
+     */
+    static newFromKeypair(keypair, hrp = core_1.LibraryConfig.DefaultAddressHrp) {
+        return new Account(keypair.secretKey, hrp);
+    }
+    /**
+     * Increments (locally) the nonce (the account sequence number).
+     */
+    incrementNonce() {
+        this.nonce = this.nonce + 1n;
+    }
+    /**
+     * Signs using the secret key of the account.
+     */
+    async sign(data) {
+        return this.secretKey.sign(data);
+    }
+    /**
+     * Verifies the signature using the public key of the account.
+     */
+    async verify(data, signature) {
+        return this.publicKey.verify(data, signature);
+    }
+    /**
+     * Serializes the transaction, computes the signature and returns it.
+     */
+    async signTransaction(transaction) {
+        const transactionComputer = new core_1.TransactionComputer();
+        const serializedTransaction = transactionComputer.computeBytesForSigning(transaction);
+        return this.secretKey.sign(serializedTransaction);
+    }
+    /**
+     * Verifies the transaction signature using the public key of the account.
+     */
+    async verifyTransactionSignature(transaction, signature) {
+        const transactionComputer = new core_1.TransactionComputer();
+        const serializedTransaction = transactionComputer.computeBytesForVerifying(transaction);
+        return this.publicKey.verify(serializedTransaction, signature);
+    }
+    /**
+     * Serializes the message, computes the signature and returns it.
+     */
+    async signMessage(message) {
+        const messageComputer = new core_1.MessageComputer();
+        const serializedMessage = messageComputer.computeBytesForSigning(message);
+        return this.secretKey.sign(serializedMessage);
+    }
+    /**
+     * Verifies the message signature using the public key of the account.
+     */
+    async verifyMessageSignature(message, signature) {
+        const messageComputer = new core_1.MessageComputer();
+        const serializedMessage = messageComputer.computeBytesForVerifying(message);
+        return this.publicKey.verify(serializedMessage, signature);
+    }
+    /**
+     * Gets the nonce (the one from the object's state) and increments it.
+     */
+    getNonceThenIncrement() {
+        let nonce = this.nonce;
+        this.nonce = this.nonce + 1n;
+        return nonce;
+    }
+    /**
+     * Saves the wallet to a pem file
+     */
+    saveToPem(path) {
+        const pem = new wallet_1.UserPem(this.address.toBech32(), this.secretKey);
+        pem.save(path);
+    }
+    /**
+     * Saves the wallet to a keystore file
+     */
+    saveToKeystore(path, password) {
+        const wallet = wallet_1.UserWallet.fromSecretKey({ secretKey: this.secretKey, password });
+        wallet.save(path, this.address.getHrp());
+    }
+}
+exports.Account = Account;
+//# sourceMappingURL=account.js.map

package/out/accounts/account.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.js","sourceRoot":"","sources":["../../src/accounts/account.ts"],"names":[],"mappings":"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"}

package/out/accounts/index.d.ts

@@ -0,0 +1 @@
+export * from "./account";

package/out/accounts/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./account"), exports);
+//# sourceMappingURL=index.js.map

package/out/accounts/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/accounts/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,4CAA0B"}

package/out/core/address.d.ts

@@ -0,0 +1,105 @@
+/// <reference types="node" />
+/**
+ * An Address, as an immutable object.
+ */
+export declare class Address {
+    private readonly publicKey;
+    private readonly hrp;
+    /**
+     * Creates an address object, given a raw string (whether a hex pubkey or a Bech32 address), a sequence of bytes, or another Address object.
+     */
+    constructor(value: Address | Uint8Array | string, hrp?: string);
+    /**
+     * Named constructor
+     * Creates an address object from a bech32-encoded string
+     */
+    static newFromBech32(value: string): Address;
+    /**
+     * @deprecated Use {@link newFromBech32} instead.
+     */
+    static fromBech32(value: string): Address;
+    /**
+     * Named constructor
+     * Creates an address object from a hex-encoded string
+     */
+    static newFromHex(value: string, hrp?: string): Address;
+    /**
+     * @deprecated Use {@link newFromHex} instead.
+     */
+    static fromHex(value: string, hrp?: string): Address;
+    private static isValidHex;
+    /**
+     * @deprecated Use {@link toHex} instead.
+     */
+    hex(): string;
+    /**
+     * Returns the hex representation of the address (pubkey)
+     */
+    toHex(): string;
+    /**
+     * @deprecated Use {@link toBech32} instead.
+     */
+    bech32(): string;
+    /**
+     * Returns the bech32 representation of the address
+     */
+    toBech32(): string;
+    /**
+     * @deprecated Use {@link getPublicKey} instead.
+     */
+    pubkey(): Buffer;
+    /**
+     * Returns the underlying public key.
+     */
+    getPublicKey(): Buffer;
+    /**
+     * Returns the human-readable-part of the bech32 addresses.
+     */
+    getHrp(): string;
+    /**
+     * Creates an empty address object.
+     * Generally speaking, this should not be used by client code (internal use only).
+     */
+    static empty(): Address;
+    /**
+     * Performs address validation without throwing errors
+     */
+    static isValid(value: string): boolean;
+    /**
+     * Returns whether the address is empty.
+     */
+    isEmpty(): boolean;
+    /**
+     * Compares the address to another address
+     */
+    equals(other: Address | null): boolean;
+    /**
+     * Returns the bech32 representation of the address
+     */
+    toString(): string;
+    /**
+     * Converts the address to a pretty, plain JavaScript object.
+     */
+    toJSON(): object;
+    /**
+     * 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;
+    /**
+     * @deprecated Use {@link isSmartContract} instead.
+     */
+    isContractAddress(): boolean;
+    /**
+     * Returns whether the address is a smart contract address.
+     */
+    isSmartContract(): boolean;
+}
+export declare class AddressComputer {
+    private readonly numberOfShardsWithoutMeta;
+    constructor(numberOfShardsWithoutMeta?: number);
+    computeContractAddress(deployer: Address, deploymentNonce: bigint): Address;
+    getShardOfAddress(address: Address): number;
+    private getShardOfPubkey;
+    private isPubkeyOfMetachain;
+}

package/out/core/address.js

@@ -0,0 +1,313 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AddressComputer = exports.Address = void 0;
+const bech32 = __importStar(require("bech32"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const codec_1 = require("../tokenOperations/codec");
+const config_1 = require("./config");
+const constants_1 = require("./constants");
+const errors = __importStar(require("./errors"));
+const createKeccakHash = require("keccak");
+/**
+ * The length (in bytes) of a public key (from which a bech32 address can be obtained).
+ */
+const PUBKEY_LENGTH = 32;
+const SMART_CONTRACT_HEX_PUBKEY_PREFIX = "0".repeat(16);
+/**
+ * An Address, as an immutable object.
+ */
+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.
+     */
+    constructor(value, hrp) {
+        // Legacy flow.
+        if (!value) {
+            this.publicKey = Buffer.from([]);
+            this.hrp = hrp || config_1.LibraryConfig.DefaultAddressHrp;
+            return;
+        }
+        // The only flow that's following the specs.
+        if (ArrayBuffer.isView(value)) {
+            if (value.length != PUBKEY_LENGTH) {
+                throw new errors.ErrAddressCannotCreate(value);
+            }
+            this.publicKey = Buffer.from(value);
+            this.hrp = hrp || config_1.LibraryConfig.DefaultAddressHrp;
+            return;
+        }
+        // Legacy flow.
+        if (value instanceof Address) {
+            if (hrp) {
+                throw new errors.ErrInvalidArgument("this variant of the Address constructor does not accept the 'hrp' argument");
+            }
+            this.publicKey = value.publicKey;
+            this.hrp = value.hrp;
+            return;
+        }
+        // Legacy flow.
+        if (typeof value === "string") {
+            if (Address.isValidHex(value)) {
+                this.publicKey = Buffer.from(value, "hex");
+                this.hrp = hrp || config_1.LibraryConfig.DefaultAddressHrp;
+                return;
+            }
+            if (hrp) {
+                throw new errors.ErrInvalidArgument("this variant of the Address constructor does not accept the 'hrp' argument");
+            }
+            // On this legacy flow, we do not accept addresses with custom hrp (in order to avoid behavioral breaking changes).
+            const { hrp: decodedHrp, pubkey } = decodeFromBech32({ value, allowCustomHrp: false });
+            this.publicKey = pubkey;
+            this.hrp = decodedHrp;
+            return;
+        }
+        throw new errors.ErrAddressCannotCreate(value);
+    }
+    /**
+     * Named constructor
+     * Creates an address object from a bech32-encoded string
+     */
+    static newFromBech32(value) {
+        const { hrp, pubkey } = decodeFromBech32({ value, allowCustomHrp: true });
+        return new Address(pubkey, hrp);
+    }
+    /**
+     * @deprecated Use {@link newFromBech32} instead.
+     */
+    static fromBech32(value) {
+        // On this legacy flow, we do not accept addresses with custom hrp (in order to avoid behavioral breaking changes).
+        const { hrp, pubkey } = decodeFromBech32({ value, allowCustomHrp: false });
+        return new Address(pubkey, hrp);
+    }
+    /**
+     * Named constructor
+     * Creates an address object from a hex-encoded string
+     */
+    static newFromHex(value, hrp) {
+        if (!Address.isValidHex(value)) {
+            throw new errors.ErrAddressCannotCreate(value);
+        }
+        return new Address(Buffer.from(value, "hex"), hrp);
+    }
+    /**
+     * @deprecated Use {@link newFromHex} instead.
+     */
+    static fromHex(value, hrp) {
+        return Address.newFromHex(value, hrp);
+    }
+    static isValidHex(value) {
+        return Buffer.from(value, "hex").length == PUBKEY_LENGTH;
+    }
+    /**
+     * @deprecated Use {@link toHex} instead.
+     */
+    hex() {
+        return this.toHex();
+    }
+    /**
+     * Returns the hex representation of the address (pubkey)
+     */
+    toHex() {
+        if (this.isEmpty()) {
+            return "";
+        }
+        return this.publicKey.toString("hex");
+    }
+    /**
+     * @deprecated Use {@link toBech32} instead.
+     */
+    bech32() {
+        return this.toBech32();
+    }
+    /**
+     * Returns the bech32 representation of the address
+     */
+    toBech32() {
+        if (this.isEmpty()) {
+            return "";
+        }
+        let words = bech32.toWords(this.getPublicKey());
+        let address = bech32.encode(this.hrp, words);
+        return address;
+    }
+    /**
+     * @deprecated Use {@link getPublicKey} instead.
+     */
+    pubkey() {
+        return this.getPublicKey();
+    }
+    /**
+     * Returns the underlying public key.
+     */
+    getPublicKey() {
+        return this.publicKey;
+    }
+    /**
+     * Returns the human-readable-part of the bech32 addresses.
+     */
+    getHrp() {
+        return this.hrp;
+    }
+    /**
+     * Creates an empty address object.
+     * Generally speaking, this should not be used by client code (internal use only).
+     */
+    static empty() {
+        return new Address("");
+    }
+    /**
+     * Performs address validation without throwing errors
+     */
+    static isValid(value) {
+        const decoded = bech32.decodeUnsafe(value);
+        const prefix = decoded?.prefix;
+        const pubkey = decoded ? Buffer.from(bech32.fromWords(decoded.words)) : undefined;
+        if (prefix !== config_1.LibraryConfig.DefaultAddressHrp || pubkey?.length !== PUBKEY_LENGTH) {
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Returns whether the address is empty.
+     */
+    isEmpty() {
+        return this.publicKey.length == 0;
+    }
+    /**
+     * Compares the address to another address
+     */
+    equals(other) {
+        if (!other) {
+            return false;
+        }
+        return this.publicKey.toString() == other.publicKey.toString();
+    }
+    /**
+     * Returns the bech32 representation of the address
+     */
+    toString() {
+        return this.toBech32();
+    }
+    /**
+     * Converts the address to a pretty, plain JavaScript object.
+     */
+    toJSON() {
+        return {
+            bech32: this.toBech32(),
+            pubkey: this.toHex(),
+        };
+    }
+    /**
+     * 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() {
+        return new Address("0".repeat(64));
+    }
+    /**
+     * @deprecated Use {@link isSmartContract} instead.
+     */
+    isContractAddress() {
+        return this.isSmartContract();
+    }
+    /**
+     * Returns whether the address is a smart contract address.
+     */
+    isSmartContract() {
+        return this.toHex().startsWith(SMART_CONTRACT_HEX_PUBKEY_PREFIX);
+    }
+}
+exports.Address = Address;
+class AddressComputer {
+    constructor(numberOfShardsWithoutMeta) {
+        this.numberOfShardsWithoutMeta = numberOfShardsWithoutMeta || constants_1.CURRENT_NUMBER_OF_SHARDS_WITHOUT_META;
+    }
+    computeContractAddress(deployer, deploymentNonce) {
+        const initialPadding = Buffer.alloc(8, 0);
+        const ownerPubkey = deployer.getPublicKey();
+        const shardSelector = ownerPubkey.slice(30);
+        const ownerNonceBytes = Buffer.alloc(8);
+        const bigNonce = new bignumber_js_1.default(deploymentNonce.toString());
+        const bigNonceBuffer = codec_1.bigIntToBuffer(bigNonce);
+        ownerNonceBytes.write(bigNonceBuffer.reverse().toString("hex"), "hex");
+        const bytesToHash = Buffer.concat([ownerPubkey, ownerNonceBytes]);
+        const hash = createKeccakHash("keccak256").update(bytesToHash).digest();
+        const vmTypeBytes = Buffer.from(constants_1.WasmVirtualMachine, "hex");
+        const addressBytes = Buffer.concat([initialPadding, vmTypeBytes, hash.slice(10, 30), shardSelector]);
+        return new Address(addressBytes);
+    }
+    getShardOfAddress(address) {
+        return this.getShardOfPubkey(address.getPublicKey(), this.numberOfShardsWithoutMeta);
+    }
+    getShardOfPubkey(pubkey, numberOfShards) {
+        const maskHigh = parseInt("11", 2);
+        const maskLow = parseInt("01", 2);
+        const lastByteOfPubkey = pubkey[31];
+        if (this.isPubkeyOfMetachain(pubkey)) {
+            return constants_1.METACHAIN_ID;
+        }
+        let shard = lastByteOfPubkey & maskHigh;
+        if (shard > numberOfShards - 1) {
+            shard = lastByteOfPubkey & maskLow;
+        }
+        return shard;
+    }
+    isPubkeyOfMetachain(pubkey) {
+        const metachainPrefix = Buffer.from([
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ]);
+        const pubkeyPrefix = Buffer.from(pubkey).slice(0, metachainPrefix.length);
+        if (metachainPrefix.equals(pubkeyPrefix)) {
+            return true;
+        }
+        const zeroAddress = Buffer.alloc(32);
+        if (zeroAddress.equals(Buffer.from(pubkey))) {
+            return true;
+        }
+        return false;
+    }
+}
+exports.AddressComputer = AddressComputer;
+function decodeFromBech32(options) {
+    const value = options.value;
+    const allowCustomHrp = options.allowCustomHrp;
+    let hrp;
+    let pubkey;
+    try {
+        const decoded = bech32.decode(value);
+        hrp = decoded.prefix;
+        pubkey = Buffer.from(bech32.fromWords(decoded.words));
+    }
+    catch (err) {
+        throw new errors.ErrAddressCannotCreate(value, err);
+    }
+    // Workaround, in order to avoid behavioral breaking changes on legacy flows.
+    // In a future major release, we should drop this constraint (not exactly useful, validation should be performed in other ways)
+    if (!allowCustomHrp && hrp != config_1.LibraryConfig.DefaultAddressHrp) {
+        throw new errors.ErrAddressBadHrp(config_1.LibraryConfig.DefaultAddressHrp, hrp);
+    }
+    return { hrp, pubkey };
+}
+//# sourceMappingURL=address.js.map