@keetanetwork/keetanet-client 0.10.2

package/lib/utils/asn1.d.ts

@@ -0,0 +1,205 @@
+import * as asn1js from 'asn1js';
+export declare const asn1: typeof asn1js;
+declare function jsBigIntToBuffer(value: bigint): Buffer;
+declare function jsIntegerToBigInt(value: asn1js.Integer | number): bigint;
+export type ASN1AnyJS = ASN1AnyJS[] | bigint | number | Date | Buffer | ASN1OID | ASN1Set | ASN1ContextTag | ASN1BitString | ASN1Date | ASN1String | string | boolean | null | undefined;
+type ASN1AnyASN = InstanceType<typeof asn1js.Sequence> | InstanceType<typeof asn1js.Set> | InstanceType<typeof asn1js.Integer> | InstanceType<typeof asn1js.GeneralizedTime> | InstanceType<typeof asn1js.Null> | InstanceType<typeof asn1js.OctetString> | InstanceType<typeof asn1js.BitString> | InstanceType<typeof asn1js.ObjectIdentifier> | InstanceType<typeof asn1js.Constructed> | InstanceType<typeof asn1js.Boolean> | InstanceType<typeof asn1js.PrintableString> | InstanceType<typeof asn1js.IA5String> | InstanceType<typeof asn1js.Utf8String> | undefined;
+interface ASN1Object {
+    type: string;
+}
+export interface ASN1OID extends ASN1Object {
+    type: 'oid';
+    oid: string;
+}
+export interface ASN1Set extends ASN1Object {
+    type: 'set';
+    name: ASN1OID;
+    value: string | ASN1String;
+}
+interface ASN1ExplicitContextTag extends ASN1Object {
+    type: 'context';
+    kind: 'explicit';
+    value: number;
+    contains: ASN1AnyJS;
+}
+interface ASN1ImplicitContextTag extends ASN1Object {
+    type: 'context';
+    kind: 'implicit';
+    value: number;
+    contains: ArrayBuffer | ASN1AnyJS;
+}
+export type ASN1ContextTag = ASN1ExplicitContextTag | ASN1ImplicitContextTag;
+export interface ASN1BitString extends ASN1Object {
+    type: 'bitstring';
+    value: Buffer;
+    unusedBits?: number;
+}
+export interface ASN1Date extends ASN1Object {
+    type: 'date';
+    kind?: 'utc' | 'general' | 'default';
+    date: Date;
+}
+export interface ASN1String extends ASN1Object {
+    type: 'string';
+    kind: 'printable' | 'ia5' | 'utf8';
+    value: string;
+}
+/**
+ * Validation function for {@link isValidSequenceSchema}
+ */
+export type ASN1SequenceValidation = ((arg: unknown) => boolean)[];
+/**
+ * Checks if an ASN.1 sequence is valid based on a provided validation schema.
+ */
+export declare function isValidSequenceSchema(input: unknown[], schema: ASN1SequenceValidation): boolean;
+declare function jsJStoASN1(input: Readonly<ASN1AnyJS>): Exclude<ASN1AnyASN, undefined>;
+declare function jsJStoASN1(input: Readonly<ASN1AnyJS>, allowUndefined: true): ASN1AnyASN;
+declare function jsASN1toJS(input: ArrayBuffer): ASN1AnyJS;
+declare const ASN1toJS: typeof jsASN1toJS, JStoASN1: typeof jsJStoASN1, ASN1IntegerToBigInt: typeof jsIntegerToBigInt, ASN1BigIntToBuffer: typeof jsBigIntToBuffer;
+export declare namespace ValidateASN1 {
+    export type Schema = keyof BasicSchemaMap | {
+        choice: Schema[];
+    } | {
+        sequenceOf: Schema;
+    } | {
+        optional: Schema;
+    } | {
+        type: 'context';
+        kind: 'implicit' | 'explicit';
+        contains: Schema;
+        value: number;
+    } | {
+        type: 'oid';
+        oid: string;
+    } | {
+        type: 'string';
+        kind: 'printable';
+    } | {
+        type: 'string';
+        kind: 'ia5';
+    } | {
+        type: 'string';
+        kind: 'utf8';
+    } | {
+        type: 'date';
+        kind: 'utc';
+    } | {
+        type: 'date';
+        kind: 'general';
+    } | readonly [Schema, ...Schema[]];
+    type BasicSchemaMap = {
+        [ValidateASN1.IsAny]: ASN1AnyJS;
+        [ValidateASN1.IsUnknown]: unknown;
+        [ValidateASN1.IsDate]: Date;
+        [ValidateASN1.IsAnyDate]: ASN1Date;
+        [ValidateASN1.IsString]: string;
+        [ValidateASN1.IsAnyString]: ASN1String;
+        [ValidateASN1.IsOctetString]: Buffer;
+        [ValidateASN1.IsBitString]: ASN1BitString;
+        [ValidateASN1.IsInteger]: bigint;
+        [ValidateASN1.IsBoolean]: boolean;
+        [ValidateASN1.IsOID]: ASN1OID;
+        [ValidateASN1.IsSet]: ASN1Set;
+        [ValidateASN1.IsNull]: null;
+    };
+    export type SchemaMap<T extends Schema> = T extends keyof BasicSchemaMap ? BasicSchemaMap[T] : T extends {
+        choice: Schema[];
+    } ? SchemaMap<T['choice'][number]> : T extends {
+        choice: readonly Schema[];
+    } ? SchemaMap<T['choice'][number]> : T extends {
+        sequenceOf: Schema;
+    } ? SchemaMap<T['sequenceOf']>[] : T extends {
+        optional: Schema;
+    } ? SchemaMap<T['optional']> | undefined : T extends {
+        type: 'context';
+        kind: infer U extends 'implicit' | 'explicit';
+        value: number;
+        contains: Schema;
+    } ? Omit<ASN1ContextTag, 'contains' | 'value' | 'kind'> & {
+        contains: SchemaMap<T['contains']>;
+        value: T['value'];
+        kind: U;
+    } : T extends {
+        type: 'oid';
+        oid: string;
+    } ? Omit<ASN1OID, 'oid'> & {
+        oid: T['oid'];
+    } : T extends {
+        type: 'string';
+        kind: 'printable' | 'ia5' | 'utf8';
+    } ? Omit<ASN1String, 'kind'> & {
+        kind: T['kind'];
+    } : T extends {
+        type: 'date';
+        kind: 'general' | 'utc';
+    } ? Omit<ASN1Date, 'kind'> & {
+        kind: T['kind'];
+    } : T extends readonly [Schema, ...Schema[]] ? {
+        [K in keyof T]: T[K] extends Schema ? SchemaMap<T[K]> : never;
+    } : never;
+    export {};
+}
+export declare class ValidateASN1<T extends ValidateASN1.Schema> {
+    #private;
+    static readonly IsAny: unique symbol;
+    static readonly IsUnknown: unique symbol;
+    static readonly IsDate: unique symbol;
+    static readonly IsAnyDate: unique symbol;
+    static readonly IsString: unique symbol;
+    static readonly IsAnyString: unique symbol;
+    static readonly IsOctetString: unique symbol;
+    static readonly IsBitString: unique symbol;
+    static readonly IsInteger: unique symbol;
+    static readonly IsBoolean: unique symbol;
+    static readonly IsOID: unique symbol;
+    static readonly IsSet: unique symbol;
+    static readonly IsNull: unique symbol;
+    /**
+     * Interpret an untagged type as a specific universal tag
+     */
+    private static interpretASN1Tag;
+    /**
+     * Given a schema, validate the ASN.1 object against it and return the
+     * object as the validated type
+     */
+    static againstSchema<T extends ValidateASN1.Schema>(input: ASN1AnyJS, schema: T): ValidateASN1.SchemaMap<T>;
+    constructor(schema: T);
+    validate(input: ASN1AnyJS): ValidateASN1.SchemaMap<T>;
+}
+/**
+ * Create a Mutable type from a given Readonly type
+ *
+ * Does not handle all possible objects, but those used
+ * within the ASN1 encoder/decoder
+ */
+type Mutable<T> = T extends Buffer | ArrayBuffer | Date ? T : T extends object ? {
+    -readonly [K in keyof T]: Mutable<T[K]>;
+} : T;
+/**
+ * An ASN.1 object which contains the DER encoded value as well as the
+ * unencoded value
+ */
+export declare class BufferStorageASN1<T extends ASN1AnyJS | Readonly<ASN1AnyJS> = Readonly<ASN1AnyJS>, S extends ValidateASN1.Schema | undefined = undefined> {
+    #private;
+    static readonly Validate: typeof ValidateASN1;
+    static readonly isInstance: (obj: any, strict?: boolean) => obj is BufferStorageASN1<string | number | bigint | boolean | Buffer | ASN1AnyJS[] | Date | ASN1OID | ASN1Set | ASN1ExplicitContextTag | ASN1ImplicitContextTag | ASN1BitString | ASN1Date | ASN1String | readonly ASN1AnyJS[] | Readonly<Buffer> | Readonly<Date> | Readonly<ASN1OID> | Readonly<ASN1Set> | Readonly<ASN1ExplicitContextTag> | Readonly<ASN1ImplicitContextTag> | Readonly<ASN1BitString> | Readonly<ASN1Date> | Readonly<ASN1String> | null | undefined, ValidateASN1.Schema | undefined>;
+    constructor(input: T | ArrayBuffer, schema?: S);
+    getDER(): ArrayBuffer;
+    getDERBuffer(): Buffer;
+    getASN1(): S extends undefined ? Mutable<T> : Mutable<ValidateASN1.SchemaMap<Exclude<S, undefined>>>;
+}
+export { ASN1toJS, JStoASN1, ASN1IntegerToBigInt, ASN1BigIntToBuffer };
+export declare const _Testing: {
+    native: {
+        ASN1toJS: typeof jsASN1toJS;
+        JStoASN1: typeof jsJStoASN1;
+        ASN1BigIntToBuffer: typeof jsBigIntToBuffer;
+        ASN1IntegerToBigInt: typeof jsIntegerToBigInt;
+    } | undefined;
+    js: {
+        ASN1toJS: typeof jsASN1toJS;
+        JStoASN1: typeof jsJStoASN1;
+        ASN1BigIntToBuffer: typeof jsBigIntToBuffer;
+        ASN1IntegerToBigInt: typeof jsIntegerToBigInt;
+    };
+};

package/lib/utils/bitfield.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Class to store a BitField
+ * Simple array of 0/1 values
+ */
+export default class BitField {
+    #private;
+    static isInstance: (obj: any, strict?: boolean) => obj is BitField;
+    constructor(data?: BitField | bigint | number[]);
+    set(offset: number | bigint, value: boolean | 0 | 1): void;
+    get size(): number;
+    get(offset: number | bigint): boolean;
+    get bigint(): bigint;
+}

package/lib/utils/bloom.d.ts

@@ -0,0 +1,6 @@
+import { BloomFilter } from 'bloom-filters';
+export { BloomFilter };
+export declare function serializeBloomFilter(filter: BloomFilter): string;
+export declare function serializeBloomFilter(filter: undefined): undefined;
+export declare function serializeBloomFilter(filter: BloomFilter | undefined): string | undefined;
+export declare function deserializeBloomFilter(input: string): BloomFilter;

package/lib/utils/buffer.d.ts

@@ -0,0 +1,27 @@
+import zlib from 'zlib';
+/**
+ * RFC 4648 Base32 Decoder
+ */
+export declare function DecodeBase32(data: string, length: number): ArrayBuffer;
+/**
+ * RFC 4648 Base32 Encoder
+ */
+export declare function EncodeBase32(data: ArrayBuffer): string;
+export declare function DecodeBase64(data: string): ArrayBuffer;
+export declare function EncodeBase64(data: ArrayBuffer): string;
+export declare function ZlibInflate(data: ArrayBuffer, options?: zlib.ZlibOptions): ArrayBuffer;
+export declare function ZlibDeflate(data: ArrayBuffer, options?: zlib.ZlibOptions): ArrayBuffer;
+export declare class BufferStorage {
+    #private;
+    readonly storageKind: string;
+    static isInstance: (obj: any, strict?: boolean) => obj is BufferStorage;
+    constructor(key: bigint | ArrayBuffer | string, length: number);
+    get(): ArrayBuffer;
+    get length(): number;
+    getBuffer(): Buffer;
+    toString(encoding?: 'hex' | 'base32' | 'base64'): string;
+    toBigInt(): bigint;
+    compare(compareWith: typeof this | undefined | null): boolean;
+    compareHexString(compareWith: BufferStorage | string | undefined | null): boolean;
+}
+export default BufferStorage;

package/lib/utils/certificate.d.ts

@@ -0,0 +1,340 @@
+import * as ASN1 from './asn1';
+import Account from '../account';
+import * as HashLib from './hash';
+/**
+ * De-normalized mapped Certificate Schema, for use in type annotations since
+ * we do not want to expose such a complex type
+ */
+type CertificateSchema = [
+    tbsCertificate: [
+        version: {
+            type: 'context';
+            value: 0;
+            kind: 'explicit';
+            contains: bigint;
+        },
+        serialNumber: bigint,
+        signatureAlgorithm: ASN1.ASN1OID[],
+        issuer: ASN1.ASN1Set[],
+        validityPeriod: [
+            notBefore: ASN1.ASN1Date,
+            notAfter: ASN1.ASN1Date
+        ],
+        subject: ASN1.ASN1Set[],
+        subjectPublicKey: [
+            algorithm: ASN1.ASN1OID[],
+            publicKey: ASN1.ASN1BitString
+        ],
+        extensions: {
+            type: 'context';
+            value: 3;
+            kind: 'explicit';
+            contains: ([
+                id: ASN1.ASN1OID,
+                critical: boolean,
+                value: Buffer
+            ] | [
+                id: ASN1.ASN1OID,
+                value: Buffer
+            ])[];
+        } | undefined
+    ],
+    signatureAlgorithm: ASN1.ASN1OID[],
+    signature: ASN1.ASN1BitString
+];
+type CertificateBuilderParams = {
+    /**
+     * Subject for the certificate, to store as the public key within the certificate
+     */
+    subjectPublicKey: Account;
+    /**
+     * Subject Distinguished Name (DN) for the certificate
+     */
+    subjectDN?: {
+        name: string;
+        value: string;
+    }[];
+    /**
+     * Issuer for the certificate, to sign the certificate with
+     */
+    issuer: Account;
+    /**
+     * Issuer Distinguished Name (DN) for the certificate
+     */
+    issuerDN?: {
+        name: string;
+        value: string;
+    }[];
+    /**
+     * Validity period of the certificate to begin on
+     */
+    validFrom: Date;
+    /**
+     * Validity period of the certificate to end (expire) on
+     */
+    validTo: Date;
+    /**
+     * Serial number for the certificate
+     */
+    serial: bigint | number;
+    /**
+     * Is a certificate authority ?
+     *
+     * Default is true if the Subject === Issuer and false otherwise
+     */
+    isCA?: boolean;
+    /**
+     * Include common/default certificate extensions ?
+     *
+     * Default is true
+     */
+    includeCommonExts?: boolean;
+    /**
+     * Hashing library to use
+     */
+    hashLib: {
+        hash: (...args: Parameters<typeof HashLib.Hash>) => ReturnType<typeof HashLib.Hash>;
+        name: string;
+    };
+};
+export declare class CertificateBuilder {
+    #private;
+    constructor(params?: Partial<CertificateBuilderParams>);
+    /**
+     * Construct an extension
+     */
+    protected static extension(oid: string, value: Parameters<typeof ASN1.JStoASN1>[0], critical?: boolean): [{
+        type: "oid";
+        oid: string;
+    }, value: Buffer] | [{
+        type: "oid";
+        oid: string;
+    }, critical: boolean, value: Buffer];
+    /**
+     * Convert a KeetaNet Account to a Key ID (for Subject Key Identifier)
+     */
+    private accountToKeyId;
+    /**
+     * Produce the extensions to include in this certificate
+     */
+    protected addExtensions(params: CertificateBuilderParams): Promise<([{
+        type: "oid";
+        oid: string;
+    }, value: Buffer] | [{
+        type: "oid";
+        oid: string;
+    }, critical: boolean, value: Buffer])[]>;
+    /**
+     * Compute the final params as required
+     */
+    private getFinalParams;
+    /**
+     * Create a certificate
+     */
+    buildDER(params?: Partial<CertificateBuilderParams>): Promise<ArrayBuffer>;
+    build(params?: Partial<CertificateBuilderParams>): Promise<Certificate>;
+}
+type CertificateOptions = {
+    /**
+     * The moment at which the certificate is being validated, or null if the
+     * moment is indeterminate and unknowable -- in which case the certificate
+     * validity period is not checked
+     */
+    moment?: Date | null;
+    /**
+     * Certificate store to use for verifying the certificate
+     */
+    store?: {
+        /**
+         * Root certificates
+         */
+        root?: Set<Certificate>;
+        /**
+         * Intermediate certificates
+         */
+        intermediate?: Set<Certificate>;
+    };
+    /**
+     * Indicate this certificate is a root certificate that we trust --
+     * it will get a "chain" parameter even if no "store" is provided
+     * or if it is not in the store.  This is because otherwise we would
+     * need to load trusted certificates twice, once for the store and
+     * once for the chain.
+     */
+    isTrustedRoot?: boolean;
+};
+export declare class Certificate {
+    #private;
+    /**
+     * The Certificate Builder
+     */
+    static readonly Builder: typeof CertificateBuilder;
+    /**
+     * The serial number of the certificate
+     */
+    readonly serial: bigint;
+    /**
+     * The timestamp at which the certificate becomes valid
+     */
+    readonly notBefore: Date;
+    /**
+     * The timestamp at which the certificate expires
+     */
+    readonly notAfter: Date;
+    /**
+     * The Subject DN of the certificate as a string --- for informational purposes only
+     */
+    readonly subject: string;
+    /**
+     * The Issuer DN of the certificate as a string --- for informational purposes only
+     */
+    readonly issuer: string;
+    /**
+     * The Subject of the certificate as a KeetaNet Account, derived from the
+     * public key in the certificate
+     */
+    readonly subjectPublicKey: Account;
+    /**
+     * The moment at which the certificate was validated
+     */
+    readonly moment: Date | null;
+    /**
+     * Chain, if a store is provided
+     */
+    readonly chain?: Certificate[];
+    /**
+     * Basic Extensions
+     */
+    readonly baseExtensions?: {
+        /**
+         * Basic Constraints
+         */
+        basicConstraints?: [
+            ca: boolean,
+            pathLenConstraint?: bigint
+        ];
+        /**
+         * Subject Key Identifier
+         */
+        subjectKeyIdentifier?: Buffer;
+        /**
+         * Authority Key Identifier
+         */
+        authorityKeyIdentifier?: {
+            type: 'context';
+            value: 0;
+            contains: Buffer;
+        };
+    };
+    /**
+     * The complete SubjectDN
+     */
+    protected subjectDN: CertificateSchema[0][5];
+    /**
+     * The complete IssuerDN
+     */
+    protected issuerDN: CertificateSchema[0][3];
+    /**
+     * Object type ID for @see Certificate.isCertificate
+     */
+    private static certificateObjectTypeID;
+    /**
+     * Is a certificate object?
+     */
+    static isCertificate(value: unknown): value is Certificate;
+    constructor(input: Certificate | ArrayBuffer | Buffer | string, options?: CertificateOptions);
+    /**
+     * Finalize construction of the certificate -- if this method is
+     * replaced in a subclass, remember to call it at the end of the
+     * subclass constructor or the certificate will not be fully
+     * constructed
+     */
+    protected finalizeConstruction(): void;
+    /**
+     * Process remaining extensions
+     */
+    protected processExtensions(): void;
+    /**
+     * Process an extension -- returns true if the extension was processed
+     *
+     * This is intended to be overridden by subclasses for processing
+     * custom extensions
+     */
+    protected processExtension(id: string, value: ArrayBuffer): boolean;
+    /**
+     * Verifies that a certificate is self-signed
+     */
+    isSelfSigned(): boolean;
+    /**
+     * Verifies that the certificate is was signed by the given account or certificate
+     */
+    verify(account: Account | Certificate): boolean;
+    /**
+     * Verify against a given certificate store
+     */
+    verifyChain(store: NonNullable<CertificateOptions['store']>, _ignore_seenCerts?: Set<Certificate>): Certificate[] | null;
+    /**
+     * Check if the certificate is valid at a given moment
+     */
+    checkValid(moment?: Date | null): boolean;
+    checkValid(moment?: Date | null, reason?: false): boolean;
+    checkValid(moment?: Date | null, reason?: true): {
+        valid: true;
+    } | {
+        valid: false;
+        reason: string;
+    };
+    /**
+     * Assert that the certificate is valid at a given moment
+     */
+    assertValid(moment?: Date | null): void;
+    /**
+     * Check if the certificate is issued by a given issuer
+     */
+    checkIssued(issuer: Certificate): boolean;
+    checkIssued(issuer: Certificate, reason: true): {
+        issued: true;
+    } | {
+        issued: false;
+        reason: string;
+    };
+    /**
+     * Get the issuer certificate (if known)
+     */
+    getIssuerCertificate(): Certificate | null;
+    /**
+     * Get the root certificate (if known)
+     */
+    getRootCertificate(): Certificate | null;
+    /**
+     * Get the issuer account
+     */
+    getIssuerAccount(): Account | null;
+    private assertConstructed;
+    /**
+     * Compare the certificate with another certificate and return true if they
+     * are the same
+     */
+    equals(other: Certificate): boolean;
+    /**
+     * If this certificate can be trusted to have been validated to a trusted Root CA
+     */
+    get trusted(): boolean;
+    /**
+     * Get the certificate as a DER encoded ArrayBuffer
+     */
+    toDER(): ArrayBuffer;
+    /**
+     * Get the certificate as a PEM encoded string
+     */
+    toPEM(): string;
+    /**
+     * Compute a hash of the certificate
+     */
+    hash(): string;
+    /**
+     * Get a JSON representation of the certificate
+     */
+    toJSON(includeChain?: boolean): any;
+}
+export default Certificate;

package/lib/utils/conversion.d.ts

@@ -0,0 +1,46 @@
+import type { Vote, VoteStaple } from '../vote';
+import type Account from '../account';
+import type { Block, BlockHash } from '../block';
+import type Permissions from '../permissions';
+export type JSONSerializable = string | number | boolean | null | JSONSerializable[] | {
+    [key: string]: JSONSerializable;
+};
+export type JSONSerializableObject = {
+    [key: string]: JSONSerializable;
+};
+type JSONUnsupportedTypes = Date | BlockHash | Account | bigint | Permissions | Vote | Block | VoteStaple;
+type JSONSupportedObject<T> = {
+    [Property in keyof T]: Exclude<T[Property], JSONUnsupportedTypes>;
+};
+type JSONSupportedValue<T> = JSONSupportedObject<T>[any];
+export type JSONSupported<T> = JSONSupportedObject<T> | JSONSupportedValue<T>;
+export type ToJSONSerializableOptions = {
+    debugUnsafe?: boolean;
+    addBinary?: boolean;
+};
+export type ToJSONSerializable<T> = T extends bigint ? string : T extends Date ? string : T extends Buffer ? string : T extends {
+    toJSONSerializable(): infer U;
+} ? U : T extends {
+    toJSON(): infer U;
+} ? ToJSONSerializable<U> : T extends Account<infer K extends typeof Account.AccountKeyAlgorithm[keyof typeof Account.AccountKeyAlgorithm]> ? ReturnType<Account<K>['publicKeyString']['get']> : T extends BlockHash ? string : T extends Permissions ? [string, string] : T extends Vote ? ReturnType<Vote['toJSON']> & {
+    '$binary': string;
+} : T extends VoteStaple ? ReturnType<VoteStaple['toJSON']> & {
+    '$binary': string;
+} : T extends Block ? ReturnType<Block['toJSON']> & {
+    '$binary': string;
+} : T extends JSONSerializable ? T : T extends object ? {
+    [K in keyof T]: ToJSONSerializable<T[K]>;
+} : never;
+export declare function toJSONSerializable(data: JSONSupported<any>, opts?: ToJSONSerializableOptions): JSONSupported<any> & JSONSerializable;
+/** @deprecated -- move to toJSON methods */
+interface WithConversionClass<T, Y> {
+    toJSONSerializablePrefix: string;
+    toJSONSerializable(value: T, options: ToJSONSerializableOptions): Y;
+    isInstance(value: any): value is T;
+    new (...args: any[]): T;
+}
+/** @deprecated -- move to toJSON methods */
+export declare function RegisterSerializable(name: string): <X, Y>(target: WithConversionClass<X, Y>) => void;
+export declare function objectToBuffer(data: JSONSupported<any>, opts?: ToJSONSerializableOptions): Buffer;
+export declare function parseHexBigIntString(input: string): bigint;
+export {};

package/lib/utils/dynamodb.d.ts

@@ -0,0 +1,17 @@
+import type { AttributeValue, DynamoDB } from '@aws-sdk/client-dynamodb';
+/**
+ * Execute some code and if a DynamoDB error occurs that is retryable, retry
+ * the execution
+ */
+export declare function dynamoDBExecuteRetryable<T>(code: () => Promise<T>, id: string): ReturnType<typeof code>;
+type AttributeValueStringMap = {
+    [key: string]: string;
+};
+type AttributeValueMap = {
+    [key: string]: AttributeValue;
+};
+export declare function dynamoDBGetItem(dynamodb: DynamoDB, table: string, keys: AttributeValueStringMap, consistent?: boolean): Promise<undefined | AttributeValueMap>;
+export declare function dynamoDBPaginatedScan(dynamodb: DynamoDB, scanArgs: Parameters<DynamoDB['scan']>[0], code: (page: AttributeValueMap[]) => Promise<any>, ordered?: boolean): Promise<void>;
+export declare function getTableState(dynamodb: DynamoDB, table: string): Promise<string>;
+export declare function waitForTableToBe(dynamodb: DynamoDB, table: string, state: string): Promise<void>;
+export {};

package/lib/utils/ed2curve.d.ts

@@ -0,0 +1,7 @@
+export declare function convertPublicKey(pk: Uint8Array): Uint8Array | null;
+export declare function convertSecretKey(sk: Uint8Array): Uint8Array;
+declare const _default: {
+    convertSecretKey: typeof convertSecretKey;
+    convertPublicKey: typeof convertPublicKey;
+};
+export default _default;

package/lib/utils/hash.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Hashing function name to use with key derivation and public key checksums
+ */
+export declare const HashFunctionName = "sha3-256";
+/**
+ * Length of the hash function
+ */
+export declare const HashFunctionLength = 32;
+/**
+ * Hash some data
+ */
+export declare function Hash(data: Buffer, len?: number): ArrayBuffer;
+export declare namespace Hash {
+    var functionName: string;
+    var functionLength: number;
+}
+export default Hash;