@cmts-dev/carmentis-sdk-core 1.2.2 → 1.2.4

package/dist/type/valibot/provider/abci/AbciResponse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbciResponse.d.ts","sourceRoot":"","sources":["../../../../../src/type/valibot/provider/abci/AbciResponse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAe7B,oBAAY,gBAAgB;IACxB,KAAK,IAAI;IACT,iBAAiB,IAAI;IACrB,iBAAiB,IAAI;IACrB,aAAa,IAAI;IACjB,wBAAwB,IAAI;IAC5B,yBAAyB,KAAK;IAC9B,sBAAsB,KAAK;IAC3B,oBAAoB,KAAK;IACzB,gBAAgB,KAAK;IACrB,aAAa,KAAK;IAClB,eAAe,KAAK;IACpB,0BAA0B,KAAK;IAC/B,yBAAyB,KAAK;IAC9B,WAAW,KAAK;IAChB,gBAAgB,KAAK;IACrB,iBAAiB,KAAK;IACtB,uBAAuB,KAAK;IAC5B,eAAe,KAAK;CACvB;AAMD,eAAO,MAAM,uBAAuB;;;aAGlC,CAAC;AAGH,eAAO,MAAM,kCAAkC;;;;;;aAM7C,CAAC;AAGH,eAAO,MAAM,kCAAkC;;;;;;;;;;;;;;;;;;;;;;;;;;;aAO7C,CAAC;AAYH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAGzC,CAAC;AAGH,eAAO,MAAM,wCAAwC;;;;;;;;;;;;aAGnD,CAAC;AAGH,eAAO,MAAM,yCAAyC;;;;;;;;;;;;;;;;;;;;;;;;aAMpD,CAAC;AAGH,eAAO,MAAM,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAGlD,CAAC;AAGH,eAAO,MAAM,qCAAqC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAIhD,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAGnC,CAAA;AAEF,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAG5C,CAAC;AAEH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAMzC,CAAC;AAGH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAG3C,CAAC;AAGH,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;aAGnD,CAAC;AAGH,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;aAGnD,CAAC;AAGH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;aAGvC,CAAC;AAGH,eAAO,MAAM,iCAAiC;;;aAG5C,CAAC;AAEH,eAAO,MAAM,iCAAiC;;;;;;;;;;;;;;aAK5C,CAAC;AAEH,eAAO,MAAM,uCAAuC;;;;;;;;;;;;aAGlD,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAG3C,CAAC;AAKH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAmB7B,CAAC;AAKH,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC;AACpE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAC9E,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,kCAAkC,CAAC,CAAC;AACpG,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,kCAAkC,CAAC,CAAC;AACpG,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAC5F,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAClG,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wCAAwC,CAAC,CAAC;AAChH,MAAM,MAAM,mCAAmC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,yCAAyC,CAAC,CAAC;AAClH,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,uCAAuC,CAAC,CAAC;AAC9G,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,qCAAqC,CAAC,CAAC;AAC1G,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAClG,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAC5F,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAChG,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wCAAwC,CAAC,CAAC;AAChH,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wCAAwC,CAAC,CAAC;AAChH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,4BAA4B,CAAC,CAAC;AACxF,MAAM,MAAM,2BAA2B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,iCAAiC,CAAC,CAAC;AAClG,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,uCAAuC,CAAC,CAAC;AAC9G,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gCAAgC,CAAC,CAAC"}

package/dist/type/valibot/walletOperatorMessages/Schemas.d.ts

@@ -0,0 +1,83 @@
+import * as v from 'valibot';
+export declare enum WalletInteractiveAnchoringRequestType {
+    APPROVAL_HANDSHAKE = "WALLET_OPERATOR_REQUEST_APPROVAL_HANDSHAKE",
+    ACTOR_KEY = "WALLET_OPERATOR_REQUEST_ACTOR_KEY",
+    APPROVAL_SIGNATURE = "WALLET_OPERATOR_REQUEST_APPROVAL_SIGNATURE"
+}
+export declare enum WalletInteractiveAnchoringResponseType {
+    ERROR = "WALLET_OPERATOR_RESPONSE_ERROR",
+    ACTOR_KEY_REQUIRED = "WALLET_OPERATOR_RESPONSE_ACTOR_KEY_REQUIRED",
+    APPROVAL_DATA = "WALLET_OPERATOR_RESPONSE_APPROVAL_DATA",
+    APPROVAL_SIGNATURE = "WALLET_OPERATOR_RESPONSE_APPROVAL_SIGNATURE"
+}
+export declare const WalletInteractiveAnchoringRequestApprovalHandshakeSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletInteractiveAnchoringRequestType.APPROVAL_HANDSHAKE, undefined>;
+    readonly anchorRequestId: v.StringSchema<undefined>;
+}, undefined>;
+export declare const WalletInteractiveAnchoringRequestActorKeySchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletInteractiveAnchoringRequestType.ACTOR_KEY, undefined>;
+    readonly anchorRequestId: v.StringSchema<undefined>;
+    readonly actorSignaturePublicKey: v.StringSchema<undefined>;
+    readonly actorPkePublicKey: v.StringSchema<undefined>;
+}, undefined>;
+export declare const WalletInteractiveAnchoringRequestApprovalSignatureSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletInteractiveAnchoringRequestType.APPROVAL_SIGNATURE, undefined>;
+    readonly anchorRequestId: v.StringSchema<undefined>;
+    readonly b64Signature: v.StringSchema<undefined>;
+}, undefined>;
+export declare const WalletInteractiveAnchoringRequestSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletInteractiveAnchoringRequestType.APPROVAL_HANDSHAKE, undefined>;
+    readonly anchorRequestId: v.StringSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletInteractiveAnchoringRequestType.ACTOR_KEY, undefined>;
+    readonly anchorRequestId: v.StringSchema<undefined>;
+    readonly actorSignaturePublicKey: v.StringSchema<undefined>;
+    readonly actorPkePublicKey: v.StringSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletInteractiveAnchoringRequestType.APPROVAL_SIGNATURE, undefined>;
+    readonly anchorRequestId: v.StringSchema<undefined>;
+    readonly b64Signature: v.StringSchema<undefined>;
+}, undefined>], undefined>;
+export declare const WalletInteractiveAnchoringResponseErrorSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletInteractiveAnchoringResponseType.ERROR, undefined>;
+    readonly errorMessage: v.OptionalSchema<v.StringSchema<undefined>, "">;
+}, undefined>;
+export declare const WalletInteractiveAnchoringResponseActorKeyRequiredSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletInteractiveAnchoringResponseType.ACTOR_KEY_REQUIRED, undefined>;
+    readonly b64GenesisSeed: v.StringSchema<undefined>;
+}, undefined>;
+export declare const WalletInteractiveAnchoringResponseApprovalDataSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletInteractiveAnchoringResponseType.APPROVAL_DATA, undefined>;
+    readonly b64SerializedMicroblock: v.StringSchema<undefined>;
+}, undefined>;
+export declare const WalletInteractiveAnchoringResponseApprovalSignatureSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletInteractiveAnchoringResponseType.APPROVAL_SIGNATURE, undefined>;
+    readonly b64VbHash: v.StringSchema<undefined>;
+    readonly b64MbHash: v.StringSchema<undefined>;
+    readonly height: v.NumberSchema<undefined>;
+}, undefined>;
+export declare const WalletInteractiveAnchoringResponseSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletInteractiveAnchoringResponseType.ERROR, undefined>;
+    readonly errorMessage: v.OptionalSchema<v.StringSchema<undefined>, "">;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletInteractiveAnchoringResponseType.ACTOR_KEY_REQUIRED, undefined>;
+    readonly b64GenesisSeed: v.StringSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletInteractiveAnchoringResponseType.APPROVAL_DATA, undefined>;
+    readonly b64SerializedMicroblock: v.StringSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletInteractiveAnchoringResponseType.APPROVAL_SIGNATURE, undefined>;
+    readonly b64VbHash: v.StringSchema<undefined>;
+    readonly b64MbHash: v.StringSchema<undefined>;
+    readonly height: v.NumberSchema<undefined>;
+}, undefined>], undefined>;
+export type WalletInteractiveAnchoringRequest = v.InferOutput<typeof WalletInteractiveAnchoringRequestSchema>;
+export type WalletInteractiveAnchoringResponse = v.InferOutput<typeof WalletInteractiveAnchoringResponseSchema>;
+export type WalletInteractiveAnchoringResponseError = v.InferOutput<typeof WalletInteractiveAnchoringResponseErrorSchema>;
+export type WalletInteractiveAnchoringRequestApprovalHandshake = v.InferOutput<typeof WalletInteractiveAnchoringRequestApprovalHandshakeSchema>;
+export type WalletInteractiveAnchoringRequestActorKey = v.InferOutput<typeof WalletInteractiveAnchoringRequestActorKeySchema>;
+export type WalletInteractiveAnchoringRequestApprovalSignature = v.InferOutput<typeof WalletInteractiveAnchoringRequestApprovalSignatureSchema>;
+export type WalletInteractiveAnchoringResponseActorKeyRequired = v.InferOutput<typeof WalletInteractiveAnchoringResponseActorKeyRequiredSchema>;
+export type WalletInteractiveAnchoringResponseApprovalData = v.InferOutput<typeof WalletInteractiveAnchoringResponseApprovalDataSchema>;
+export type WalletInteractiveAnchoringResponseApprovalSignature = v.InferOutput<typeof WalletInteractiveAnchoringResponseApprovalSignatureSchema>;
+//# sourceMappingURL=Schemas.d.ts.map

package/dist/type/valibot/walletOperatorMessages/Schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schemas.d.ts","sourceRoot":"","sources":["../../../../src/type/valibot/walletOperatorMessages/Schemas.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAG7B,oBAAY,qCAAqC;IAC7C,kBAAkB,+CAA+C;IACjE,SAAS,sCAAsC;IAC/C,kBAAkB,+CAA+C;CACpE;AAGD,oBAAY,sCAAsC;IAC9C,KAAK,mCAAmC;IACxC,kBAAkB,gDAAgD;IAClE,aAAa,2CAA2C;IACxD,kBAAkB,gDAAgD;CACrE;AAGD,eAAO,MAAM,wDAAwD;;;aAGnE,CAAC;AAEH,eAAO,MAAM,+CAA+C;;;;;aAK1D,CAAC;AAEH,eAAO,MAAM,wDAAwD;;;;aAInE,CAAC;AAEH,eAAO,MAAM,uCAAuC;;;;;;;;;;;;0BAIlD,CAAC;AAGH,eAAO,MAAM,6CAA6C;;;aAGxD,CAAC;AAEH,eAAO,MAAM,wDAAwD;;;aAGnE,CAAC;AAEH,eAAO,MAAM,oDAAoD;;;aAG/D,CAAC;AAEH,eAAO,MAAM,yDAAyD;;;;;aAKpE,CAAC;AAEH,eAAO,MAAM,wCAAwC;;;;;;;;;;;;;;0BAKnD,CAAC;AAGH,MAAM,MAAM,iCAAiC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,uCAAuC,CAAC,CAAC;AAC9G,MAAM,MAAM,kCAAkC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wCAAwC,CAAC,CAAC;AAChH,MAAM,MAAM,uCAAuC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,6CAA6C,CAAC,CAAC;AAC1H,MAAM,MAAM,kDAAkD,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wDAAwD,CAAC,CAAC;AAChJ,MAAM,MAAM,yCAAyC,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,+CAA+C,CAAC,CAAC;AAC9H,MAAM,MAAM,kDAAkD,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wDAAwD,CAAC,CAAC;AAChJ,MAAM,MAAM,kDAAkD,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,wDAAwD,CAAC,CAAC;AAChJ,MAAM,MAAM,8CAA8C,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oDAAoD,CAAC,CAAC;AACxI,MAAM,MAAM,mDAAmD,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,yDAAyD,CAAC,CAAC"}

package/dist/type/valibot/walletRequest/WalletRequestEncoder.d.ts

@@ -0,0 +1,12 @@
+import { WalletRequest, WalletResponse } from './walletRequests';
+export declare class WalletRequestEncoder {
+    static encodeRequest(request: WalletRequest): Uint8Array;
+    static decodeRequest(data: Uint8Array): WalletRequest;
+    static encodeResponse(response: WalletResponse): Uint8Array;
+    static decodeResponse(data: Uint8Array): WalletResponse;
+}
+export declare class WalletRequestValidation {
+    static validateWalletRequest(request: object): WalletRequest;
+    static validateWalletResponse(response: object): WalletResponse;
+}
+//# sourceMappingURL=WalletRequestEncoder.d.ts.map

package/dist/type/valibot/walletRequest/WalletRequestEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WalletRequestEncoder.d.ts","sourceRoot":"","sources":["../../../../src/type/valibot/walletRequest/WalletRequestEncoder.ts"],"names":[],"mappings":"AAEA,OAAO,EACH,aAAa,EAEb,cAAc,EAEjB,MAAM,kBAAkB,CAAC;AAE1B,qBAAa,oBAAoB;IAC7B,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,UAAU;IAIxD,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,UAAU,GAAG,aAAa;IAIrD,MAAM,CAAC,cAAc,CAAC,QAAQ,EAAE,cAAc,GAAG,UAAU;IAI3D,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,cAAc;CAI1D;AAED,qBAAa,uBAAuB;IAChC,MAAM,CAAC,qBAAqB,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa;IAI5D,MAAM,CAAC,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,cAAc;CAGlE"}

package/dist/type/valibot/walletRequest/walletRequests.d.ts

@@ -0,0 +1,54 @@
+import * as v from 'valibot';
+export declare enum WalletRequestType {
+    AUTH_BY_PUBLIC_KEY = "WALLET_REQUEST_AUTH_BY_PUBLIC_KEY",
+    DATA_APPROVAL = "WALLET_REQUEST_DATA_APPROVAL"
+}
+export declare enum WalletResponseType {
+    AUTH_BY_PUBLIC_KEY = "WALLET_RESPONSE_AUTH_BY_PUBLIC_KEY",
+    DATA_APPROVAL = "WALLET_RESPONSE_DATA_APPROVAL"
+}
+export declare const WalletRequestAuthByPublicKeySchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletRequestType.AUTH_BY_PUBLIC_KEY, undefined>;
+    readonly base64EncodedChallenge: v.StringSchema<undefined>;
+}, undefined>;
+export declare const WalletRequestDataApprovalSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletRequestType.DATA_APPROVAL, undefined>;
+    readonly anchorRequestId: v.StringSchema<undefined>;
+    readonly serverUrl: v.StringSchema<undefined>;
+}, undefined>;
+export declare const WalletRequestSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletRequestType.AUTH_BY_PUBLIC_KEY, undefined>;
+    readonly base64EncodedChallenge: v.StringSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletRequestType.DATA_APPROVAL, undefined>;
+    readonly anchorRequestId: v.StringSchema<undefined>;
+    readonly serverUrl: v.StringSchema<undefined>;
+}, undefined>], undefined>;
+export declare const WalletResponseAuthByPublicKeySchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletResponseType.AUTH_BY_PUBLIC_KEY, undefined>;
+    readonly publicKey: v.StringSchema<undefined>;
+    readonly signature: v.StringSchema<undefined>;
+}, undefined>;
+export declare const WalletResponseDataApprovalSchema: v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletResponseType.DATA_APPROVAL, undefined>;
+    readonly b64VbHash: v.StringSchema<undefined>;
+    readonly b64MbHash: v.StringSchema<undefined>;
+    readonly height: v.NumberSchema<undefined>;
+}, undefined>;
+export declare const WalletResponseSchema: v.VariantSchema<"type", [v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletResponseType.AUTH_BY_PUBLIC_KEY, undefined>;
+    readonly publicKey: v.StringSchema<undefined>;
+    readonly signature: v.StringSchema<undefined>;
+}, undefined>, v.ObjectSchema<{
+    readonly type: v.LiteralSchema<WalletResponseType.DATA_APPROVAL, undefined>;
+    readonly b64VbHash: v.StringSchema<undefined>;
+    readonly b64MbHash: v.StringSchema<undefined>;
+    readonly height: v.NumberSchema<undefined>;
+}, undefined>], undefined>;
+export type WalletRequest = v.InferOutput<typeof WalletRequestSchema>;
+export type WalletRequestAuthByPublicKey = v.InferOutput<typeof WalletRequestAuthByPublicKeySchema>;
+export type WalletRequestDataApproval = v.InferOutput<typeof WalletRequestDataApprovalSchema>;
+export type WalletResponse = v.InferOutput<typeof WalletResponseSchema>;
+export type WalletResponseAuthByPublicKey = v.InferOutput<typeof WalletResponseAuthByPublicKeySchema>;
+export type WalletResponseDataApproval = v.InferOutput<typeof WalletResponseDataApprovalSchema>;
+//# sourceMappingURL=walletRequests.d.ts.map

package/dist/type/valibot/walletRequest/walletRequests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walletRequests.d.ts","sourceRoot":"","sources":["../../../../src/type/valibot/walletRequest/walletRequests.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAI7B,oBAAY,iBAAiB;IACzB,kBAAkB,sCAAsC;IACxD,aAAa,iCAAiC;CACjD;AAGD,oBAAY,kBAAkB;IAC1B,kBAAkB,uCAAuC;IACzD,aAAa,kCAAkC;CAClD;AAGD,eAAO,MAAM,kCAAkC;;;aAG7C,CAAC;AAEH,eAAO,MAAM,+BAA+B;;;;aAI1C,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;0BAG9B,CAAC;AAGH,eAAO,MAAM,mCAAmC;;;;aAI9C,CAAC;AAEH,eAAO,MAAM,gCAAgC;;;;;aAK3C,CAAC;AAIH,eAAO,MAAM,oBAAoB;;;;;;;;;0BAG/B,CAAC;AAGH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACtE,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,kCAAkC,CAAC,CAAC;AACpG,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAG9F,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,oBAAoB,CAAC,CAAC;AACxE,MAAM,MAAM,6BAA6B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mCAAmC,CAAC,CAAC;AACtG,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,gCAAgC,CAAC,CAAC"}

package/dist/utils/AbciQueryEncoder.d.ts

@@ -0,0 +1,9 @@
+import { AbciRequest } from '../type/valibot/provider/abci/AbciRequest';
+import { AbciResponse } from '../type/valibot/provider/abci/AbciResponse';
+export declare class AbciQueryEncoder {
+    static encodeAbciRequest(request: AbciRequest): Uint8Array;
+    static decodeAbciRequest(request: Uint8Array): AbciRequest;
+    static encodeAbciResponse(response: AbciResponse): Uint8Array;
+    static decodeAbciResponse(response: Uint8Array): AbciResponse;
+}
+//# sourceMappingURL=AbciQueryEncoder.d.ts.map

package/dist/utils/AbciQueryEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbciQueryEncoder.d.ts","sourceRoot":"","sources":["../../src/utils/AbciQueryEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAoB,MAAM,2CAA2C,CAAC;AAEzF,OAAO,EAAC,YAAY,EAAqB,MAAM,4CAA4C,CAAC;AAI5F,qBAAa,gBAAgB;IACzB,MAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,UAAU;IAI1D,MAAM,CAAC,iBAAiB,CAAC,OAAO,EAAE,UAAU,GAAG,WAAW;IAI1D,MAAM,CAAC,kBAAkB,CAAC,QAAQ,EAAE,YAAY,GAAG,UAAU;IAI7D,MAAM,CAAC,kBAAkB,CAAC,QAAQ,EAAE,UAAU,GAAG,YAAY;CAIhE"}

package/dist/utils/AccountSeedEncoder.d.ts

@@ -0,0 +1,5 @@
+import { SeedEncoder } from './SeedEncoder';
+export declare class AccountSeedEncoder extends SeedEncoder {
+    protected getPrefix(): string[];
+}
+//# sourceMappingURL=AccountSeedEncoder.d.ts.map

package/dist/utils/AccountSeedEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccountSeedEncoder.d.ts","sourceRoot":"","sources":["../../src/utils/AccountSeedEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAE1C,qBAAa,kBAAmB,SAAQ,WAAW;IAC/C,SAAS,CAAC,SAAS,IAAI,MAAM,EAAE;CAGlC"}

package/dist/utils/AccountTransactions.d.ts

@@ -0,0 +1,94 @@
+import { CMTSToken } from '../economics/currencies/token';
+import { Height } from '../type/Height';
+import { AccountHistoryAbciResponse } from '../type/valibot/provider/abci/AbciResponse';
+import { AccountHistoryEntry, AccountHistory } from '../type/valibot/account/Account';
+import { Hash } from '../entities/Hash';
+export declare class AccountTransactions {
+    private readonly transactions;
+    static createFromAbciResponse(response: AccountHistoryAbciResponse): AccountTransactions;
+    constructor(transactions: AccountHistory);
+    containsTransactions(): boolean;
+    getTransactions(): AccountTransaction[];
+}
+export declare class AccountTransaction {
+    private readonly transaction;
+    constructor(transaction: AccountHistoryEntry);
+    getHeight(): Height;
+    getPreviousHistoryHash(): Hash;
+    getTimestamp(): number;
+    transferredAt(): Date;
+    getTransactionTypeLabel(): "Sale" | "Purchase" | "Sent payment" | "Received payment" | "Earned fees" | "Paid fees" | "Sent issuance" | "Received issuance" | "Transaction";
+    /**
+     * Retrieves the linked account associated with the transaction.
+     *
+     * @return {Hash} The hash object representing the linked account.
+     */
+    getLinkedAccount(): Hash;
+    getAmount(): CMTSToken;
+    getChainReference(): Hash;
+    /**
+     * Determines if the transaction is for a positive (or zero) amount.
+     *
+     * @return {boolean} True if the transaction amount is positive (or zero), otherwise false.
+     */
+    isPositive(): boolean;
+    /**
+     * Determines if the transaction is for a negative amount.
+     *
+     * @return {boolean} True if the transaction amount is negative, otherwise false.
+     */
+    isNegative(): boolean;
+    /**
+     * Determines whether the transaction is categorized as earned fees.
+     *
+     * @return {boolean} Returns true if the transaction is earned fees, otherwise false.
+     */
+    isEarnedFees(): boolean;
+    isEarnedBlockFees(): boolean;
+    isEarnedTxFees(): boolean;
+    isPaidBlockFees(): boolean;
+    isPaidTxFees(): boolean;
+    /**
+     * Determines whether the transaction is categorized as issuance receiving.
+     *
+     * Note: This method is only applicable to the genesis account receiving the initial issuance.
+     *
+     * @return {boolean} Returns true if the transaction is earned fees, otherwise false.
+     */
+    isReceivedIssuance(): boolean;
+    isSentIssuance(): boolean;
+    /**
+     * Determines whether the transaction is categorized as a sale.
+     *
+     * Note: A transaction categorized as a sale is only applicable to the genesis account sending tokens to an account.
+     *
+     * @return {boolean} Returns true if the transaction is sale, otherwise false.
+     */
+    isSale(): boolean;
+    /**
+     * Determines whether the transaction is categorized as a sent payment.
+     *
+     * Payments occur between two accounts (distinct from the genesis account).
+     *
+     * @return {boolean} Returns true if the transaction is a sent payment, otherwise false.
+     */
+    isSentPayment(): boolean;
+    isPaidFees(): boolean;
+    /**
+     * Determines whether the transaction is categorized as a purchase.
+     *
+     * Note: A transaction categorized as a purchase is only applicable to an account receiving tokens from the genesis account.
+     *
+     * @return {boolean} Returns true if the transaction is purchase, otherwise false.
+     */
+    isPurchase(): boolean;
+    /**
+     * Determines whether the transaction is categorized as a received payment.
+     *
+     * Payments occur between two accounts (distinct from the genesis account).
+     *
+     * @return {boolean} Returns true if the transaction is a received payment, otherwise false.
+     */
+    isReceivedPayment(): boolean;
+}
+//# sourceMappingURL=AccountTransactions.d.ts.map

package/dist/utils/AccountTransactions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccountTransactions.d.ts","sourceRoot":"","sources":["../../src/utils/AccountTransactions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAC,MAAM,+BAA+B,CAAC;AAYxD,OAAO,EAAC,MAAM,EAAC,MAAM,gBAAgB,CAAC;AACtC,OAAO,EAAC,0BAA0B,EAAC,MAAM,4CAA4C,CAAC;AACtF,OAAO,EAAC,mBAAmB,EAAE,cAAc,EAAC,MAAM,iCAAiC,CAAC;AACpF,OAAO,EAAC,IAAI,EAAC,MAAM,kBAAkB,CAAC;AAEtC,qBAAa,mBAAmB;IAKhB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAJzC,MAAM,CAAC,sBAAsB,CAAC,QAAQ,EAAE,0BAA0B;gBAIrC,YAAY,EAAE,cAAc;IAGzD,oBAAoB,IAAI,OAAO;IAI/B,eAAe,IAAI,kBAAkB,EAAE;CAG1C;AAED,qBAAa,kBAAkB;IAEvB,OAAO,CAAC,QAAQ,CAAC,WAAW;gBAAX,WAAW,EAAE,mBAAmB;IAG9C,SAAS,IAAI,MAAM;IAInB,sBAAsB,IAAI,IAAI;IAI9B,YAAY,IAAI,MAAM;IAItB,aAAa,IAAI,IAAI;IAIrB,uBAAuB;IAY9B;;;;OAIG;IACI,gBAAgB,IAAI,IAAI;IAIxB,SAAS,IAAI,SAAS;IAKtB,iBAAiB,IAAI,IAAI;IAIhC;;;;OAIG;IACI,UAAU,IAAI,OAAO;IAI5B;;;;OAIG;IACI,UAAU,IAAI,OAAO;IAI5B;;;;OAIG;IACI,YAAY,IAAI,OAAO;IAIvB,iBAAiB,IAAI,OAAO;IAI5B,cAAc,IAAI,OAAO;IAIzB,eAAe,IAAI,OAAO;IAI1B,YAAY,IAAI,OAAO;IAI9B;;;;;;OAMG;IACI,kBAAkB,IAAI,OAAO;IAI7B,cAAc,IAAI,OAAO;IAIhC;;;;;;OAMG;IACI,MAAM,IAAI,OAAO;IAIxB;;;;;;OAMG;IACI,aAAa,IAAI,OAAO;IAIxB,UAAU,IAAI,OAAO;IAI5B;;;;;;OAMG;IACI,UAAU,IAAI,OAAO;IAI5B;;;;;;OAMG;IACI,iBAAiB,IAAI,OAAO;CAGtC"}

package/dist/utils/ActorSeedEncoder.d.ts

@@ -0,0 +1,5 @@
+import { SeedEncoder } from './SeedEncoder';
+export declare class ActorSeedEncoder extends SeedEncoder {
+    protected getPrefix(): string[];
+}
+//# sourceMappingURL=ActorSeedEncoder.d.ts.map

package/dist/utils/ActorSeedEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ActorSeedEncoder.d.ts","sourceRoot":"","sources":["../../src/utils/ActorSeedEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,eAAe,CAAC;AAE1C,qBAAa,gBAAiB,SAAQ,WAAW;IAC7C,SAAS,CAAC,SAAS,IAAI,MAAM,EAAE;CAGlC"}

package/dist/utils/Assertion.d.ts

@@ -0,0 +1,4 @@
+export declare class Assertion {
+    static assert(isVerified: boolean, messageOnUnverified?: string): void;
+}
+//# sourceMappingURL=Assertion.d.ts.map

package/dist/utils/Assertion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Assertion.d.ts","sourceRoot":"","sources":["../../src/utils/Assertion.ts"],"names":[],"mappings":"AAEA,qBAAa,SAAS;IAClB,MAAM,CAAC,MAAM,CAAC,UAAU,EAAE,OAAO,EAAE,mBAAmB,GAAE,MAAmC;CAG9F"}

package/dist/utils/BalanceAvailability.d.ts

@@ -0,0 +1,207 @@
+import { LockType, EscrowParameters, VestingParameters, Lock, AccountBreakdown } from '../type/valibot/account/Account';
+import { CMTSToken } from '../economics/currencies/token';
+import { AccountStateAbciResponse } from '../type/valibot/provider/abci/AbciResponse';
+/**
+ * This class models the availability of tokens for a given account.
+ *
+ * It keeps track of the balance, the locks (escrow, vesting and staking) and provides methods to add, remove and query tokens.
+ */
+export declare class BalanceAvailability {
+    private initialBalance;
+    private initialLocks;
+    static createFromAccountStateAbciResponse(accountStateResponse: AccountStateAbciResponse): BalanceAvailability;
+    private readonly logger;
+    /**
+     * The balance of the account.
+     * @private
+     */
+    private balanceInAtomics;
+    /**
+     * The set of locks on the account.
+     * @private
+     */
+    private locks;
+    /**
+     * By default, the balance is 0 and there are no locks.
+     */
+    constructor(initialBalance?: number, initialLocks?: Lock[]);
+    /**
+     * Getters and setters for balance and locks.
+     */
+    setBalance(balance: number): void;
+    getBalanceAsAtomics(): number;
+    getBalance(): CMTSToken;
+    setLocks(locks: Lock[]): void;
+    getLocks(): ({
+        type: LockType.Escrow;
+        lockedAmountInAtomics: number;
+        parameters: {
+            escrowIdentifier: Uint8Array<ArrayBufferLike>;
+            fundEmitterAccountId: Uint8Array<ArrayBufferLike>;
+            transferAuthorizerAccountId: Uint8Array<ArrayBufferLike>;
+            startTimestamp: number;
+            durationDays: number;
+        };
+    } | {
+        type: LockType.Vesting;
+        lockedAmountInAtomics: number;
+        parameters: {
+            initialVestedAmountInAtomics: number;
+            cliffStartTimestamp: number;
+            cliffDurationDays: number;
+            vestingDurationDays: number;
+        };
+    } | {
+        type: LockType.NodeStaking;
+        lockedAmountInAtomics: number;
+        parameters: {
+            validatorNodeId: Uint8Array<ArrayBufferLike>;
+            plannedUnlockAmountInAtomics: number;
+            plannedUnlockTimestamp: number;
+            slashed: boolean;
+            plannedSlashingAmountInAtomics: number;
+            plannedSlashingTimestamp: number;
+        };
+    })[];
+    hasNodeStakingLocks(): boolean;
+    getNodeStakingLocks(): {
+        type: LockType.NodeStaking;
+        lockedAmountInAtomics: number;
+        parameters: {
+            validatorNodeId: Uint8Array<ArrayBufferLike>;
+            plannedUnlockAmountInAtomics: number;
+            plannedUnlockTimestamp: number;
+            slashed: boolean;
+            plannedSlashingAmountInAtomics: number;
+            plannedSlashingTimestamp: number;
+        };
+    }[];
+    getNodeStakingLock(nodeId: Uint8Array): {
+        type: LockType.NodeStaking;
+        lockedAmountInAtomics: number;
+        parameters: {
+            validatorNodeId: Uint8Array<ArrayBufferLike>;
+            plannedUnlockAmountInAtomics: number;
+            plannedUnlockTimestamp: number;
+            slashed: boolean;
+            plannedSlashingAmountInAtomics: number;
+            plannedSlashingTimestamp: number;
+        };
+    } | undefined;
+    getNodeStakingLockOrFail(nodeId: Uint8Array): {
+        type: LockType.NodeStaking;
+        lockedAmountInAtomics: number;
+        parameters: {
+            validatorNodeId: Uint8Array<ArrayBufferLike>;
+            plannedUnlockAmountInAtomics: number;
+            plannedUnlockTimestamp: number;
+            slashed: boolean;
+            plannedSlashingAmountInAtomics: number;
+            plannedSlashingTimestamp: number;
+        };
+    };
+    getNodeStakingLockAmount(nodeAccountId: Uint8Array): number;
+    hasEscrowLocks(): boolean;
+    getEscrowLocks(): {
+        type: LockType.Escrow;
+        lockedAmountInAtomics: number;
+        parameters: {
+            escrowIdentifier: Uint8Array<ArrayBufferLike>;
+            fundEmitterAccountId: Uint8Array<ArrayBufferLike>;
+            transferAuthorizerAccountId: Uint8Array<ArrayBufferLike>;
+            startTimestamp: number;
+            durationDays: number;
+        };
+    }[];
+    hasVestingLocks(): boolean;
+    getVestingLocks(): {
+        type: LockType.Vesting;
+        lockedAmountInAtomics: number;
+        parameters: {
+            initialVestedAmountInAtomics: number;
+            cliffStartTimestamp: number;
+            cliffDurationDays: number;
+            vestingDurationDays: number;
+        };
+    }[];
+    /**
+     * Methods to remove expired locks (i.e. with a locked amount set to 0)
+     */
+    private removeExpiredEscrowLocks;
+    private removeExpiredVestingLocks;
+    private removeExpiredStakingLocks;
+    private removeExpiredLocks;
+    /**
+     * Adds a given amount of spendable tokens.
+     */
+    addSpendableTokens(amountInAtomics: number): void;
+    /**
+     * Adds vested tokens, given an amount, a start time as a timestamp in seconds, a cliff duration in days and a vesting duration in days.
+     */
+    addVestedTokens(initialVestedAmountInAtomics: number, vestingParameters: VestingParameters): void;
+    /**
+     * Adds escrowed tokens, given an amount, an escrow identifier and an agent public key.
+     */
+    addEscrowedTokens(lockedAmountInAtomics: number, escrowParameters: EscrowParameters): void;
+    /**
+     * Removes an escrow lock, given its identifier.
+     */
+    removeEscrowLock(escrowIdentifier: Uint8Array): number;
+    /**
+     * Stakes a given amount of tokens for a given node.
+     * If a staking is already defined for this node, the new amount is added to the current staked amount.
+     */
+    addNodeStaking(amountInAtomics: number, nodeId: Uint8Array): void;
+    /**
+     * Sets a plan to unlock staked tokens for a given node.
+     */
+    planNodeStakingUnlock(plannedUnlockAmountInAtomics: number, plannedUnlockTimestamp: number, nodeAccountId: Uint8Array): void;
+    /**
+     * Applies node staking unlocks for which the planned date has been reached (or exceeded).
+     */
+    applyNodeStakingUnlocks(referenceTimestamp: number): number;
+    /**
+     * Sets slashing for a given node.
+     */
+    setSlashing(nodeId: Uint8Array, plannedTimestamp: number): void;
+    /**
+     * Cancels slashing for a given node.
+     */
+    cancelNodeSlashing(nodeId: Uint8Array): void;
+    /**
+     * Applies slashing.
+     */
+    applyNodeSlashing(referenceTimestamp: number): number;
+    /**
+     * Adjusts vesting locks so that the total amount of vested tokens doesn't exceed the balance.
+     * This applies when vested tokens are slashed.
+     * Some vesting locks may be removed entirely.
+     */
+    adjustVesting(): void;
+    /**
+     * Unstakes tokens for a given node.
+     */
+    private removeNodeStaking;
+    /**
+     * Releases all vesting tokens that should be unlocked as of the given time.
+     *
+     * This applies the full vesting schedule up to `time`, including any tokens
+     * that would have been released earlier but could not be (typically because
+     * they were temporarily locked by staking or other constraints).
+     *
+     * Each vesting lock is updated independently, but release is capped by the
+     * globally releasable amount for this account at the current time.
+     *
+     * Returns the total released amount.
+     */
+    applyLinearVesting(referenceTimestamp: number): number;
+    /**
+     * Returns the breakdown of the account balance.
+     */
+    getBreakdown(): AccountBreakdown;
+    getSpendable(): CMTSToken;
+    getVested(): CMTSToken;
+    getStakeable(): CMTSToken;
+    getStaked(): CMTSToken;
+}
+//# sourceMappingURL=BalanceAvailability.d.ts.map

package/dist/utils/BalanceAvailability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BalanceAvailability.d.ts","sourceRoot":"","sources":["../../src/utils/BalanceAvailability.ts"],"names":[],"mappings":"AACA,OAAO,EACH,QAAQ,EACR,gBAAgB,EAChB,iBAAiB,EACjB,IAAI,EAEJ,gBAAgB,EACnB,MAAM,iCAAiC,CAAC;AAEzC,OAAO,EAAC,SAAS,EAAC,MAAM,+BAA+B,CAAC;AACxD,OAAO,EAAC,wBAAwB,EAAC,MAAM,4CAA4C,CAAC;AAGpF;;;;GAIG;AACH,qBAAa,mBAAmB;IA2BhB,OAAO,CAAC,cAAc;IAAc,OAAO,CAAC,YAAY;WAzBtD,kCAAkC,CAAC,oBAAoB,EAAE,wBAAwB,GAAG,mBAAmB;IAOrH,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA8D;IAErF;;;OAGG;IACH,OAAO,CAAC,gBAAgB,CAAS;IAEjC;;;OAGG;IACH,OAAO,CAAC,KAAK,CAAS;IAGtB;;OAEG;gBACiB,cAAc,GAAE,MAAU,EAAU,YAAY,GAAE,IAAI,EAAO;IAKjF;;OAEG;IACH,UAAU,CAAC,OAAO,EAAE,MAAM;IAI1B,mBAAmB;IAInB,UAAU;IAIV,QAAQ,CAAC,KAAK,EAAE,IAAI,EAAE;IAItB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAIR,mBAAmB;IAInB,mBAAmB;;;;;;;;;;;;IAInB,kBAAkB,CAAC,MAAM,EAAE,UAAU;;;;;;;;;;;;IAQrC,wBAAwB,CAAC,MAAM,EAAE,UAAU;;;;;;;;;;;;IAQ3C,wBAAwB,CAAC,aAAa,EAAE,UAAU;IAQlD,cAAc;IAId,cAAc;;;;;;;;;;;IAId,eAAe;IAIf,eAAe;;;;;;;;;;IAIf;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAIhC,OAAO,CAAC,yBAAyB;IAIjC,OAAO,CAAC,yBAAyB;IAIjC,OAAO,CAAC,kBAAkB;IAI1B;;OAEG;IACH,kBAAkB,CAAC,eAAe,EAAE,MAAM;IAI1C;;OAEG;IACH,eAAe,CAAC,4BAA4B,EAAE,MAAM,EAAE,iBAAiB,EAAE,iBAAiB;IAY1F;;OAEG;IACH,iBAAiB,CAAC,qBAAqB,EAAE,MAAM,EAAE,gBAAgB,EAAE,gBAAgB;IAYnF;;OAEG;IACH,gBAAgB,CAAC,gBAAgB,EAAE,UAAU;IAe7C;;;OAGG;IACH,cAAc,CAAC,eAAe,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU;IAwC1D;;OAEG;IACH,qBAAqB,CAAC,4BAA4B,EAAE,MAAM,EAAE,sBAAsB,EAAE,MAAM,EAAE,aAAa,EAAE,UAAU;IAerH;;OAEG;IACH,uBAAuB,CAAC,kBAAkB,EAAE,MAAM;IAqBlD;;OAEG;IACH,WAAW,CAAC,MAAM,EAAE,UAAU,EAAE,gBAAgB,EAAE,MAAM;IAaxD;;OAEG;IACH,kBAAkB,CAAC,MAAM,EAAE,UAAU;IAgBrC;;OAEG;IACH,iBAAiB,CAAC,kBAAkB,EAAE,MAAM;IA8B5C;;;;OAIG;IACH,aAAa;IA2Bb;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAazB;;;;;;;;;;;OAWG;IACH,kBAAkB,CAAC,kBAAkB,EAAE,MAAM;IAwD7C;;OAEG;IACH,YAAY,IAAI,gBAAgB;IAyChC,YAAY;IAIZ,SAAS;IAIT,YAAY;IAIZ,SAAS;CAGZ"}

package/dist/utils/BinaryToStringEncoderInterface.d.ts

@@ -0,0 +1,4 @@
+import { EncoderInterface } from './encoder';
+export interface BinaryToStringEncoderInterface extends EncoderInterface<Uint8Array, string> {
+}
+//# sourceMappingURL=BinaryToStringEncoderInterface.d.ts.map

package/dist/utils/BinaryToStringEncoderInterface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BinaryToStringEncoderInterface.d.ts","sourceRoot":"","sources":["../../src/utils/BinaryToStringEncoderInterface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,gBAAgB,EAAC,MAAM,WAAW,CAAC;AAE3C,MAAM,WAAW,8BAA+B,SAAQ,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC;CAAG"}

package/dist/utils/BlockchainUtils.d.ts

@@ -0,0 +1,69 @@
+import { MicroblockHeader } from '../type/valibot/blockchain/microblock/MicroblockHeader';
+import { MicroblockBody } from '../type/valibot/blockchain/microblock/MicroblockBody';
+import { VirtualBlockchainState } from '../type/valibot/blockchain/virtualBlockchain/virtualBlockchains';
+import { Section } from '../type/valibot/blockchain/section/sections';
+import { VirtualBlockchainInfo } from '../type/valibot/provider/VirtualBlockchainInfo';
+import { MicroblockInformation } from '../type/valibot/provider/MicroblockInformationSchema';
+import { AccountBreakdown, AccountInformation, AccountState, EscrowLock, EscrowParameters, Lock, NodeStakingLock, NodeStakingParameters, VestingLock, VestingParameters } from '../type/valibot/account/Account';
+export declare class BlockchainUtils {
+    private static encoder;
+    private static logger;
+    static computeMicroblockHashFromHeader(header: MicroblockHeader): Uint8Array<ArrayBufferLike>;
+    /**
+      Takes a list of consecutive microblock headers in binary format and in anti-chronological order.
+      Returns an object with a flag telling if the hash chain is valid and the list of microblock hashes (also in anti-chronological order).
+    */
+    static checkHeaderList(serializedHeaders: Uint8Array[]): {
+        valid: boolean;
+        hashes: Uint8Array<ArrayBufferLike>[];
+    };
+    /**
+      Extracts the 'previousHash' field from a microblock header in binary format.
+    */
+    static previousHashFromHeader(serializedHeader: Uint8Array): Uint8Array<ArrayBufferLike>;
+    static encodeVirtualBlockchainInfo(virtualBlockchainInfo: VirtualBlockchainInfo): Uint8Array;
+    static decodeVirtualBlockchainInfo(serializedInfo: Uint8Array): VirtualBlockchainInfo;
+    /**
+     *
+     * @param vbState
+     */
+    static encodeVirtualBlockchainState(vbState: VirtualBlockchainState): Uint8Array<ArrayBufferLike>;
+    /**
+     * Decodes a virtual blockchain state object from the given binary data.
+     *
+     * @param {Uint8Array} serializedVirtualBlockchainState The binary encoded virtual blockchain state data.
+     * @return {VirtualBlockchainState} The decoded virtual blockchain state object.
+     */
+    static decodeVirtualBlockchainState(serializedVirtualBlockchainState: Uint8Array): VirtualBlockchainState;
+    static encodeMicroblockBody(body: MicroblockBody): Uint8Array;
+    static decodeMicroblockBody(serializedBody: Uint8Array): MicroblockBody;
+    static encodeSection(section: Section): Uint8Array<ArrayBufferLike>;
+    static decodeSection(serializedSection: Uint8Array): Section;
+    static encodeMicroblockHeader(header: MicroblockHeader): Uint8Array;
+    static decodeMicroblockHeader(serializedHeader: Uint8Array): MicroblockHeader;
+    static encodeEscrowParameters(escrowParameters: EscrowParameters): Uint8Array<ArrayBufferLike>;
+    static decodeEscrowParameters(serializedEscrowParameters: Uint8Array): EscrowParameters;
+    static encodeEscrowLock(escrowLock: EscrowLock): Uint8Array<ArrayBufferLike>;
+    static decodeEscrowLock(serializedEscrowLock: Uint8Array): EscrowLock;
+    static encodeVestingParameters(vestingParameters: VestingParameters): Uint8Array<ArrayBufferLike>;
+    static decodeVestingParameters(serializedVestingParameters: Uint8Array): VestingParameters;
+    static encodeVestingLock(vestingLock: VestingLock): Uint8Array<ArrayBufferLike>;
+    static decodeVestingLock(serializedVestingLock: Uint8Array): VestingLock;
+    static encodeNodeStakingParameters(nodeStakingParameters: NodeStakingParameters): Uint8Array<ArrayBufferLike>;
+    static decodeNodeStakingParameters(serializedNodeStakingParameters: Uint8Array): NodeStakingParameters;
+    static encodeNodeStakingLock(nodeStakingLock: NodeStakingLock): Uint8Array<ArrayBufferLike>;
+    static decodeNodeStakingLock(serializedNodeStakingLock: Uint8Array): NodeStakingLock;
+    static encodeLock(lock: Lock): Uint8Array<ArrayBufferLike>;
+    static decodeLock(serializedLock: Uint8Array): Lock;
+    static encodeAccountBreakdown(accountBreakdown: AccountBreakdown): Uint8Array<ArrayBufferLike>;
+    static decodeAccountBreakdown(serializedAccountBreakdown: Uint8Array): AccountBreakdown;
+    static encodeAccountState(accountState: AccountState): Uint8Array<ArrayBufferLike>;
+    static decodeAccountState(serializedAccountState: Uint8Array): AccountState;
+    static encodeAccountInformation(accountInformation: AccountInformation): Uint8Array<ArrayBufferLike>;
+    static decodeAccountInformation(serializedAccountInformation: Uint8Array): AccountInformation;
+    static encodeMicroblockInformation(microblockInformation: MicroblockInformation): Uint8Array<ArrayBufferLike>;
+    static decodeMicroblockInformation(serializedMicroblockInformation: Uint8Array): MicroblockInformation;
+    private static encodeObjectToBinary;
+    private static decodeObjectFromBinary;
+}
+//# sourceMappingURL=BlockchainUtils.d.ts.map

package/dist/utils/BlockchainUtils.d.ts.map

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

package/dist/utils/CometBFTPublicKeyConverter.d.ts

@@ -0,0 +1,4 @@
+export declare class CometBFTPublicKeyConverter {
+    static convertRawPublicKeyIntoAddress(publicKey: Uint8Array): Uint8Array;
+}
+//# sourceMappingURL=CometBFTPublicKeyConverter.d.ts.map

package/dist/utils/CometBFTPublicKeyConverter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"CometBFTPublicKeyConverter.d.ts","sourceRoot":"","sources":["../../src/utils/CometBFTPublicKeyConverter.ts"],"names":[],"mappings":"AAGA,qBAAa,0BAA0B;WACrB,8BAA8B,CAAC,SAAS,EAAE,UAAU,GAAG,UAAU;CAGlF"}