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

package/dist/providers/nodeRpc/NewBlockEventType.d.ts

@@ -0,0 +1,79 @@
+import * as v from "valibot";
+export declare const NewBlockEventSchema: v.ObjectSchema<{
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+    readonly id: v.NumberSchema<undefined>;
+    readonly result: v.ObjectSchema<{
+        readonly query: v.StringSchema<undefined>;
+        readonly data: v.ObjectSchema<{
+            readonly type: v.LiteralSchema<"tendermint/event/NewBlock", undefined>;
+            readonly value: v.ObjectSchema<{
+                readonly block: v.ObjectSchema<{
+                    readonly header: v.ObjectSchema<{
+                        readonly version: v.ObjectSchema<{
+                            readonly block: v.StringSchema<undefined>;
+                            readonly app: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                        }, undefined>;
+                        readonly chain_id: v.StringSchema<undefined>;
+                        readonly height: v.StringSchema<undefined>;
+                        readonly time: v.StringSchema<undefined>;
+                        readonly last_block_id: v.ObjectSchema<{
+                            readonly hash: v.StringSchema<undefined>;
+                            readonly parts: v.ObjectSchema<{
+                                readonly total: v.NumberSchema<undefined>;
+                                readonly hash: v.StringSchema<undefined>;
+                            }, undefined>;
+                        }, undefined>;
+                        readonly last_commit_hash: v.StringSchema<undefined>;
+                        readonly data_hash: v.StringSchema<undefined>;
+                        readonly validators_hash: v.StringSchema<undefined>;
+                        readonly next_validators_hash: v.StringSchema<undefined>;
+                        readonly consensus_hash: v.StringSchema<undefined>;
+                        readonly app_hash: v.StringSchema<undefined>;
+                        readonly last_results_hash: v.StringSchema<undefined>;
+                        readonly evidence_hash: v.StringSchema<undefined>;
+                        readonly proposer_address: v.StringSchema<undefined>;
+                    }, undefined>;
+                    readonly data: v.ObjectSchema<{
+                        readonly txs: v.ArraySchema<v.StringSchema<undefined>, undefined>;
+                    }, undefined>;
+                    readonly evidence: v.ObjectSchema<{
+                        readonly evidence: v.ArraySchema<v.AnySchema, undefined>;
+                    }, undefined>;
+                    readonly last_commit: v.ObjectSchema<{
+                        readonly height: v.StringSchema<undefined>;
+                        readonly round: v.NumberSchema<undefined>;
+                        readonly block_id: v.ObjectSchema<{
+                            readonly hash: v.StringSchema<undefined>;
+                            readonly parts: v.ObjectSchema<{
+                                readonly total: v.NumberSchema<undefined>;
+                                readonly hash: v.StringSchema<undefined>;
+                            }, undefined>;
+                        }, undefined>;
+                        readonly signatures: v.ArraySchema<v.ObjectSchema<{
+                            readonly block_id_flag: v.NumberSchema<undefined>;
+                            readonly validator_address: v.StringSchema<undefined>;
+                            readonly timestamp: v.StringSchema<undefined>;
+                            readonly signature: v.StringSchema<undefined>;
+                        }, undefined>, undefined>;
+                    }, undefined>;
+                }, undefined>;
+                readonly block_id: v.ObjectSchema<{
+                    readonly hash: v.StringSchema<undefined>;
+                    readonly parts: v.ObjectSchema<{
+                        readonly total: v.NumberSchema<undefined>;
+                        readonly hash: v.StringSchema<undefined>;
+                    }, undefined>;
+                }, undefined>;
+                readonly result_finalize_block: v.ObjectSchema<{
+                    readonly validator_updates: v.OptionalSchema<v.UnionSchema<[v.NullSchema<undefined>, v.AnySchema], undefined>, undefined>;
+                    readonly app_hash: v.StringSchema<undefined>;
+                }, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly events: v.ObjectSchema<{
+            readonly "tm.event": v.ArraySchema<v.StringSchema<undefined>, undefined>;
+        }, undefined>;
+    }, undefined>;
+}, undefined>;
+export type NewBlockEventType = v.InferOutput<typeof NewBlockEventSchema>;
+//# sourceMappingURL=NewBlockEventType.d.ts.map

package/dist/providers/nodeRpc/NewBlockEventType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NewBlockEventType.d.ts","sourceRoot":"","sources":["../../../src/providers/nodeRpc/NewBlockEventType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA6E9B,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/providers/nodeRpc/RPCNodeStatusResponseSchema.d.ts

@@ -0,0 +1,45 @@
+import * as v from "valibot";
+export declare const RPCNodeStatusResponseSchema: v.ObjectSchema<{
+    readonly jsonrpc: v.LiteralSchema<"2.0", undefined>;
+    readonly id: v.NumberSchema<undefined>;
+    readonly result: v.ObjectSchema<{
+        readonly node_info: v.ObjectSchema<{
+            readonly protocol_version: v.ObjectSchema<{
+                readonly p2p: v.StringSchema<undefined>;
+                readonly block: v.StringSchema<undefined>;
+                readonly app: v.StringSchema<undefined>;
+            }, undefined>;
+            readonly id: v.StringSchema<undefined>;
+            readonly listen_addr: v.StringSchema<undefined>;
+            readonly network: v.StringSchema<undefined>;
+            readonly version: v.StringSchema<undefined>;
+            readonly channels: v.StringSchema<undefined>;
+            readonly moniker: v.StringSchema<undefined>;
+            readonly other: v.ObjectSchema<{
+                readonly tx_index: v.StringSchema<undefined>;
+                readonly rpc_address: v.StringSchema<undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly sync_info: v.ObjectSchema<{
+            readonly latest_block_hash: v.StringSchema<undefined>;
+            readonly latest_app_hash: v.StringSchema<undefined>;
+            readonly latest_block_height: v.StringSchema<undefined>;
+            readonly latest_block_time: v.StringSchema<undefined>;
+            readonly earliest_block_hash: v.StringSchema<undefined>;
+            readonly earliest_app_hash: v.StringSchema<undefined>;
+            readonly earliest_block_height: v.StringSchema<undefined>;
+            readonly earliest_block_time: v.StringSchema<undefined>;
+            readonly catching_up: v.BooleanSchema<undefined>;
+        }, undefined>;
+        readonly validator_info: v.ObjectSchema<{
+            readonly address: v.StringSchema<undefined>;
+            readonly pub_key: v.ObjectSchema<{
+                readonly type: v.StringSchema<undefined>;
+                readonly value: v.StringSchema<undefined>;
+            }, undefined>;
+            readonly voting_power: v.StringSchema<undefined>;
+        }, undefined>;
+    }, undefined>;
+}, undefined>;
+export type RPCNodeStatusResponseType = v.InferOutput<typeof RPCNodeStatusResponseSchema>;
+//# sourceMappingURL=RPCNodeStatusResponseSchema.d.ts.map

package/dist/providers/nodeRpc/RPCNodeStatusResponseSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RPCNodeStatusResponseSchema.d.ts","sourceRoot":"","sources":["../../../src/providers/nodeRpc/RPCNodeStatusResponseSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAE7B,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAyCtC,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,WAAW,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/providers/nodeRpc/RPCNodeWebSocketCallback.d.ts

@@ -0,0 +1,5 @@
+import { NewBlockEventType } from './NewBlockEventType';
+export type RPCNodeWebSocketCallback = {
+    onNewBlock?: (event: NewBlockEventType) => void;
+};
+//# sourceMappingURL=RPCNodeWebSocketCallback.d.ts.map

package/dist/providers/nodeRpc/RPCNodeWebSocketCallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RPCNodeWebSocketCallback.d.ts","sourceRoot":"","sources":["../../../src/providers/nodeRpc/RPCNodeWebSocketCallback.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,iBAAiB,EAAC,MAAM,qBAAqB,CAAC;AAGtD,MAAM,MAAM,wBAAwB,GACpC;IACI,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,iBAAiB,KAAK,IAAI,CAAA;CAClD,CAAA"}

package/dist/providers/serverNetworkProvider.d.ts

@@ -0,0 +1,5 @@
+import { NetworkProvider } from './NetworkProvider';
+export declare class ServerNetworkProvider extends NetworkProvider {
+    constructor(nodeUrl: any);
+}
+//# sourceMappingURL=serverNetworkProvider.d.ts.map

package/dist/providers/serverNetworkProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverNetworkProvider.d.ts","sourceRoot":"","sources":["../../src/providers/serverNetworkProvider.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAElD,qBAAa,qBAAsB,SAAQ,eAAe;gBAC5C,OAAO,EAAE,GAAG;CAGzB"}

package/dist/records/MerkleLeaf.d.ts

@@ -0,0 +1,27 @@
+import { SaltShaker } from './SaltShaker';
+import { Path, Item, PrimitiveValue, TypedPrimitiveValue, ProofField } from './types';
+export declare class MerkleLeaf {
+    private internalData;
+    private encoder;
+    static fromProofFormat(field: ProofField): MerkleLeaf;
+    static fromItemWithPublicData(item: Item): MerkleLeaf;
+    static fromItemWithPlainData(saltShaker: SaltShaker, item: Item): MerkleLeaf;
+    static fromItemWithHashedData(saltShaker: SaltShaker, item: Item): MerkleLeaf;
+    static fromItemWithMaskedData(saltShaker: SaltShaker, item: Item): MerkleLeaf;
+    private setPublicDataFromValue;
+    private setPlainDataFromValue;
+    private setHashedDataFromValue;
+    private setHashedDataFromHash;
+    private setMaskedDataFromAllParts;
+    private setMaskedDataFromVisibleParts;
+    setToHashed(): void;
+    setToMasked(): void;
+    private getInternalData;
+    private fromProofField;
+    toProofFormat(path: Path, index: number): ProofField;
+    private getCommitmentData;
+    getHash(): Uint8Array<ArrayBufferLike>;
+    getRawValue(): PrimitiveValue;
+    getTypedValue(): TypedPrimitiveValue;
+}
+//# sourceMappingURL=MerkleLeaf.d.ts.map

package/dist/records/MerkleLeaf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MerkleLeaf.d.ts","sourceRoot":"","sources":["../../src/records/MerkleLeaf.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AACxC,OAAO,EACH,IAAI,EACJ,IAAI,EACJ,cAAc,EACd,mBAAmB,EAMnB,UAAU,EACb,MAAM,SAAS,CAAC;AAGjB,qBAAa,UAAU;IACnB,OAAO,CAAC,YAAY,CAAyC;IAC7D,OAAO,CAAC,OAAO,CAAiC;IAEhD,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,UAAU;IAMxC,MAAM,CAAC,sBAAsB,CAAC,IAAI,EAAE,IAAI;IAMxC,MAAM,CAAC,qBAAqB,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI;IAO/D,MAAM,CAAC,sBAAsB,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI;IAOhE,MAAM,CAAC,sBAAsB,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,IAAI;IAchE,OAAO,CAAC,sBAAsB;IAO9B,OAAO,CAAC,qBAAqB;IAQ7B,OAAO,CAAC,sBAAsB;IAQ9B,OAAO,CAAC,qBAAqB;IAQ7B,OAAO,CAAC,yBAAyB;IAgBjC,OAAO,CAAC,6BAA6B;IAYrC,WAAW;IAcX,WAAW;IAcX,OAAO,CAAC,eAAe;IAOvB,OAAO,CAAC,cAAc;IAiDtB,aAAa,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU;IAiEpD,OAAO,CAAC,iBAAiB;IA+CzB,OAAO;IAOP,WAAW,IAAI,cAAc;IA0B7B,aAAa,IAAI,mBAAmB;CAsBvC"}

package/dist/records/MerkleRecord.d.ts

@@ -0,0 +1,20 @@
+import { RecordByChannels } from './RecordByChannels';
+export declare class MerkleRecord {
+    private channelMap;
+    private recordByChannels;
+    private publicChannels;
+    constructor();
+    static fromRecordByChannels(recordByChannels: RecordByChannels, peppers?: Map<number, Uint8Array> | undefined): MerkleRecord;
+    private setChannelsFromRecordByChannels;
+    private storeChannel;
+    getPublicChannels(): Set<number>;
+    getLeavesByChannelMap(): Map<any, any>;
+    getRecordByChannels(): RecordByChannels;
+    getChannelIds(): number[];
+    getChannelPepper(channelId: number): Uint8Array<ArrayBufferLike>;
+    getChannelRootHash(channelId: number): Uint8Array<ArrayBufferLike>;
+    private getChannel;
+    private flatItemsToPositionedLeaves;
+    private flatItemToLeaf;
+}
+//# sourceMappingURL=MerkleRecord.d.ts.map

package/dist/records/MerkleRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MerkleRecord.d.ts","sourceRoot":"","sources":["../../src/records/MerkleRecord.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AAepD,qBAAa,YAAY;IACrB,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,gBAAgB,CAA+B;IACvD,OAAO,CAAC,cAAc,CAAc;;IAOpC,MAAM,CAAC,oBAAoB,CAAC,gBAAgB,EAAE,gBAAgB,EAAE,OAAO,GAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,GAAC,SAAqB;IAMtH,OAAO,CAAC,+BAA+B;IAuBvC,OAAO,CAAC,YAAY;IAQpB,iBAAiB;IAIjB,qBAAqB;IAQrB,mBAAmB;IAQnB,aAAa;IAIb,gBAAgB,CAAC,SAAS,EAAE,MAAM;IAKlC,kBAAkB,CAAC,SAAS,EAAE,MAAM;IAiBpC,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,2BAA2B;IAUnC,OAAO,CAAC,cAAc;CA6BzB"}

package/dist/records/OnChainRecord.d.ts

@@ -0,0 +1,20 @@
+import { MerkleRecord } from './MerkleRecord';
+export declare class OnChainRecord {
+    private encoder;
+    private channelMap;
+    private publicChannels;
+    constructor();
+    static fromMerkleRecord(merkleRecord: MerkleRecord): OnChainRecord;
+    private logger;
+    private setChannelsFromMerkleRecord;
+    getChannelIds(): number[];
+    getOnChainData(channelId: number, pack?: boolean): {
+        isPublic: boolean;
+        merkleRootHash: Uint8Array<ArrayBufferLike>;
+        data: Uint8Array<ArrayBufferLike>;
+    };
+    addOnChainData(channelId: number, isPublic: boolean, rootHash: Uint8Array, encodedData: Uint8Array): void;
+    toMerkleRecord(checkHashes?: boolean): MerkleRecord;
+    private getChannel;
+}
+//# sourceMappingURL=OnChainRecord.d.ts.map

package/dist/records/OnChainRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OnChainRecord.d.ts","sourceRoot":"","sources":["../../src/records/OnChainRecord.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAkB5C,qBAAa,aAAa;IACtB,OAAO,CAAC,OAAO,CAAgC;IAC/C,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,cAAc,CAAc;;IAOpC,MAAM,CAAC,gBAAgB,CAAC,YAAY,EAAE,YAAY;IAMlD,OAAO,CAAC,MAAM,CAA0C;IACxD,OAAO,CAAC,2BAA2B;IA2BnC,aAAa;IAIb,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,UAAQ;;;;;IAkB9C,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,UAAU;IAyBlG,cAAc,CAAC,WAAW,UAAO;IAwCjC,OAAO,CAAC,UAAU;CAOrB"}

package/dist/records/PositionedLeaf.d.ts

@@ -0,0 +1,8 @@
+import { MerkleLeaf } from './MerkleLeaf';
+import { Path } from './types';
+export type PositionedLeaf = {
+    leaf: MerkleLeaf;
+    index: number;
+    path: Path;
+};
+//# sourceMappingURL=PositionedLeaf.d.ts.map

package/dist/records/PositionedLeaf.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PositionedLeaf.d.ts","sourceRoot":"","sources":["../../src/records/PositionedLeaf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,UAAU,EAAC,MAAM,cAAc,CAAC;AACxC,OAAO,EAAC,IAAI,EAAC,MAAM,SAAS,CAAC;AAE7B,MAAM,MAAM,cAAc,GAAG;IACzB,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,IAAI,CAAC;CACd,CAAA"}

package/dist/records/ProofDocument.d.ts

@@ -0,0 +1,74 @@
+import { ProofDocumentVB } from './ProofDocumentVB';
+import { ProofWrapper } from './types';
+export declare class ProofDocument {
+    private encoder;
+    private wrapper;
+    constructor();
+    static fromObject(proofWrapper: ProofWrapper): ProofDocument;
+    setTitle(title: string): void;
+    getTitle(): string;
+    setDescription(description: string): void;
+    getDescription(): string;
+    setAuthor(author: string): void;
+    getAuthor(): string;
+    setDate(date: Date): void;
+    getDate(): Date;
+    addVirtualBlockchain(proofDocumentVB: ProofDocumentVB): void;
+    getSingleVirtualBlockchainOrFail(): ProofDocumentVB;
+    getVirtualBlockchain(id: string): {
+        id: string;
+        microblocks: {
+            height: number;
+            channels: {
+                id: number;
+                is_public: boolean;
+                n_leaves: number;
+                fields: ({
+                    path: (string | number)[];
+                    type: import("./types").ProofFieldTypeEnum.Public;
+                    value: string | number | boolean | null;
+                } | {
+                    type: import("./types").ProofFieldTypeEnum.Plain;
+                    salt: string;
+                    value: string | number | boolean | null;
+                    path: (string | number)[];
+                    index: number;
+                } | {
+                    type: import("./types").ProofFieldTypeEnum.HashableAsPlain;
+                    salt: string;
+                    value: string | number | boolean | null;
+                    path: (string | number)[];
+                    index: number;
+                } | {
+                    type: import("./types").ProofFieldTypeEnum.HashableAsHash;
+                    salt: string;
+                    hash: string;
+                    path: (string | number)[];
+                    index: number;
+                } | {
+                    type: import("./types").ProofFieldTypeEnum.MaskableAsAllParts;
+                    v_salt: string;
+                    v_parts: string[];
+                    h_salt: string;
+                    h_parts: string[];
+                    path: (string | number)[];
+                    index: number;
+                } | {
+                    type: import("./types").ProofFieldTypeEnum.MaskableAsVisibleParts;
+                    v_salt: string;
+                    v_parts: string[];
+                    h_hash: string;
+                    path: (string | number)[];
+                    index: number;
+                })[];
+                witnesses: string[];
+            }[];
+        }[];
+    };
+    getVirtualBlockchains(): ProofDocumentVB[];
+    sign(issuedAt?: Date): void;
+    verifySignature(): void;
+    computeDigest(): Uint8Array<ArrayBufferLike>;
+    getObject(): ProofWrapper;
+}
+//# sourceMappingURL=ProofDocument.d.ts.map

package/dist/records/ProofDocument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofDocument.d.ts","sourceRoot":"","sources":["../../src/records/ProofDocument.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAElD,OAAO,EAEH,YAAY,EAEf,MAAM,SAAS,CAAC;AAKjB,qBAAa,aAAa;IACtB,OAAO,CAAC,OAAO,CAAiC;IAChD,OAAO,CAAC,OAAO,CAAe;;IAe9B,MAAM,CAAC,UAAU,CAAC,YAAY,EAAE,YAAY;IAO5C,QAAQ,CAAC,KAAK,EAAE,MAAM;IAItB,QAAQ;IAIR,cAAc,CAAC,WAAW,EAAE,MAAM;IAIlC,cAAc;IAId,SAAS,CAAC,MAAM,EAAE,MAAM;IAIxB,SAAS;IAIT,OAAO,CAAC,IAAI,EAAE,IAAI;IAIlB,OAAO;IAIP,oBAAoB,CAAC,eAAe,EAAE,eAAe;IAIrD,gCAAgC;IAWhC,oBAAoB,CAAC,EAAE,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAQ/B,qBAAqB;IAMrB,IAAI,CAAC,QAAQ,GAAE,IAAe;IAqB9B,eAAe;IAKf,aAAa;IAUb,SAAS,IAAI,YAAY;CAG5B"}

package/dist/records/ProofDocumentVB.d.ts

@@ -0,0 +1,14 @@
+import { ProofChannel, ProofMicroblock, ProofVirtualBlockchain } from './types';
+export declare class ProofDocumentVB {
+    private identifier;
+    private microblocks;
+    constructor();
+    static fromObject(object: ProofVirtualBlockchain): ProofDocumentVB;
+    toObject(): ProofVirtualBlockchain;
+    setIdentifier(identifier: string): void;
+    getIdentifier(): string;
+    addMicroblock(height: number, channels: ProofChannel[]): void;
+    getMicroblock(height: number): ProofMicroblock;
+    getMicroblocks(): ProofMicroblock[];
+}
+//# sourceMappingURL=ProofDocumentVB.d.ts.map

package/dist/records/ProofDocumentVB.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofDocumentVB.d.ts","sourceRoot":"","sources":["../../src/records/ProofDocumentVB.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,YAAY,EACZ,eAAe,EACf,sBAAsB,EACzB,MAAM,SAAS,CAAC;AAEjB,qBAAa,eAAe;IACxB,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,WAAW,CAAoB;;IAOvC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,sBAAsB;IAShD,QAAQ,IAAI,sBAAsB;IAOlC,aAAa,CAAC,UAAU,EAAE,MAAM;IAIhC,aAAa;IAIb,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE;IAQtD,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,eAAe;IAQ9C,cAAc,IAAI,eAAe,EAAE;CAGtC"}

package/dist/records/ProofRecord.d.ts

@@ -0,0 +1,26 @@
+import { MerkleRecord } from './MerkleRecord';
+import { Path, ProofChannel, JsonData } from './types';
+export declare class ProofRecord {
+    private channelMap;
+    private fieldMap;
+    private publicChannels;
+    constructor();
+    static fromMerkleRecord(merkleRecord: MerkleRecord): ProofRecord;
+    static fromProofChannels(proofChannels: ProofChannel[]): ProofRecord;
+    private setChannelsFromMerkleRecord;
+    private setChannelsFromProofChannels;
+    toJson(withDisclosureTypes?: boolean): JsonData;
+    private buildTrees;
+    private buildWitnesses;
+    private buildFieldMap;
+    private getLeafByPath;
+    private getFieldByPath;
+    private getChannel;
+    removeField(path: Path): void;
+    setFieldToHashed(path: Path): void;
+    setFieldToMasked(path: Path): void;
+    getRootHashAsBinary(channelId: number): Uint8Array<ArrayBufferLike>;
+    getRootHashAsHexString(channelId: number): string;
+    toProofChannels(): ProofChannel[];
+}
+//# sourceMappingURL=ProofRecord.d.ts.map

package/dist/records/ProofRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ProofRecord.d.ts","sourceRoot":"","sources":["../../src/records/ProofRecord.ts"],"names":[],"mappings":"AAGA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,EACH,IAAI,EAEJ,YAAY,EAEZ,QAAQ,EACX,MAAM,SAAS,CAAC;AAUjB,qBAAa,WAAW;IACpB,OAAO,CAAC,UAAU,CAA+B;IACjD,OAAO,CAAC,QAAQ,CAAoD;IACpE,OAAO,CAAC,cAAc,CAAc;;IAQpC,MAAM,CAAC,gBAAgB,CAAC,YAAY,EAAE,YAAY;IAMlD,MAAM,CAAC,iBAAiB,CAAC,aAAa,EAAE,YAAY,EAAE;IAMtD,OAAO,CAAC,2BAA2B;IAkBnC,OAAO,CAAC,4BAA4B;IAiCpC,MAAM,CAAC,mBAAmB,GAAE,OAAe,GAAG,QAAQ;IAkCtD,OAAO,CAAC,UAAU;IAclB,OAAO,CAAC,cAAc;IAoBtB,OAAO,CAAC,aAAa;IAarB,OAAO,CAAC,aAAa;IAWrB,OAAO,CAAC,cAAc;IAUtB,OAAO,CAAC,UAAU;IASlB,WAAW,CAAC,IAAI,EAAE,IAAI;IAMtB,gBAAgB,CAAC,IAAI,EAAE,IAAI;IAK3B,gBAAgB,CAAC,IAAI,EAAE,IAAI;IAK3B,mBAAmB,CAAC,SAAS,EAAE,MAAM;IASrC,sBAAsB,CAAC,SAAS,EAAE,MAAM;IAMxC,eAAe,IAAI,YAAY,EAAE;CAyBpC"}

package/dist/records/Record.d.ts

@@ -0,0 +1,49 @@
+import { MaskPart, Json, TypeEnum, FlatItem } from './types';
+export declare class Record {
+    private itemList;
+    private publicChannels;
+    constructor();
+    static fromObject(object: unknown): Record;
+    setChannelAsPublic(channelId: number): void;
+    setChannelAsPrivate(channelId: number): void;
+    getPublicChannels(): Set<number>;
+    setChannel(pathString: string, channelId: number): void;
+    /**
+     * Sets the channel ID of a field identified by its path.
+     */
+    private setFieldChannel;
+    setAsHashable(pathString: string): void;
+    /**
+     * Sets a field identified by its path as hashable.
+     */
+    private setFieldAsHashable;
+    /**
+     * Sets a mask on a field identified by its path, using an array of mask parts. Each mask part is
+     * defined as { start, end, replacement } where 'start' and 'end' are the 0-based indices of the
+     * masked part and 'replacement' the replacement string when this part is not revealed.
+     */
+    private setMaskOnField;
+    setMaskByPositions(pathString: string, maskParts: MaskPart[]): void;
+    setMaskByRegex(pathString: string, regex: RegExp, substitutionString: string): void;
+    /**
+     * Sets a mask on a field identified by its path, using a regular expression and a substitution
+     * string. The regular expression must capture all parts of the string. The substitution string
+     * is a mix of replacement strings and references to the captured groups with $x.
+     * Example: /^(.)(.*)(@.)(.*)$/ and '$1***$3***' applied to 'john.do@gmail.com' will produce
+     * 'j***@g***'.
+     */
+    private setMaskByRegexOnField;
+    getItemList(): FlatItem[];
+    private getFieldsByPathString;
+    static getValueType(field: Json): TypeEnum;
+    static getPrimitiveValueType(field: Json): TypeEnum.String | TypeEnum.Number | TypeEnum.Boolean | TypeEnum.Null;
+    private buildItemListByDfs;
+    private addFlatItem;
+    private buildStringItem;
+    private buildNumberItem;
+    private buildBooleanItem;
+    private buildNullItem;
+    private buildArrayItem;
+    private buildObjectItem;
+}
+//# sourceMappingURL=Record.d.ts.map

package/dist/records/Record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Record.d.ts","sourceRoot":"","sources":["../../src/records/Record.ts"],"names":[],"mappings":"AACA,OAAO,EAEH,QAAQ,EAER,IAAI,EAEJ,QAAQ,EAER,QAAQ,EAKX,MAAM,SAAS,CAAC;AAEjB,qBAAa,MAAM;IACf,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,cAAc,CAAc;;IAOpC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,OAAO;IAOjC,kBAAkB,CAAC,SAAS,EAAE,MAAM;IAIpC,mBAAmB,CAAC,SAAS,EAAE,MAAM;IAIrC,iBAAiB;IAIjB,UAAU,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAOhD;;OAEG;IACH,OAAO,CAAC,eAAe;IAIvB,aAAa,CAAC,UAAU,EAAE,MAAM;IAOhC;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAO1B;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAwCtB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE;IAO5D,cAAc,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,kBAAkB,EAAE,MAAM;IAO5E;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB;IAyC7B,WAAW;IAIX,OAAO,CAAC,qBAAqB;IAiC7B,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,IAAI;IAsB/B,MAAM,CAAC,qBAAqB,CAAC,KAAK,EAAE,IAAI;IAQxC,OAAO,CAAC,kBAAkB;IAiC1B,OAAO,CAAC,WAAW;IAKnB,OAAO,CAAC,eAAe;IASvB,OAAO,CAAC,eAAe;IAQvB,OAAO,CAAC,gBAAgB;IAQxB,OAAO,CAAC,aAAa;IAQrB,OAAO,CAAC,cAAc;IAMtB,OAAO,CAAC,eAAe;CAM1B"}

package/dist/records/RecordByChannels.d.ts

@@ -0,0 +1,14 @@
+import { Record } from './Record';
+import { FlatItem } from './types';
+export declare class RecordByChannels {
+    private channelMap;
+    private publicChannels;
+    constructor();
+    static fromRecord(record: Record): RecordByChannels;
+    setChannel(channelId: number, isPublic: boolean, flatItems: FlatItem[]): void;
+    private setPublicChannels;
+    getPublicChannels(): Set<number>;
+    getChannelIds(): number[];
+    getFlatItems(channelId: number): FlatItem[];
+}
+//# sourceMappingURL=RecordByChannels.d.ts.map

package/dist/records/RecordByChannels.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RecordByChannels.d.ts","sourceRoot":"","sources":["../../src/records/RecordByChannels.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,MAAM,EAAC,MAAM,UAAU,CAAC;AAChC,OAAO,EACH,QAAQ,EACX,MAAM,SAAS,CAAC;AAEjB,qBAAa,gBAAgB;IACzB,OAAO,CAAC,UAAU,CAA0B;IAC5C,OAAO,CAAC,cAAc,CAAc;;IAOpC,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM;IAgBhC,UAAU,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE;IAUtE,OAAO,CAAC,iBAAiB;IAIzB,iBAAiB;IAIjB,aAAa;IAIb,YAAY,CAAC,SAAS,EAAE,MAAM;CAOjC"}

package/dist/records/SaltShaker.d.ts

@@ -0,0 +1,11 @@
+export declare class SaltShaker {
+    private pepper;
+    private hasNullPepper;
+    private sha512;
+    private counter;
+    constructor(pepper: Uint8Array);
+    static generatePepper(): Uint8Array<ArrayBufferLike>;
+    getPepper(): Uint8Array<ArrayBufferLike>;
+    getSalt(): Uint8Array<ArrayBuffer>;
+}
+//# sourceMappingURL=SaltShaker.d.ts.map

package/dist/records/SaltShaker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SaltShaker.d.ts","sourceRoot":"","sources":["../../src/records/SaltShaker.ts"],"names":[],"mappings":"AAGA,qBAAa,UAAU;IACnB,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,aAAa,CAAU;IAC/B,OAAO,CAAC,MAAM,CAAa;IAC3B,OAAO,CAAC,OAAO,CAAS;gBAEZ,MAAM,EAAE,UAAU;IAO9B,MAAM,CAAC,cAAc;IAIrB,SAAS;IAIT,OAAO;CASV"}