Attestations V2

dist/pbaas/ContentMultiMapRemove.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+/// <reference types="bn.js" />
+import { BigNumber } from '../utils/types/BigNumber';
+import { SerializableEntity } from '../utils/types/SerializableEntity';
+export declare class ContentMultiMapRemove implements SerializableEntity {
+    version: BigNumber;
+    action: BigNumber;
+    entryKey: string;
+    valueHash: Buffer;
+    static VERSION_INVALID: import("bn.js");
+    static VERSION_FIRST: import("bn.js");
+    static VERSION_LAST: import("bn.js");
+    static VERSION_CURRENT: import("bn.js");
+    static ACTION_FIRST: import("bn.js");
+    static ACTION_REMOVE_ONE_KEYVALUE: import("bn.js");
+    static ACTION_REMOVE_ALL_KEYVALUE: import("bn.js");
+    static ACTION_REMOVE_ALL_KEY: import("bn.js");
+    static ACTION_CLEAR_MAP: import("bn.js");
+    static ACTION_LAST: import("bn.js");
+    constructor(data: {
+        version?: BigNumber;
+        action?: BigNumber;
+        entryKey?: string;
+        valueHash?: Buffer;
+    });
+    getByteLength(): number;
+    toBuffer(): Buffer;
+    fromBuffer(buffer: Buffer, offset?: number): number;
+}

dist/pbaas/ContentMultiMapRemove.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentMultiMapRemove = void 0;
+const address_1 = require("../utils/address");
+const bufferutils_1 = require("../utils/bufferutils");
+const bn_js_1 = require("bn.js");
+const vdxf_1 = require("../constants/vdxf");
+const { BufferReader, BufferWriter } = bufferutils_1.default;
+class ContentMultiMapRemove {
+    constructor(data) {
+        this.version = data.version || new bn_js_1.BN(1, 10);
+        this.action = data.action || new bn_js_1.BN(0, 10);
+        this.entryKey = data.entryKey || "";
+        this.valueHash = data.valueHash || Buffer.alloc(0);
+    }
+    getByteLength() {
+        let byteLength = 0;
+        byteLength += 4; // version uint32
+        byteLength + 4; // action uint32
+        if (this.action != ContentMultiMapRemove.ACTION_CLEAR_MAP) {
+            byteLength += 20;
+            if (this.action != ContentMultiMapRemove.ACTION_REMOVE_ALL_KEY) {
+                byteLength += 32;
+            }
+        }
+        return byteLength;
+    }
+    toBuffer() {
+        const bufferWriter = new BufferWriter(Buffer.alloc(this.getByteLength()));
+        bufferWriter.writeUInt32(this.version.toNumber());
+        bufferWriter.writeUInt32(this.action.toNumber());
+        if (this.action != ContentMultiMapRemove.ACTION_CLEAR_MAP) {
+            bufferWriter.writeSlice((0, address_1.fromBase58Check)(this.entryKey).hash);
+            if (this.action != ContentMultiMapRemove.ACTION_REMOVE_ALL_KEY) {
+                bufferWriter.writeSlice(this.valueHash);
+            }
+        }
+        return bufferWriter.buffer;
+    }
+    fromBuffer(buffer, offset = 0) {
+        const reader = new BufferReader(buffer, offset);
+        this.version = new bn_js_1.BN(reader.readUInt32());
+        this.action = new bn_js_1.BN(reader.readUInt32());
+        if (this.action != ContentMultiMapRemove.ACTION_CLEAR_MAP) {
+            this.entryKey = (0, address_1.toBase58Check)(reader.readSlice(20), vdxf_1.I_ADDR_VERSION);
+            if (this.action != ContentMultiMapRemove.ACTION_REMOVE_ALL_KEY) {
+                this.valueHash = reader.readSlice(32);
+            }
+        }
+        return reader.offset;
+    }
+}
+exports.ContentMultiMapRemove = ContentMultiMapRemove;
+ContentMultiMapRemove.VERSION_INVALID = new bn_js_1.BN(0);
+ContentMultiMapRemove.VERSION_FIRST = new bn_js_1.BN(1);
+ContentMultiMapRemove.VERSION_LAST = new bn_js_1.BN(1);
+ContentMultiMapRemove.VERSION_CURRENT = new bn_js_1.BN(1);
+ContentMultiMapRemove.ACTION_FIRST = new bn_js_1.BN(1);
+ContentMultiMapRemove.ACTION_REMOVE_ONE_KEYVALUE = new bn_js_1.BN(1);
+ContentMultiMapRemove.ACTION_REMOVE_ALL_KEYVALUE = new bn_js_1.BN(2);
+ContentMultiMapRemove.ACTION_REMOVE_ALL_KEY = new bn_js_1.BN(3);
+ContentMultiMapRemove.ACTION_CLEAR_MAP = new bn_js_1.BN(4);
+ContentMultiMapRemove.ACTION_LAST = new bn_js_1.BN(4);

dist/pbaas/CurrencyValueMap.d.ts

@@ -13,4 +13,6 @@ export declare class CurrencyValueMap implements SerializableEntity {
     getByteLength(): number;
     toBuffer(): Buffer;
     fromBuffer(buffer: Buffer, offset?: number): number;
+    IsValid(): boolean;
+    toJson(): any;
 }

dist/pbaas/CurrencyValueMap.js

@@ -59,5 +59,20 @@ class CurrencyValueMap {
         }
         return reader.offset;
     }
+    IsValid() {
+        for (let [key, value] of this.value_map) {
+            if (!key) {
+                return false;
+            }
+        }
+        return true;
+    }
+    toJson() {
+        const value_map = {};
+        for (let [key, value] of this.value_map) {
+            value_map[key] = value.toString();
+        }
+        return value_map;
+    }
 }
 exports.CurrencyValueMap = CurrencyValueMap;

dist/pbaas/Rating.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="bn.js" />
+/// <reference types="node" />
+import { BigNumber } from '../utils/types/BigNumber';
+import { SerializableEntity } from '../utils/types/SerializableEntity';
+export declare class Rating implements SerializableEntity {
+    static VERSION_INVALID: import("bn.js");
+    static VERSION_FIRST: import("bn.js");
+    static VERSION_LAST: import("bn.js");
+    static VERSION_CURRENT: import("bn.js");
+    static TRUST_UNKNOWN: import("bn.js");
+    static TRUST_BLOCKED: import("bn.js");
+    static TRUST_APPROVED: import("bn.js");
+    static TRUST_FIRST: import("bn.js");
+    static TRUST_LAST: import("bn.js");
+    version: BigNumber;
+    trustLevel: BigNumber;
+    ratings: Map<string, Buffer>;
+    constructor(data?: {
+        version?: BigNumber;
+        trustLevel?: BigNumber;
+        ratings?: Map<string, Buffer>;
+    });
+    getByteLength(): number;
+    toBuffer(): Buffer;
+    fromBuffer(buffer: Buffer, offset?: number): number;
+    IsValid(): boolean;
+    toJson(): {
+        version: string;
+        trustlevel: string;
+        ratings: Map<string, Buffer>;
+    };
+}

dist/pbaas/Rating.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rating = void 0;
+const varint_1 = require("../utils/varint");
+const varuint_1 = require("../utils/varuint");
+const address_1 = require("../utils/address");
+const bufferutils_1 = require("../utils/bufferutils");
+const bn_js_1 = require("bn.js");
+const vdxf_1 = require("../constants/vdxf");
+const { BufferReader, BufferWriter } = bufferutils_1.default;
+class Rating {
+    constructor(data = {}) {
+        this.version = data.version || new bn_js_1.BN(1, 10);
+        this.trustLevel = data.trustLevel || new bn_js_1.BN(0, 10);
+        this.ratings = new Map(data.ratings || []);
+    }
+    getByteLength() {
+        let byteLength = 0;
+        byteLength += 4; // version uint32
+        byteLength + 1; // trustLevel uint8
+        byteLength += varuint_1.default.encodingLength(this.ratings.size);
+        for (const [key, value] of this.ratings) {
+            byteLength += 20;
+            byteLength += varint_1.default.encodingLength(new bn_js_1.BN(value.length));
+            byteLength += value.length;
+        }
+        return byteLength;
+    }
+    toBuffer() {
+        const bufferWriter = new BufferWriter(Buffer.alloc(this.getByteLength()));
+        bufferWriter.writeUInt32(this.version.toNumber());
+        bufferWriter.writeUInt8(this.trustLevel.toNumber());
+        bufferWriter.writeCompactSize(this.ratings.size);
+        for (const [key, value] of this.ratings) {
+            const { hash } = (0, address_1.fromBase58Check)(key);
+            bufferWriter.writeSlice(hash);
+            bufferWriter.writeVarSlice(value);
+        }
+        return bufferWriter.buffer;
+    }
+    fromBuffer(buffer, offset = 0) {
+        const reader = new BufferReader(buffer, offset);
+        this.version = new bn_js_1.BN(reader.readUInt32());
+        this.trustLevel = new bn_js_1.BN(reader.readUInt8());
+        const count = reader.readCompactSize();
+        for (let i = 0; i < count; i++) {
+            const hash = reader.readSlice(20);
+            const value = reader.readVarSlice();
+            const base58Key = (0, address_1.toBase58Check)(hash, vdxf_1.I_ADDR_VERSION);
+            this.ratings.set(base58Key, value);
+        }
+        return reader.offset;
+    }
+    IsValid() {
+        return this.version.gte(Rating.VERSION_FIRST) && this.version.lte(Rating.VERSION_LAST) &&
+            this.trustLevel.gte(Rating.TRUST_FIRST) && this.trustLevel.lte(Rating.TRUST_LAST);
+    }
+    toJson() {
+        return {
+            version: this.version.toString(),
+            trustlevel: this.trustLevel.toString(),
+            ratings: this.ratings
+        };
+    }
+}
+exports.Rating = Rating;
+Rating.VERSION_INVALID = new bn_js_1.BN(0, 10);
+Rating.VERSION_FIRST = new bn_js_1.BN(1, 10);
+Rating.VERSION_LAST = new bn_js_1.BN(1, 10);
+Rating.VERSION_CURRENT = new bn_js_1.BN(1, 10);
+Rating.TRUST_UNKNOWN = new bn_js_1.BN(0, 10); // unknown and can be included in exploration
+Rating.TRUST_BLOCKED = new bn_js_1.BN(1, 10); // suspected or known to be untrustworthy and should not be interacted with
+Rating.TRUST_APPROVED = new bn_js_1.BN(2, 10); // explicitly believed to be trustworthy enough to interact with
+Rating.TRUST_FIRST = new bn_js_1.BN(0, 10);
+Rating.TRUST_LAST = new bn_js_1.BN(2, 10);

dist/pbaas/TransferDestination.d.ts

@@ -53,4 +53,6 @@ export declare class TransferDestination implements SerializableEntity {
     fromBuffer(buffer: Buffer, offset?: number): number;
     static fromJson(data: TransferDestinationJson): TransferDestination;
     toJson(): TransferDestinationJson;
+    IsValid(): boolean;
+    GetAuxDest(destNum: any): TransferDestination;
 }

dist/pbaas/TransferDestination.js

@@ -23,6 +23,7 @@ exports.LAST_VALID_TYPE_NO_FLAGS = exports.DEST_RAW;
 exports.FLAG_DEST_AUX = new bn_js_1.BN(64, 10);
 exports.FLAG_DEST_GATEWAY = new bn_js_1.BN(128, 10);
 exports.FLAG_MASK = exports.FLAG_DEST_AUX.add(exports.FLAG_DEST_GATEWAY);
+const UINT160_BYTE_SIZE = 20;
 class TransferDestination {
     constructor(data) {
         this.type = exports.DEST_INVALID;
@@ -89,9 +90,9 @@ class TransferDestination {
                 length += (0, address_1.fromBase58Check)(this.gateway_code).hash.length; // gateway_code
             }
             else {
-                length += 20;
+                length += UINT160_BYTE_SIZE;
             }
-            length += 8; // fees
+            length += 8; // fees int64
         }
         if (this.hasAuxDests()) {
             length += varuint_1.default.encodingLength(this.aux_dests.length); // aux dests compact size
@@ -113,7 +114,7 @@ class TransferDestination {
                 writer.writeSlice((0, address_1.fromBase58Check)(this.gateway_code).hash);
             }
             else {
-                writer.writeSlice(Buffer.alloc(20));
+                writer.writeSlice(Buffer.alloc(UINT160_BYTE_SIZE));
             }
             writer.writeInt64(this.fees);
         }
@@ -162,5 +163,41 @@ class TransferDestination {
             aux_dests: this.aux_dests.map(x => x.toJson())
         };
     }
+    IsValid() {
+        // verify aux dests
+        let valid = (((this.type.and(exports.FLAG_DEST_AUX).gt(new bn_js_1.BN(0))) && this.aux_dests.length > 0) || (!(this.type.and(exports.FLAG_DEST_AUX).gt(new bn_js_1.BN(0))) && !(this.aux_dests.length > 0)));
+        if (valid && this.aux_dests) {
+            for (let i = 0; i < this.aux_dests.length; i++) {
+                if (!this.GetAuxDest(i).IsValid()) {
+                    valid = false;
+                    break;
+                }
+            }
+        }
+        return !!(valid &&
+            !this.typeNoFlags().eq(exports.DEST_INVALID) &&
+            this.typeNoFlags().lte(exports.LAST_VALID_TYPE_NO_FLAGS) &&
+            ((!(this.type.and(exports.FLAG_DEST_GATEWAY)) && !this.gateway_id) || this.gateway_id));
+    }
+    GetAuxDest(destNum) {
+        const retVal = this.aux_dests[destNum];
+        if (destNum >= 0 && destNum < this.aux_dests.length) {
+            if (retVal.type.and(exports.FLAG_DEST_AUX).gt(new bn_js_1.BN(0)) || retVal.aux_dests.length > 0) {
+                retVal.type = exports.DEST_INVALID;
+            }
+            // no gateways or flags, only simple destinations work
+            switch (retVal.type) {
+                case exports.DEST_ID:
+                case exports.DEST_PK:
+                case exports.DEST_PKH:
+                case exports.DEST_ETH:
+                case exports.DEST_SH:
+                    break;
+                default:
+                    retVal.type = exports.DEST_INVALID;
+            }
+        }
+        return retVal;
+    }
 }
 exports.TransferDestination = TransferDestination;

dist/vdxf/classes/Attestation.d.ts

@@ -0,0 +1,12 @@
+import { BufferDataVdxfObject } from '../index';
+export interface AttestationRequestInterface {
+    attestationId: string;
+    accepted_attestors: Array<string>;
+    attestation_keys: Array<string>;
+    attestor_filters?: Array<string>;
+}
+export declare class Attestation extends BufferDataVdxfObject {
+    setAttestationViewRequestData(attestationId: string, accepted_attestors: Array<string>, attestation_keys: Array<string>, attestor_filters: Array<string>): void;
+    getAttestationViewRequestData(): AttestationRequestInterface;
+    getAttestationProvisioningData(): any[];
+}