@lukso/web-components 1.131.0 → 1.132.0

package/dist/{index-ba49f23a.cjs → index-B-jWYFR1.cjs}

@@ -1,11 +1,11 @@
 'use strict';
 
-const shared_tailwindElement_index = require('./index-96bba619.cjs');
-const property = require('./property-98f7e05b.cjs');
-const index = require('./index-2b104ecb.cjs');
-const index$1 = require('./index-5df012eb.cjs');
+const shared_tailwindElement_index = require('./index-BitOdrRJ.cjs');
+const property = require('./property-BmOVhAsp.cjs');
+const index = require('./index-CaJky2qL.cjs');
+const index$1 = require('./index-BqVcbfZx.cjs');
 require('./tailwind-config.cjs');
-const cn = require('./cn-b6daa995.cjs');
+const cn = require('./cn-CNdKneQ1.cjs');
 
 const sliceAddress = (address, startSliceBy = 6, endSliceBy) => {
   if (!address || typeof address !== "string") {
@@ -61,7 +61,6 @@ function output(out, instance) {
     }
 }
 const assert = { number, bool, bytes, hash, exists, output };
-const assert$1 = assert;
 
 const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
 const _32n = /* @__PURE__ */ BigInt(32);
@@ -339,12 +338,10 @@ const gen = (suffix, blockLen, outputLen) => wrapConstructor(() => new Keccak(bl
  */
 const keccak_256 = /* @__PURE__ */ gen(0x01, 136, 256 / 8);
 
-assert$1.bool;
-assert$1.bytes;
 // Internal utils
 function wrapHash(hash) {
     return (msg) => {
-        assert$1.bytes(msg);
+        assert.bytes(msg);
         return hash(msg);
     };
 }
@@ -383,29 +380,28 @@ You should have received a copy of the GNU Lesser General Public License
 along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
 */
 // Response error
-const ERR_MULTIPLE_ERRORS = 208;
+const ERR_MULTIPLE_ERRORS$1 = 208;
 // RPC error codes (EIP-1193)
 // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1193.md#provider-errors
-const JSONRPC_ERR_REJECTED_REQUEST = 4001;
-const JSONRPC_ERR_UNAUTHORIZED = 4100;
-const JSONRPC_ERR_UNSUPPORTED_METHOD = 4200;
-const JSONRPC_ERR_DISCONNECTED = 4900;
-const JSONRPC_ERR_CHAIN_DISCONNECTED = 4901;
-const ERR_INVALID_ADDRESS = 1005;
+const JSONRPC_ERR_REJECTED_REQUEST$1 = 4001;
+const JSONRPC_ERR_UNAUTHORIZED$1 = 4100;
+const JSONRPC_ERR_UNSUPPORTED_METHOD$1 = 4200;
+const JSONRPC_ERR_DISCONNECTED$1 = 4900;
+const JSONRPC_ERR_CHAIN_DISCONNECTED$1 = 4901;
 // RPC error codes (EIP-1474)
 // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1474.md
-const ERR_RPC_INVALID_JSON = -32700;
-const ERR_RPC_INVALID_REQUEST = -32600;
-const ERR_RPC_INVALID_METHOD = -32601;
-const ERR_RPC_INVALID_PARAMS = -32602;
-const ERR_RPC_INTERNAL_ERROR = -32603;
-const ERR_RPC_INVALID_INPUT = -32000;
-const ERR_RPC_MISSING_RESOURCE = -32001;
-const ERR_RPC_UNAVAILABLE_RESOURCE = -32002;
-const ERR_RPC_TRANSACTION_REJECTED = -32003;
-const ERR_RPC_UNSUPPORTED_METHOD = -32004;
-const ERR_RPC_LIMIT_EXCEEDED = -32005;
-const ERR_RPC_NOT_SUPPORTED = -32006;
+const ERR_RPC_INVALID_JSON$1 = -32700;
+const ERR_RPC_INVALID_REQUEST$1 = -32600;
+const ERR_RPC_INVALID_METHOD$1 = -32601;
+const ERR_RPC_INVALID_PARAMS$1 = -32602;
+const ERR_RPC_INTERNAL_ERROR$1 = -32603;
+const ERR_RPC_INVALID_INPUT$1 = -32e3;
+const ERR_RPC_MISSING_RESOURCE$1 = -32001;
+const ERR_RPC_UNAVAILABLE_RESOURCE$1 = -32002;
+const ERR_RPC_TRANSACTION_REJECTED$1 = -32003;
+const ERR_RPC_UNSUPPORTED_METHOD$1 = -32004;
+const ERR_RPC_LIMIT_EXCEEDED$1 = -32005;
+const ERR_RPC_NOT_SUPPORTED$1 = -32006;
 
 /*
 This file is part of web3.js.
@@ -426,12 +422,12 @@ along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
 /**
  * Base class for Web3 errors.
  */
-class BaseWeb3Error extends Error {
+let BaseWeb3Error$1 = class BaseWeb3Error extends Error {
     constructor(msg, cause) {
         super(msg);
         if (Array.isArray(cause)) {
             // eslint-disable-next-line no-use-before-define
-            this.cause = new MultipleErrors(cause);
+            this.cause = new MultipleErrors$1(cause);
         }
         else {
             this.cause = cause;
@@ -449,7 +445,7 @@ class BaseWeb3Error extends Error {
      */
     get innerError() {
         // eslint-disable-next-line no-use-before-define
-        if (this.cause instanceof MultipleErrors) {
+        if (this.cause instanceof MultipleErrors$1) {
             return this.cause.errors;
         }
         return this.cause;
@@ -460,7 +456,7 @@ class BaseWeb3Error extends Error {
     set innerError(cause) {
         if (Array.isArray(cause)) {
             // eslint-disable-next-line no-use-before-define
-            this.cause = new MultipleErrors(cause);
+            this.cause = new MultipleErrors$1(cause);
         }
         else {
             this.cause = cause;
@@ -486,44 +482,14 @@ class BaseWeb3Error extends Error {
             innerError: this.cause,
         };
     }
-}
-class MultipleErrors extends BaseWeb3Error {
+};
+let MultipleErrors$1 = class MultipleErrors extends BaseWeb3Error$1 {
     constructor(errors) {
         super(`Multiple errors occurred: [${errors.map(e => e.message).join('], [')}]`);
-        this.code = ERR_MULTIPLE_ERRORS;
+        this.code = ERR_MULTIPLE_ERRORS$1;
         this.errors = errors;
     }
-}
-class InvalidValueError extends BaseWeb3Error {
-    constructor(value, msg) {
-        super(`Invalid value given "${BaseWeb3Error.convertToString(value, true)}". Error: ${msg}.`);
-        this.name = this.constructor.name;
-    }
-}
-
-/*
-This file is part of web3.js.
-
-web3.js is free software: you can redistribute it and/or modify
-it under the terms of the GNU Lesser General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-web3.js is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Lesser General Public License for more details.
-
-You should have received a copy of the GNU Lesser General Public License
-along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
-*/
-/* eslint-disable max-classes-per-file */
-class InvalidAddressError extends InvalidValueError {
-    constructor(value) {
-        super(value, 'invalid ethereum address');
-        this.code = ERR_INVALID_ADDRESS;
-    }
-}
+};
 
 /*
 This file is part of web3.js.
@@ -546,78 +512,78 @@ along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
  * Note: consider in next version that a spelling mistake could be corrected for `occured` and the value could be:
  * 	`An Rpc error has occurred with a code of *code*`
  */
-const genericRpcErrorMessageTemplate = 'An Rpc error has occured with a code of *code*';
+const genericRpcErrorMessageTemplate$1 = 'An Rpc error has occured with a code of *code*';
 /* eslint-disable @typescript-eslint/naming-convention */
-const RpcErrorMessages = {
+const RpcErrorMessages$1 = {
     //  EIP-1474 & JSON RPC 2.0
     // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1474.md
-    [ERR_RPC_INVALID_JSON]: {
+    [ERR_RPC_INVALID_JSON$1]: {
         message: 'Parse error',
         description: 'Invalid JSON',
     },
-    [ERR_RPC_INVALID_REQUEST]: {
+    [ERR_RPC_INVALID_REQUEST$1]: {
         message: 'Invalid request',
         description: 'JSON is not a valid request object	',
     },
-    [ERR_RPC_INVALID_METHOD]: {
+    [ERR_RPC_INVALID_METHOD$1]: {
         message: 'Method not found',
         description: 'Method does not exist	',
     },
-    [ERR_RPC_INVALID_PARAMS]: {
+    [ERR_RPC_INVALID_PARAMS$1]: {
         message: 'Invalid params',
         description: 'Invalid method parameters',
     },
-    [ERR_RPC_INTERNAL_ERROR]: {
+    [ERR_RPC_INTERNAL_ERROR$1]: {
         message: 'Internal error',
         description: 'Internal JSON-RPC error',
     },
-    [ERR_RPC_INVALID_INPUT]: {
+    [ERR_RPC_INVALID_INPUT$1]: {
         message: 'Invalid input',
         description: 'Missing or invalid parameters',
     },
-    [ERR_RPC_MISSING_RESOURCE]: {
+    [ERR_RPC_MISSING_RESOURCE$1]: {
         message: 'Resource not found',
         description: 'Requested resource not found',
     },
-    [ERR_RPC_UNAVAILABLE_RESOURCE]: {
+    [ERR_RPC_UNAVAILABLE_RESOURCE$1]: {
         message: 'Resource unavailable',
         description: 'Requested resource not available',
     },
-    [ERR_RPC_TRANSACTION_REJECTED]: {
+    [ERR_RPC_TRANSACTION_REJECTED$1]: {
         message: 'Transaction rejected',
         description: 'Transaction creation failed',
     },
-    [ERR_RPC_UNSUPPORTED_METHOD]: {
+    [ERR_RPC_UNSUPPORTED_METHOD$1]: {
         message: 'Method not supported',
         description: 'Method is not implemented',
     },
-    [ERR_RPC_LIMIT_EXCEEDED]: {
+    [ERR_RPC_LIMIT_EXCEEDED$1]: {
         message: 'Limit exceeded',
         description: 'Request exceeds defined limit',
     },
-    [ERR_RPC_NOT_SUPPORTED]: {
+    [ERR_RPC_NOT_SUPPORTED$1]: {
         message: 'JSON-RPC version not supported',
         description: 'Version of JSON-RPC protocol is not supported',
     },
     // EIP-1193
     // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1193.md#provider-errors
-    [JSONRPC_ERR_REJECTED_REQUEST]: {
+    [JSONRPC_ERR_REJECTED_REQUEST$1]: {
         name: 'User Rejected Request',
         message: 'The user rejected the request.',
     },
-    [JSONRPC_ERR_UNAUTHORIZED]: {
+    [JSONRPC_ERR_UNAUTHORIZED$1]: {
         name: 'Unauthorized',
         message: 'The requested method and/or account has not been authorized by the user.',
     },
-    [JSONRPC_ERR_UNSUPPORTED_METHOD]: {
+    [JSONRPC_ERR_UNSUPPORTED_METHOD$1]: {
         name: 'Unsupported Method',
         message: 'The Provider does not support the requested method.',
     },
-    [JSONRPC_ERR_DISCONNECTED]: {
+    [JSONRPC_ERR_DISCONNECTED$1]: {
         name: 'Disconnected',
         message: 'The Provider is disconnected from all chains.',
     },
-    [JSONRPC_ERR_CHAIN_DISCONNECTED]: {
+    [JSONRPC_ERR_CHAIN_DISCONNECTED$1]: {
         name: 'Chain Disconnected',
         message: 'The Provider is not connected to the requested chain.',
     },
@@ -721,9 +687,9 @@ GNU Lesser General Public License for more details.
 You should have received a copy of the GNU Lesser General Public License
 along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
 */
-class RpcError extends BaseWeb3Error {
+let RpcError$1 = class RpcError extends BaseWeb3Error$1 {
     constructor(rpcError, message) {
-        super(message !== null && message !== void 0 ? message : genericRpcErrorMessageTemplate.replace('*code*', rpcError.error.code.toString()));
+        super(message !== null && message !== void 0 ? message : genericRpcErrorMessageTemplate$1.replace('*code*', rpcError.error.code.toString()));
         this.code = rpcError.error.code;
         this.id = rpcError.id;
         this.jsonrpc = rpcError.jsonrpc;
@@ -732,106 +698,106 @@ class RpcError extends BaseWeb3Error {
     toJSON() {
         return Object.assign(Object.assign({}, super.toJSON()), { error: this.jsonRpcError, id: this.id, jsonRpc: this.jsonrpc });
     }
-}
-class ParseError extends RpcError {
+};
+let ParseError$1 = class ParseError extends RpcError$1 {
     constructor(rpcError) {
-        super(rpcError, RpcErrorMessages[ERR_RPC_INVALID_JSON].message);
-        this.code = ERR_RPC_INVALID_JSON;
+        super(rpcError, RpcErrorMessages$1[ERR_RPC_INVALID_JSON$1].message);
+        this.code = ERR_RPC_INVALID_JSON$1;
     }
-}
-class InvalidRequestError extends RpcError {
+};
+let InvalidRequestError$1 = class InvalidRequestError extends RpcError$1 {
     constructor(rpcError) {
-        super(rpcError, RpcErrorMessages[ERR_RPC_INVALID_REQUEST].message);
-        this.code = ERR_RPC_INVALID_REQUEST;
+        super(rpcError, RpcErrorMessages$1[ERR_RPC_INVALID_REQUEST$1].message);
+        this.code = ERR_RPC_INVALID_REQUEST$1;
     }
-}
-class MethodNotFoundError extends RpcError {
+};
+let MethodNotFoundError$1 = class MethodNotFoundError extends RpcError$1 {
     constructor(rpcError) {
-        super(rpcError, RpcErrorMessages[ERR_RPC_INVALID_METHOD].message);
-        this.code = ERR_RPC_INVALID_METHOD;
+        super(rpcError, RpcErrorMessages$1[ERR_RPC_INVALID_METHOD$1].message);
+        this.code = ERR_RPC_INVALID_METHOD$1;
     }
-}
-class InvalidParamsError extends RpcError {
+};
+let InvalidParamsError$1 = class InvalidParamsError extends RpcError$1 {
     constructor(rpcError) {
-        super(rpcError, RpcErrorMessages[ERR_RPC_INVALID_PARAMS].message);
-        this.code = ERR_RPC_INVALID_PARAMS;
+        super(rpcError, RpcErrorMessages$1[ERR_RPC_INVALID_PARAMS$1].message);
+        this.code = ERR_RPC_INVALID_PARAMS$1;
     }
-}
-class InternalError extends RpcError {
+};
+let InternalError$1 = class InternalError extends RpcError$1 {
     constructor(rpcError) {
-        super(rpcError, RpcErrorMessages[ERR_RPC_INTERNAL_ERROR].message);
-        this.code = ERR_RPC_INTERNAL_ERROR;
+        super(rpcError, RpcErrorMessages$1[ERR_RPC_INTERNAL_ERROR$1].message);
+        this.code = ERR_RPC_INTERNAL_ERROR$1;
     }
-}
-class InvalidInputError extends RpcError {
+};
+let InvalidInputError$1 = class InvalidInputError extends RpcError$1 {
     constructor(rpcError) {
-        super(rpcError, RpcErrorMessages[ERR_RPC_INVALID_INPUT].message);
-        this.code = ERR_RPC_INVALID_INPUT;
+        super(rpcError, RpcErrorMessages$1[ERR_RPC_INVALID_INPUT$1].message);
+        this.code = ERR_RPC_INVALID_INPUT$1;
     }
-}
-class MethodNotSupported extends RpcError {
+};
+let MethodNotSupported$1 = class MethodNotSupported extends RpcError$1 {
     constructor(rpcError) {
-        super(rpcError, RpcErrorMessages[ERR_RPC_UNSUPPORTED_METHOD].message);
-        this.code = ERR_RPC_UNSUPPORTED_METHOD;
+        super(rpcError, RpcErrorMessages$1[ERR_RPC_UNSUPPORTED_METHOD$1].message);
+        this.code = ERR_RPC_UNSUPPORTED_METHOD$1;
     }
-}
-class ResourceUnavailableError extends RpcError {
+};
+let ResourceUnavailableError$1 = class ResourceUnavailableError extends RpcError$1 {
     constructor(rpcError) {
-        super(rpcError, RpcErrorMessages[ERR_RPC_UNAVAILABLE_RESOURCE].message);
-        this.code = ERR_RPC_UNAVAILABLE_RESOURCE;
+        super(rpcError, RpcErrorMessages$1[ERR_RPC_UNAVAILABLE_RESOURCE$1].message);
+        this.code = ERR_RPC_UNAVAILABLE_RESOURCE$1;
     }
-}
-class ResourcesNotFoundError extends RpcError {
+};
+let ResourcesNotFoundError$1 = class ResourcesNotFoundError extends RpcError$1 {
     constructor(rpcError) {
-        super(rpcError, RpcErrorMessages[ERR_RPC_MISSING_RESOURCE].message);
-        this.code = ERR_RPC_MISSING_RESOURCE;
+        super(rpcError, RpcErrorMessages$1[ERR_RPC_MISSING_RESOURCE$1].message);
+        this.code = ERR_RPC_MISSING_RESOURCE$1;
     }
-}
-class VersionNotSupportedError extends RpcError {
+};
+let VersionNotSupportedError$1 = class VersionNotSupportedError extends RpcError$1 {
     constructor(rpcError) {
-        super(rpcError, RpcErrorMessages[ERR_RPC_NOT_SUPPORTED].message);
-        this.code = ERR_RPC_NOT_SUPPORTED;
+        super(rpcError, RpcErrorMessages$1[ERR_RPC_NOT_SUPPORTED$1].message);
+        this.code = ERR_RPC_NOT_SUPPORTED$1;
     }
-}
-class TransactionRejectedError extends RpcError {
+};
+let TransactionRejectedError$1 = class TransactionRejectedError extends RpcError$1 {
     constructor(rpcError) {
-        super(rpcError, RpcErrorMessages[ERR_RPC_TRANSACTION_REJECTED].message);
-        this.code = ERR_RPC_TRANSACTION_REJECTED;
+        super(rpcError, RpcErrorMessages$1[ERR_RPC_TRANSACTION_REJECTED$1].message);
+        this.code = ERR_RPC_TRANSACTION_REJECTED$1;
     }
-}
-class LimitExceededError extends RpcError {
+};
+let LimitExceededError$1 = class LimitExceededError extends RpcError$1 {
     constructor(rpcError) {
-        super(rpcError, RpcErrorMessages[ERR_RPC_LIMIT_EXCEEDED].message);
-        this.code = ERR_RPC_LIMIT_EXCEEDED;
+        super(rpcError, RpcErrorMessages$1[ERR_RPC_LIMIT_EXCEEDED$1].message);
+        this.code = ERR_RPC_LIMIT_EXCEEDED$1;
     }
-}
-const rpcErrorsMap = new Map();
-rpcErrorsMap.set(ERR_RPC_INVALID_JSON, { error: ParseError });
-rpcErrorsMap.set(ERR_RPC_INVALID_REQUEST, {
-    error: InvalidRequestError,
+};
+const rpcErrorsMap$1 = new Map();
+rpcErrorsMap$1.set(ERR_RPC_INVALID_JSON$1, { error: ParseError$1 });
+rpcErrorsMap$1.set(ERR_RPC_INVALID_REQUEST$1, {
+    error: InvalidRequestError$1,
 });
-rpcErrorsMap.set(ERR_RPC_INVALID_METHOD, {
-    error: MethodNotFoundError,
+rpcErrorsMap$1.set(ERR_RPC_INVALID_METHOD$1, {
+    error: MethodNotFoundError$1,
 });
-rpcErrorsMap.set(ERR_RPC_INVALID_PARAMS, { error: InvalidParamsError });
-rpcErrorsMap.set(ERR_RPC_INTERNAL_ERROR, { error: InternalError });
-rpcErrorsMap.set(ERR_RPC_INVALID_INPUT, { error: InvalidInputError });
-rpcErrorsMap.set(ERR_RPC_UNSUPPORTED_METHOD, {
-    error: MethodNotSupported,
+rpcErrorsMap$1.set(ERR_RPC_INVALID_PARAMS$1, { error: InvalidParamsError$1 });
+rpcErrorsMap$1.set(ERR_RPC_INTERNAL_ERROR$1, { error: InternalError$1 });
+rpcErrorsMap$1.set(ERR_RPC_INVALID_INPUT$1, { error: InvalidInputError$1 });
+rpcErrorsMap$1.set(ERR_RPC_UNSUPPORTED_METHOD$1, {
+    error: MethodNotSupported$1,
 });
-rpcErrorsMap.set(ERR_RPC_UNAVAILABLE_RESOURCE, {
-    error: ResourceUnavailableError,
+rpcErrorsMap$1.set(ERR_RPC_UNAVAILABLE_RESOURCE$1, {
+    error: ResourceUnavailableError$1,
 });
-rpcErrorsMap.set(ERR_RPC_TRANSACTION_REJECTED, {
-    error: TransactionRejectedError,
+rpcErrorsMap$1.set(ERR_RPC_TRANSACTION_REJECTED$1, {
+    error: TransactionRejectedError$1,
 });
-rpcErrorsMap.set(ERR_RPC_MISSING_RESOURCE, {
-    error: ResourcesNotFoundError,
+rpcErrorsMap$1.set(ERR_RPC_MISSING_RESOURCE$1, {
+    error: ResourcesNotFoundError$1,
 });
-rpcErrorsMap.set(ERR_RPC_NOT_SUPPORTED, {
-    error: VersionNotSupportedError,
+rpcErrorsMap$1.set(ERR_RPC_NOT_SUPPORTED$1, {
+    error: VersionNotSupportedError$1,
 });
-rpcErrorsMap.set(ERR_RPC_LIMIT_EXCEEDED, { error: LimitExceededError });
+rpcErrorsMap$1.set(ERR_RPC_LIMIT_EXCEEDED$1, { error: LimitExceededError$1 });
 
 /*
 This file is part of web3.js.
@@ -1041,7 +1007,7 @@ var HardforksOrdered;
     HardforksOrdered["shanghai"] = "shanghai";
 })(HardforksOrdered || (HardforksOrdered = {}));
 
-(globalThis && globalThis.__awaiter) || function (thisArg, _arguments, P, generator) {
+(undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -1087,65 +1053,532 @@ but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.
 
+You should have received a copy of the GNU Lesser General Public License
+along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+// Response error
+const ERR_MULTIPLE_ERRORS = 208;
+// RPC error codes (EIP-1193)
+// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1193.md#provider-errors
+const JSONRPC_ERR_REJECTED_REQUEST = 4001;
+const JSONRPC_ERR_UNAUTHORIZED = 4100;
+const JSONRPC_ERR_UNSUPPORTED_METHOD = 4200;
+const JSONRPC_ERR_DISCONNECTED = 4900;
+const JSONRPC_ERR_CHAIN_DISCONNECTED = 4901;
+const ERR_INVALID_ADDRESS = 1005;
+// RPC error codes (EIP-1474)
+// https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1474.md
+const ERR_RPC_INVALID_JSON = -32700;
+const ERR_RPC_INVALID_REQUEST = -32600;
+const ERR_RPC_INVALID_METHOD = -32601;
+const ERR_RPC_INVALID_PARAMS = -32602;
+const ERR_RPC_INTERNAL_ERROR = -32603;
+const ERR_RPC_INVALID_INPUT = -32e3;
+const ERR_RPC_MISSING_RESOURCE = -32001;
+const ERR_RPC_UNAVAILABLE_RESOURCE = -32002;
+const ERR_RPC_TRANSACTION_REJECTED = -32003;
+const ERR_RPC_UNSUPPORTED_METHOD = -32004;
+const ERR_RPC_LIMIT_EXCEEDED = -32005;
+const ERR_RPC_NOT_SUPPORTED = -32006;
+
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
 You should have received a copy of the GNU Lesser General Public License
 along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
 */
 /**
- * @module Utils
- */
-// Ref: https://ethdocs.org/en/latest/ether.html
-// Note: this could be simplified using ** operator, but babel does not handle it well (https://github.com/babel/babel/issues/13109)
-/** @internal */
-({
-    noether: BigInt(0),
-    wei: BigInt(1),
-    kwei: BigInt(1000),
-    Kwei: BigInt(1000),
-    babbage: BigInt(1000),
-    femtoether: BigInt(1000),
-    mwei: BigInt(1000000),
-    Mwei: BigInt(1000000),
-    lovelace: BigInt(1000000),
-    picoether: BigInt(1000000),
-    gwei: BigInt(1000000000),
-    Gwei: BigInt(1000000000),
-    shannon: BigInt(1000000000),
-    nanoether: BigInt(1000000000),
-    nano: BigInt(1000000000),
-    szabo: BigInt(1000000000000),
-    microether: BigInt(1000000000000),
-    micro: BigInt(1000000000000),
-    finney: BigInt(1000000000000000),
-    milliether: BigInt(1000000000000000),
-    milli: BigInt(1000000000000000),
-    ether: BigInt('1000000000000000000'),
-    kether: BigInt('1000000000000000000000'),
-    grand: BigInt('1000000000000000000000'),
-    mether: BigInt('1000000000000000000000000'),
-    gether: BigInt('1000000000000000000000000000'),
-    tether: BigInt('1000000000000000000000000000000'),
-});
-const utf8ToBytes = utf8ToBytes$1;
-/**
- * Will convert an upper or lowercase Ethereum address to a checksum address.
- * @param address - An address string
- * @returns	The checksum address
- * @example
- * ```ts
- * web3.utils.toChecksumAddress('0xc1912fee45d61c87cc5ea59dae31190fffff232d');
- * > "0xc1912fEE45d61C87Cc5EA59DaE31190FFFFf232d"
- * ```
+ * Base class for Web3 errors.
  */
-const toChecksumAddress = (address) => {
-    if (!isAddress(address, false)) {
-        throw new InvalidAddressError(address);
-    }
-    const lowerCaseAddress = address.toLowerCase().replace(/^0x/i, '');
-    // calling `Uint8Array.from` because `noble-hashes` checks with `instanceof Uint8Array` that fails in some edge cases:
-    // 	https://github.com/paulmillr/noble-hashes/issues/25#issuecomment-1750106284
-    const hash = uint8ArrayToHexString(keccak256(ensureIfUint8Array(utf8ToBytes(lowerCaseAddress))));
-    if (isNullish(hash) ||
-        hash === '0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470')
+class BaseWeb3Error extends Error {
+    /**
+     * @deprecated Use the `cause` property instead.
+     */
+    get innerError() {
+        // eslint-disable-next-line no-use-before-define
+        if (this.cause instanceof MultipleErrors) {
+            return this.cause.errors;
+        }
+        return this.cause;
+    }
+    /**
+     * @deprecated Use the `cause` property instead.
+     */
+    set innerError(cause) {
+        if (Array.isArray(cause)) {
+            // eslint-disable-next-line no-use-before-define
+            this.cause = new MultipleErrors(cause);
+        }
+        else {
+            this.cause = cause;
+        }
+    }
+    constructor(msg, cause) {
+        super(msg);
+        if (Array.isArray(cause)) {
+            // eslint-disable-next-line no-use-before-define
+            this.cause = new MultipleErrors(cause);
+        }
+        else {
+            this.cause = cause;
+        }
+        this.name = this.constructor.name;
+        if (typeof Error.captureStackTrace === 'function') {
+            Error.captureStackTrace(new.target.constructor);
+        }
+        else {
+            this.stack = new Error().stack;
+        }
+    }
+    static convertToString(value, unquotValue = false) {
+        // Using "null" value intentionally for validation
+        // eslint-disable-next-line no-null/no-null
+        if (value === null || value === undefined)
+            return 'undefined';
+        const result = JSON.stringify(value, (_, v) => (typeof v === 'bigint' ? v.toString() : v));
+        return unquotValue && ['bigint', 'string'].includes(typeof value)
+            ? result.replace(/['\\"]+/g, '')
+            : result;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            cause: this.cause,
+            // deprecated
+            innerError: this.cause,
+        };
+    }
+}
+class MultipleErrors extends BaseWeb3Error {
+    constructor(errors) {
+        super(`Multiple errors occurred: [${errors.map(e => e.message).join('], [')}]`);
+        this.code = ERR_MULTIPLE_ERRORS;
+        this.errors = errors;
+    }
+}
+class InvalidValueError extends BaseWeb3Error {
+    constructor(value, msg) {
+        super(`Invalid value given "${BaseWeb3Error.convertToString(value, true)}". Error: ${msg}.`);
+        this.name = this.constructor.name;
+    }
+}
+
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/* eslint-disable max-classes-per-file */
+class InvalidAddressError extends InvalidValueError {
+    constructor(value) {
+        super(value, 'invalid ethereum address');
+        this.code = ERR_INVALID_ADDRESS;
+    }
+}
+
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * A template string for a generic Rpc Error. The `*code*` will be replaced with the code number.
+ * Note: consider in next version that a spelling mistake could be corrected for `occured` and the value could be:
+ * 	`An Rpc error has occurred with a code of *code*`
+ */
+const genericRpcErrorMessageTemplate = 'An Rpc error has occured with a code of *code*';
+/* eslint-disable @typescript-eslint/naming-convention */
+const RpcErrorMessages = {
+    //  EIP-1474 & JSON RPC 2.0
+    // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1474.md
+    [ERR_RPC_INVALID_JSON]: {
+        message: 'Parse error',
+        description: 'Invalid JSON',
+    },
+    [ERR_RPC_INVALID_REQUEST]: {
+        message: 'Invalid request',
+        description: 'JSON is not a valid request object	',
+    },
+    [ERR_RPC_INVALID_METHOD]: {
+        message: 'Method not found',
+        description: 'Method does not exist	',
+    },
+    [ERR_RPC_INVALID_PARAMS]: {
+        message: 'Invalid params',
+        description: 'Invalid method parameters',
+    },
+    [ERR_RPC_INTERNAL_ERROR]: {
+        message: 'Internal error',
+        description: 'Internal JSON-RPC error',
+    },
+    [ERR_RPC_INVALID_INPUT]: {
+        message: 'Invalid input',
+        description: 'Missing or invalid parameters',
+    },
+    [ERR_RPC_MISSING_RESOURCE]: {
+        message: 'Resource not found',
+        description: 'Requested resource not found',
+    },
+    [ERR_RPC_UNAVAILABLE_RESOURCE]: {
+        message: 'Resource unavailable',
+        description: 'Requested resource not available',
+    },
+    [ERR_RPC_TRANSACTION_REJECTED]: {
+        message: 'Transaction rejected',
+        description: 'Transaction creation failed',
+    },
+    [ERR_RPC_UNSUPPORTED_METHOD]: {
+        message: 'Method not supported',
+        description: 'Method is not implemented',
+    },
+    [ERR_RPC_LIMIT_EXCEEDED]: {
+        message: 'Limit exceeded',
+        description: 'Request exceeds defined limit',
+    },
+    [ERR_RPC_NOT_SUPPORTED]: {
+        message: 'JSON-RPC version not supported',
+        description: 'Version of JSON-RPC protocol is not supported',
+    },
+    // EIP-1193
+    // https://github.com/ethereum/EIPs/blob/master/EIPS/eip-1193.md#provider-errors
+    [JSONRPC_ERR_REJECTED_REQUEST]: {
+        name: 'User Rejected Request',
+        message: 'The user rejected the request.',
+    },
+    [JSONRPC_ERR_UNAUTHORIZED]: {
+        name: 'Unauthorized',
+        message: 'The requested method and/or account has not been authorized by the user.',
+    },
+    [JSONRPC_ERR_UNSUPPORTED_METHOD]: {
+        name: 'Unsupported Method',
+        message: 'The Provider does not support the requested method.',
+    },
+    [JSONRPC_ERR_DISCONNECTED]: {
+        name: 'Disconnected',
+        message: 'The Provider is disconnected from all chains.',
+    },
+    [JSONRPC_ERR_CHAIN_DISCONNECTED]: {
+        name: 'Chain Disconnected',
+        message: 'The Provider is not connected to the requested chain.',
+    },
+    // EIP-1193 - CloseEvent
+    // https://developer.mozilla.org/en-US/docs/Web/API/CloseEvent/code
+    '0-999': {
+        name: '',
+        message: 'Not used.',
+    },
+    1000: {
+        name: 'Normal Closure',
+        message: 'The connection successfully completed the purpose for which it was created.',
+    },
+    1001: {
+        name: 'Going Away',
+        message: 'The endpoint is going away, either because of a server failure or because the browser is navigating away from the page that opened the connection.',
+    },
+    1002: {
+        name: 'Protocol error',
+        message: 'The endpoint is terminating the connection due to a protocol error.',
+    },
+    1003: {
+        name: 'Unsupported Data',
+        message: 'The connection is being terminated because the endpoint received data of a type it cannot accept. (For example, a text-only endpoint received binary data.)',
+    },
+    1004: {
+        name: 'Reserved',
+        message: 'Reserved. A meaning might be defined in the future.',
+    },
+    1005: {
+        name: 'No Status Rcvd',
+        message: 'Reserved. Indicates that no status code was provided even though one was expected.',
+    },
+    1006: {
+        name: 'Abnormal Closure',
+        message: 'Reserved. Indicates that a connection was closed abnormally (that is, with no close frame being sent) when a status code is expected.',
+    },
+    1007: {
+        name: 'Invalid frame payload data',
+        message: 'The endpoint is terminating the connection because a message was received that contained inconsistent data (e.g., non-UTF-8 data within a text message).',
+    },
+    1008: {
+        name: 'Policy Violation',
+        message: 'The endpoint is terminating the connection because it received a message that violates its policy. This is a generic status code, used when codes 1003 and 1009 are not suitable.',
+    },
+    1009: {
+        name: 'Message Too Big',
+        message: 'The endpoint is terminating the connection because a data frame was received that is too large.',
+    },
+    1010: {
+        name: 'Mandatory Ext.',
+        message: "The client is terminating the connection because it expected the server to negotiate one or more extension, but the server didn't.",
+    },
+    1011: {
+        name: 'Internal Error',
+        message: 'The server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request.',
+    },
+    1012: {
+        name: 'Service Restart',
+        message: 'The server is terminating the connection because it is restarting.',
+    },
+    1013: {
+        name: 'Try Again Later',
+        message: 'The server is terminating the connection due to a temporary condition, e.g. it is overloaded and is casting off some of its clients.',
+    },
+    1014: {
+        name: 'Bad Gateway',
+        message: 'The server was acting as a gateway or proxy and received an invalid response from the upstream server. This is similar to 502 HTTP Status Code.',
+    },
+    1015: {
+        name: 'TLS handshake',
+        message: "Reserved. Indicates that the connection was closed due to a failure to perform a TLS handshake (e.g., the server certificate can't be verified).",
+    },
+    '1016-2999': {
+        name: '',
+        message: 'For definition by future revisions of the WebSocket Protocol specification, and for definition by extension specifications.',
+    },
+    '3000-3999': {
+        name: '',
+        message: 'For use by libraries, frameworks, and applications. These status codes are registered directly with IANA. The interpretation of these codes is undefined by the WebSocket protocol.',
+    },
+    '4000-4999': {
+        name: '',
+        message: "For private use, and thus can't be registered. Such codes can be used by prior agreements between WebSocket applications. The interpretation of these codes is undefined by the WebSocket protocol.",
+    },
+};
+
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+class RpcError extends BaseWeb3Error {
+    constructor(rpcError, message) {
+        super(message !== null && message !== void 0 ? message : genericRpcErrorMessageTemplate.replace('*code*', rpcError.error.code.toString()));
+        this.code = rpcError.error.code;
+        this.id = rpcError.id;
+        this.jsonrpc = rpcError.jsonrpc;
+        this.jsonRpcError = rpcError.error;
+    }
+    toJSON() {
+        return Object.assign(Object.assign({}, super.toJSON()), { error: this.jsonRpcError, id: this.id, jsonRpc: this.jsonrpc });
+    }
+}
+class ParseError extends RpcError {
+    constructor(rpcError) {
+        super(rpcError, RpcErrorMessages[ERR_RPC_INVALID_JSON].message);
+        this.code = ERR_RPC_INVALID_JSON;
+    }
+}
+class InvalidRequestError extends RpcError {
+    constructor(rpcError) {
+        super(rpcError, RpcErrorMessages[ERR_RPC_INVALID_REQUEST].message);
+        this.code = ERR_RPC_INVALID_REQUEST;
+    }
+}
+class MethodNotFoundError extends RpcError {
+    constructor(rpcError) {
+        super(rpcError, RpcErrorMessages[ERR_RPC_INVALID_METHOD].message);
+        this.code = ERR_RPC_INVALID_METHOD;
+    }
+}
+class InvalidParamsError extends RpcError {
+    constructor(rpcError) {
+        super(rpcError, RpcErrorMessages[ERR_RPC_INVALID_PARAMS].message);
+        this.code = ERR_RPC_INVALID_PARAMS;
+    }
+}
+class InternalError extends RpcError {
+    constructor(rpcError) {
+        super(rpcError, RpcErrorMessages[ERR_RPC_INTERNAL_ERROR].message);
+        this.code = ERR_RPC_INTERNAL_ERROR;
+    }
+}
+class InvalidInputError extends RpcError {
+    constructor(rpcError) {
+        super(rpcError, RpcErrorMessages[ERR_RPC_INVALID_INPUT].message);
+        this.code = ERR_RPC_INVALID_INPUT;
+    }
+}
+class MethodNotSupported extends RpcError {
+    constructor(rpcError) {
+        super(rpcError, RpcErrorMessages[ERR_RPC_UNSUPPORTED_METHOD].message);
+        this.code = ERR_RPC_UNSUPPORTED_METHOD;
+    }
+}
+class ResourceUnavailableError extends RpcError {
+    constructor(rpcError) {
+        super(rpcError, RpcErrorMessages[ERR_RPC_UNAVAILABLE_RESOURCE].message);
+        this.code = ERR_RPC_UNAVAILABLE_RESOURCE;
+    }
+}
+class ResourcesNotFoundError extends RpcError {
+    constructor(rpcError) {
+        super(rpcError, RpcErrorMessages[ERR_RPC_MISSING_RESOURCE].message);
+        this.code = ERR_RPC_MISSING_RESOURCE;
+    }
+}
+class VersionNotSupportedError extends RpcError {
+    constructor(rpcError) {
+        super(rpcError, RpcErrorMessages[ERR_RPC_NOT_SUPPORTED].message);
+        this.code = ERR_RPC_NOT_SUPPORTED;
+    }
+}
+class TransactionRejectedError extends RpcError {
+    constructor(rpcError) {
+        super(rpcError, RpcErrorMessages[ERR_RPC_TRANSACTION_REJECTED].message);
+        this.code = ERR_RPC_TRANSACTION_REJECTED;
+    }
+}
+class LimitExceededError extends RpcError {
+    constructor(rpcError) {
+        super(rpcError, RpcErrorMessages[ERR_RPC_LIMIT_EXCEEDED].message);
+        this.code = ERR_RPC_LIMIT_EXCEEDED;
+    }
+}
+const rpcErrorsMap = new Map();
+rpcErrorsMap.set(ERR_RPC_INVALID_JSON, { error: ParseError });
+rpcErrorsMap.set(ERR_RPC_INVALID_REQUEST, {
+    error: InvalidRequestError,
+});
+rpcErrorsMap.set(ERR_RPC_INVALID_METHOD, {
+    error: MethodNotFoundError,
+});
+rpcErrorsMap.set(ERR_RPC_INVALID_PARAMS, { error: InvalidParamsError });
+rpcErrorsMap.set(ERR_RPC_INTERNAL_ERROR, { error: InternalError });
+rpcErrorsMap.set(ERR_RPC_INVALID_INPUT, { error: InvalidInputError });
+rpcErrorsMap.set(ERR_RPC_UNSUPPORTED_METHOD, {
+    error: MethodNotSupported,
+});
+rpcErrorsMap.set(ERR_RPC_UNAVAILABLE_RESOURCE, {
+    error: ResourceUnavailableError,
+});
+rpcErrorsMap.set(ERR_RPC_TRANSACTION_REJECTED, {
+    error: TransactionRejectedError,
+});
+rpcErrorsMap.set(ERR_RPC_MISSING_RESOURCE, {
+    error: ResourcesNotFoundError,
+});
+rpcErrorsMap.set(ERR_RPC_NOT_SUPPORTED, {
+    error: VersionNotSupportedError,
+});
+rpcErrorsMap.set(ERR_RPC_LIMIT_EXCEEDED, { error: LimitExceededError });
+
+/*
+This file is part of web3.js.
+
+web3.js is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+web3.js is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with web3.js.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @module Utils
+ */
+// Ref: https://ethdocs.org/en/latest/ether.html
+// Note: this could be simplified using ** operator, but babel does not handle it well (https://github.com/babel/babel/issues/13109)
+/** @internal */
+({
+    noether: BigInt(0),
+    wei: BigInt(1),
+    kwei: BigInt(1000),
+    Kwei: BigInt(1000),
+    babbage: BigInt(1000),
+    femtoether: BigInt(1000),
+    mwei: BigInt(1000000),
+    Mwei: BigInt(1000000),
+    lovelace: BigInt(1000000),
+    picoether: BigInt(1000000),
+    gwei: BigInt(1000000000),
+    Gwei: BigInt(1000000000),
+    shannon: BigInt(1000000000),
+    nanoether: BigInt(1000000000),
+    nano: BigInt(1000000000),
+    szabo: BigInt(1000000000000),
+    microether: BigInt(1000000000000),
+    micro: BigInt(1000000000000),
+    finney: BigInt(1000000000000000),
+    milliether: BigInt(1000000000000000),
+    milli: BigInt(1000000000000000),
+    ether: BigInt('1000000000000000000'),
+    kether: BigInt('1000000000000000000000'),
+    grand: BigInt('1000000000000000000000'),
+    mether: BigInt('1000000000000000000000000'),
+    gether: BigInt('1000000000000000000000000000'),
+    tether: BigInt('1000000000000000000000000000000'),
+});
+const utf8ToBytes = utf8ToBytes$1;
+/**
+ * Will convert an upper or lowercase Ethereum address to a checksum address.
+ * @param address - An address string
+ * @returns	The checksum address
+ * @example
+ * ```ts
+ * web3.utils.toChecksumAddress('0xc1912fee45d61c87cc5ea59dae31190fffff232d');
+ * > "0xc1912fEE45d61C87Cc5EA59DaE31190FFFFf232d"
+ * ```
+ */
+const toChecksumAddress = (address) => {
+    if (!isAddress(address, false)) {
+        throw new InvalidAddressError(address);
+    }
+    const lowerCaseAddress = address.toLowerCase().replace(/^0x/i, '');
+    // calling `Uint8Array.from` because `noble-hashes` checks with `instanceof Uint8Array` that fails in some edge cases:
+    // 	https://github.com/paulmillr/noble-hashes/issues/25#issuecomment-1750106284
+    const hash = uint8ArrayToHexString(keccak256(ensureIfUint8Array(utf8ToBytes(lowerCaseAddress))));
+    if (isNullish(hash) ||
+        hash === '0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470')
         return ''; // // EIP-1052 if hash is equal to c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470, keccak was given empty data
     let checksumAddress = '0x';
     const addressHash = hash.replace(/^0x/i, '');
@@ -1170,62 +1603,64 @@ var __decorateClass = (decorators, target, key, kind) => {
   for (var i = decorators.length - 1, decorator; i >= 0; i--)
     if (decorator = decorators[i])
       result = (kind ? decorator(target, key, result) : decorator(result)) || result;
-  if (kind && result)
-    __defProp(target, key, result);
+  if (kind && result) __defProp(target, key, result);
   return result;
 };
 exports.LuksoUsername = class LuksoUsername extends shared_tailwindElement_index.TailwindStyledElement(style) {
-  name = "";
-  address = "";
-  maxWidth = 200;
-  size = "large";
-  sliceBy = 8;
-  addressColor = "";
-  nameColor = "";
-  customClass = "";
-  hidePrefix = false;
-  prefix = "@";
-  noTransform = false;
-  /** Width of the first 4 bytes of the address */
-  bytesWidth = 52;
-  styles = index.ce({
-    slots: {
-      wrapper: "inline-flex",
-      name: "inline-block whitespace-nowrap overflow-hidden text-ellipsis",
-      address: "inline-block",
-      bytes: "inline-block"
-    },
-    variants: {
-      size: {
-        "x-small": {
-          wrapper: "paragraph-ptmono-10-bold"
-        },
-        small: {
-          wrapper: "paragraph-ptmono-12-bold"
-        },
-        medium: {
-          wrapper: "paragraph-ptmono-14-bold"
+  constructor() {
+    super(...arguments);
+    this.name = "";
+    this.address = "";
+    this.maxWidth = 200;
+    this.size = "large";
+    this.sliceBy = 8;
+    this.addressColor = "";
+    this.nameColor = "";
+    this.customClass = "";
+    this.hidePrefix = false;
+    this.prefix = "@";
+    this.noTransform = false;
+    /** Width of the first 4 bytes of the address */
+    this.bytesWidth = 52;
+    this.styles = index.ce({
+      slots: {
+        wrapper: "inline-flex",
+        name: "inline-block whitespace-nowrap overflow-hidden text-ellipsis",
+        address: "inline-block",
+        bytes: "inline-block"
+      },
+      variants: {
+        size: {
+          "x-small": {
+            wrapper: "paragraph-ptmono-10-bold"
+          },
+          small: {
+            wrapper: "paragraph-ptmono-12-bold"
+          },
+          medium: {
+            wrapper: "paragraph-ptmono-14-bold"
+          },
+          large: {
+            wrapper: "paragraph-ptmono-16-bold"
+          },
+          "x-large": {
+            wrapper: "paragraph-ptmono-24-bold"
+          }
         },
-        large: {
-          wrapper: "paragraph-ptmono-16-bold"
+        hasNameColor: {
+          false: {
+            name: "text-transparent bg-clip-text bg-gradient-to-r from-gradient-1-start to-gradient-1-end"
+          }
         },
-        "x-large": {
-          wrapper: "paragraph-ptmono-24-bold"
-        }
-      },
-      hasNameColor: {
-        false: {
-          name: "text-transparent bg-clip-text bg-gradient-to-r from-gradient-1-start to-gradient-1-end"
-        }
-      },
-      hasAddressColor: {
-        false: {
-          address: "text-neutral-20",
-          bytes: "text-neutral-60"
+        hasAddressColor: {
+          false: {
+            address: "text-neutral-20",
+            bytes: "text-neutral-60"
+          }
         }
       }
-    }
-  });
+    });
+  }
   transformName(name) {
     if (this.noTransform) {
       return name;