@pagopa/io-react-native-wallet 0.1.0

package/lib/typescript/sd-jwt/types.d.ts

@@ -0,0 +1,416 @@
+import { z } from "zod";
+export declare const UnixTime: z.ZodNumber;
+export type UnixTime = z.infer<typeof UnixTime>;
+export type ObfuscatedDisclosures = z.infer<typeof ObfuscatedDisclosures>;
+export declare const ObfuscatedDisclosures: z.ZodObject<{
+    _sd: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    _sd: string[];
+}, {
+    _sd: string[];
+}>;
+/**
+ * A triple of values in the form of {salt, claim name, claim value} that represent a parsed disclosure.
+ *
+ * @see https://datatracker.ietf.org/doc/html/draft-ietf-oauth-selective-disclosure-jwt-04
+ * @see https://vcstuff.github.io/draft-terbu-sd-jwt-vc/draft-terbu-oauth-sd-jwt-vc.html
+ */
+export type Disclosure = z.infer<typeof Disclosure>;
+export declare const Disclosure: z.ZodTuple<[z.ZodString, z.ZodString, z.ZodUnknown], null>;
+export type SdJwt4VC = z.infer<typeof SdJwt4VC>;
+export declare const SdJwt4VC: z.ZodObject<{
+    header: z.ZodObject<{
+        typ: z.ZodLiteral<"vc+sd-jwt">;
+        alg: z.ZodString;
+        kid: z.ZodString;
+        trust_chain: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        alg: string;
+        kid: string;
+        typ: "vc+sd-jwt";
+        trust_chain: string[];
+    }, {
+        alg: string;
+        kid: string;
+        typ: "vc+sd-jwt";
+        trust_chain: string[];
+    }>;
+    payload: z.ZodObject<{
+        iss: z.ZodString;
+        sub: z.ZodString;
+        jti: z.ZodString;
+        iat: z.ZodNumber;
+        exp: z.ZodNumber;
+        status: z.ZodString;
+        cnf: z.ZodObject<{
+            jwk: z.ZodObject<{
+                alg: z.ZodOptional<z.ZodString>;
+                crv: z.ZodOptional<z.ZodString>;
+                d: z.ZodOptional<z.ZodString>;
+                dp: z.ZodOptional<z.ZodString>;
+                dq: z.ZodOptional<z.ZodString>;
+                e: z.ZodOptional<z.ZodString>;
+                ext: z.ZodOptional<z.ZodBoolean>;
+                k: z.ZodOptional<z.ZodString>;
+                key_ops: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                kid: z.ZodOptional<z.ZodString>;
+                kty: z.ZodUnion<[z.ZodLiteral<"RSA">, z.ZodLiteral<"EC">]>;
+                n: z.ZodOptional<z.ZodString>;
+                p: z.ZodOptional<z.ZodString>;
+                q: z.ZodOptional<z.ZodString>;
+                qi: z.ZodOptional<z.ZodString>;
+                use: z.ZodOptional<z.ZodString>;
+                x: z.ZodOptional<z.ZodString>;
+                y: z.ZodOptional<z.ZodString>;
+                x5c: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                x5t: z.ZodOptional<z.ZodString>;
+                "x5t#S256": z.ZodOptional<z.ZodString>;
+                x5u: z.ZodOptional<z.ZodString>;
+            }, "strip", z.ZodTypeAny, {
+                kty: "RSA" | "EC";
+                alg?: string | undefined;
+                crv?: string | undefined;
+                d?: string | undefined;
+                dp?: string | undefined;
+                dq?: string | undefined;
+                e?: string | undefined;
+                ext?: boolean | undefined;
+                k?: string | undefined;
+                key_ops?: string[] | undefined;
+                kid?: string | undefined;
+                n?: string | undefined;
+                p?: string | undefined;
+                q?: string | undefined;
+                qi?: string | undefined;
+                use?: string | undefined;
+                x?: string | undefined;
+                y?: string | undefined;
+                x5c?: string[] | undefined;
+                x5t?: string | undefined;
+                "x5t#S256"?: string | undefined;
+                x5u?: string | undefined;
+            }, {
+                kty: "RSA" | "EC";
+                alg?: string | undefined;
+                crv?: string | undefined;
+                d?: string | undefined;
+                dp?: string | undefined;
+                dq?: string | undefined;
+                e?: string | undefined;
+                ext?: boolean | undefined;
+                k?: string | undefined;
+                key_ops?: string[] | undefined;
+                kid?: string | undefined;
+                n?: string | undefined;
+                p?: string | undefined;
+                q?: string | undefined;
+                qi?: string | undefined;
+                use?: string | undefined;
+                x?: string | undefined;
+                y?: string | undefined;
+                x5c?: string[] | undefined;
+                x5t?: string | undefined;
+                "x5t#S256"?: string | undefined;
+                x5u?: string | undefined;
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            jwk: {
+                kty: "RSA" | "EC";
+                alg?: string | undefined;
+                crv?: string | undefined;
+                d?: string | undefined;
+                dp?: string | undefined;
+                dq?: string | undefined;
+                e?: string | undefined;
+                ext?: boolean | undefined;
+                k?: string | undefined;
+                key_ops?: string[] | undefined;
+                kid?: string | undefined;
+                n?: string | undefined;
+                p?: string | undefined;
+                q?: string | undefined;
+                qi?: string | undefined;
+                use?: string | undefined;
+                x?: string | undefined;
+                y?: string | undefined;
+                x5c?: string[] | undefined;
+                x5t?: string | undefined;
+                "x5t#S256"?: string | undefined;
+                x5u?: string | undefined;
+            };
+        }, {
+            jwk: {
+                kty: "RSA" | "EC";
+                alg?: string | undefined;
+                crv?: string | undefined;
+                d?: string | undefined;
+                dp?: string | undefined;
+                dq?: string | undefined;
+                e?: string | undefined;
+                ext?: boolean | undefined;
+                k?: string | undefined;
+                key_ops?: string[] | undefined;
+                kid?: string | undefined;
+                n?: string | undefined;
+                p?: string | undefined;
+                q?: string | undefined;
+                qi?: string | undefined;
+                use?: string | undefined;
+                x?: string | undefined;
+                y?: string | undefined;
+                x5c?: string[] | undefined;
+                x5t?: string | undefined;
+                "x5t#S256"?: string | undefined;
+                x5u?: string | undefined;
+            };
+        }>;
+        type: z.ZodLiteral<"PersonIdentificationData">;
+        verified_claims: z.ZodObject<{
+            verification: z.ZodIntersection<z.ZodObject<{
+                trust_framework: z.ZodLiteral<"eidas">;
+                assurance_level: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                trust_framework: "eidas";
+                assurance_level: string;
+            }, {
+                trust_framework: "eidas";
+                assurance_level: string;
+            }>, z.ZodObject<{
+                _sd: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                _sd: string[];
+            }, {
+                _sd: string[];
+            }>>;
+            claims: z.ZodObject<{
+                _sd: z.ZodArray<z.ZodString, "many">;
+            }, "strip", z.ZodTypeAny, {
+                _sd: string[];
+            }, {
+                _sd: string[];
+            }>;
+        }, "strip", z.ZodTypeAny, {
+            verification: {
+                trust_framework: "eidas";
+                assurance_level: string;
+            } & {
+                _sd: string[];
+            };
+            claims: {
+                _sd: string[];
+            };
+        }, {
+            verification: {
+                trust_framework: "eidas";
+                assurance_level: string;
+            } & {
+                _sd: string[];
+            };
+            claims: {
+                _sd: string[];
+            };
+        }>;
+        _sd_alg: z.ZodLiteral<"sha-256">;
+    }, "strip", z.ZodTypeAny, {
+        type: "PersonIdentificationData";
+        status: string;
+        iss: string;
+        sub: string;
+        jti: string;
+        iat: number;
+        exp: number;
+        cnf: {
+            jwk: {
+                kty: "RSA" | "EC";
+                alg?: string | undefined;
+                crv?: string | undefined;
+                d?: string | undefined;
+                dp?: string | undefined;
+                dq?: string | undefined;
+                e?: string | undefined;
+                ext?: boolean | undefined;
+                k?: string | undefined;
+                key_ops?: string[] | undefined;
+                kid?: string | undefined;
+                n?: string | undefined;
+                p?: string | undefined;
+                q?: string | undefined;
+                qi?: string | undefined;
+                use?: string | undefined;
+                x?: string | undefined;
+                y?: string | undefined;
+                x5c?: string[] | undefined;
+                x5t?: string | undefined;
+                "x5t#S256"?: string | undefined;
+                x5u?: string | undefined;
+            };
+        };
+        verified_claims: {
+            verification: {
+                trust_framework: "eidas";
+                assurance_level: string;
+            } & {
+                _sd: string[];
+            };
+            claims: {
+                _sd: string[];
+            };
+        };
+        _sd_alg: "sha-256";
+    }, {
+        type: "PersonIdentificationData";
+        status: string;
+        iss: string;
+        sub: string;
+        jti: string;
+        iat: number;
+        exp: number;
+        cnf: {
+            jwk: {
+                kty: "RSA" | "EC";
+                alg?: string | undefined;
+                crv?: string | undefined;
+                d?: string | undefined;
+                dp?: string | undefined;
+                dq?: string | undefined;
+                e?: string | undefined;
+                ext?: boolean | undefined;
+                k?: string | undefined;
+                key_ops?: string[] | undefined;
+                kid?: string | undefined;
+                n?: string | undefined;
+                p?: string | undefined;
+                q?: string | undefined;
+                qi?: string | undefined;
+                use?: string | undefined;
+                x?: string | undefined;
+                y?: string | undefined;
+                x5c?: string[] | undefined;
+                x5t?: string | undefined;
+                "x5t#S256"?: string | undefined;
+                x5u?: string | undefined;
+            };
+        };
+        verified_claims: {
+            verification: {
+                trust_framework: "eidas";
+                assurance_level: string;
+            } & {
+                _sd: string[];
+            };
+            claims: {
+                _sd: string[];
+            };
+        };
+        _sd_alg: "sha-256";
+    }>;
+}, "strip", z.ZodTypeAny, {
+    header: {
+        alg: string;
+        kid: string;
+        typ: "vc+sd-jwt";
+        trust_chain: string[];
+    };
+    payload: {
+        type: "PersonIdentificationData";
+        status: string;
+        iss: string;
+        sub: string;
+        jti: string;
+        iat: number;
+        exp: number;
+        cnf: {
+            jwk: {
+                kty: "RSA" | "EC";
+                alg?: string | undefined;
+                crv?: string | undefined;
+                d?: string | undefined;
+                dp?: string | undefined;
+                dq?: string | undefined;
+                e?: string | undefined;
+                ext?: boolean | undefined;
+                k?: string | undefined;
+                key_ops?: string[] | undefined;
+                kid?: string | undefined;
+                n?: string | undefined;
+                p?: string | undefined;
+                q?: string | undefined;
+                qi?: string | undefined;
+                use?: string | undefined;
+                x?: string | undefined;
+                y?: string | undefined;
+                x5c?: string[] | undefined;
+                x5t?: string | undefined;
+                "x5t#S256"?: string | undefined;
+                x5u?: string | undefined;
+            };
+        };
+        verified_claims: {
+            verification: {
+                trust_framework: "eidas";
+                assurance_level: string;
+            } & {
+                _sd: string[];
+            };
+            claims: {
+                _sd: string[];
+            };
+        };
+        _sd_alg: "sha-256";
+    };
+}, {
+    header: {
+        alg: string;
+        kid: string;
+        typ: "vc+sd-jwt";
+        trust_chain: string[];
+    };
+    payload: {
+        type: "PersonIdentificationData";
+        status: string;
+        iss: string;
+        sub: string;
+        jti: string;
+        iat: number;
+        exp: number;
+        cnf: {
+            jwk: {
+                kty: "RSA" | "EC";
+                alg?: string | undefined;
+                crv?: string | undefined;
+                d?: string | undefined;
+                dp?: string | undefined;
+                dq?: string | undefined;
+                e?: string | undefined;
+                ext?: boolean | undefined;
+                k?: string | undefined;
+                key_ops?: string[] | undefined;
+                kid?: string | undefined;
+                n?: string | undefined;
+                p?: string | undefined;
+                q?: string | undefined;
+                qi?: string | undefined;
+                use?: string | undefined;
+                x?: string | undefined;
+                y?: string | undefined;
+                x5c?: string[] | undefined;
+                x5t?: string | undefined;
+                "x5t#S256"?: string | undefined;
+                x5u?: string | undefined;
+            };
+        };
+        verified_claims: {
+            verification: {
+                trust_framework: "eidas";
+                assurance_level: string;
+            } & {
+                _sd: string[];
+            };
+            claims: {
+                _sd: string[];
+            };
+        };
+        _sd_alg: "sha-256";
+    };
+}>;
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/sd-jwt/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/sd-jwt/types.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,QAAQ,aAAuC,CAAC;AAC7D,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAC1E,eAAO,MAAM,qBAAqB;;;;;;EAAyC,CAAC;AAE5E;;;;;GAKG;AACH,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AACpD,eAAO,MAAM,UAAU,4DAIrB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAChD,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA8BnB,CAAC"}

package/lib/typescript/sd-jwt/verifier.d.ts

@@ -0,0 +1,3 @@
+import type { ObfuscatedDisclosures } from "./types";
+export declare const verifyDisclosure: (disclosure: [string, string, unknown], claims: ObfuscatedDisclosures["_sd"]) => Promise<void>;
+//# sourceMappingURL=verifier.d.ts.map

package/lib/typescript/sd-jwt/verifier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verifier.d.ts","sourceRoot":"","sources":["../../../src/sd-jwt/verifier.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAc,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAEjE,eAAO,MAAM,gBAAgB,kDAEnB,qBAAqB,CAAC,KAAK,CAAC,kBAYrC,CAAC"}

package/lib/typescript/utils/errors.d.ts

@@ -0,0 +1,45 @@
+/**
+ * A generic Error that all other io-wallet specific Error subclasses extend.
+ *
+ * @example Checking thrown error is a io-wallet one
+ *
+ * ```js
+ * if (err instanceof errors.IoWalletError) {
+ *   // ...
+ * }
+ * ```
+ */
+export declare class IoWalletError extends Error {
+    /** A unique error code for the particular error subclass. */
+    static get code(): string;
+    /** A unique error code for the particular error subclass. */
+    code: string;
+    constructor(message?: string);
+}
+/**
+ * An error subclass thrown when validation fail
+ *
+ */
+export declare class ValidationFailed extends IoWalletError {
+    static get code(): "ERR_IO_WALLET_VALIDATION_FAILED";
+    code: string;
+    /** The Claim for which the validation failed. */
+    claim: string;
+    /** Reason code for the validation failure. */
+    reason: string;
+    constructor(message: string, claim?: string, reason?: string);
+}
+/**
+ * An error subclass thrown when validation fail
+ *
+ */
+export declare class WalletInstanceAttestationIssuingError extends IoWalletError {
+    static get code(): "ERR_IO_WALLET_INSTANCE_ATTESTATION_ISSUING_FAILED";
+    code: string;
+    /** The Claim for which the validation failed. */
+    claim: string;
+    /** Reason code for the validation failure. */
+    reason: string;
+    constructor(message: string, claim?: string, reason?: string);
+}
+//# sourceMappingURL=errors.d.ts.map

package/lib/typescript/utils/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/utils/errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,qBAAa,aAAc,SAAQ,KAAK;IACtC,6DAA6D;IAC7D,MAAM,KAAK,IAAI,IAAI,MAAM,CAExB;IAED,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAA2B;gBAE3B,OAAO,CAAC,EAAE,MAAM;CAM7B;AACD;;;GAGG;AACH,qBAAa,gBAAiB,SAAQ,aAAa;IACjD,MAAM,KAAK,IAAI,IAAI,iCAAiC,CAEnD;IAED,IAAI,SAAqC;IAEzC,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IAEd,8CAA8C;IAC9C,MAAM,EAAE,MAAM,CAAC;gBAEH,OAAO,EAAE,MAAM,EAAE,KAAK,SAAgB,EAAE,MAAM,SAAgB;CAK3E;AAED;;;GAGG;AACH,qBAAa,qCAAsC,SAAQ,aAAa;IACtE,MAAM,KAAK,IAAI,IAAI,mDAAmD,CAErE;IAED,IAAI,SAAuD;IAE3D,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAC;IAEd,8CAA8C;IAC9C,MAAM,EAAE,MAAM,CAAC;gBAEH,OAAO,EAAE,MAAM,EAAE,KAAK,SAAgB,EAAE,MAAM,SAAgB;CAK3E"}

package/lib/typescript/utils/jwk.d.ts

@@ -0,0 +1,85 @@
+import { z } from "zod";
+export type JWK = z.infer<typeof JWK>;
+export declare const JWK: z.ZodObject<{
+    /** JWK "alg" (Algorithm) Parameter. */
+    alg: z.ZodOptional<z.ZodString>;
+    crv: z.ZodOptional<z.ZodString>;
+    d: z.ZodOptional<z.ZodString>;
+    dp: z.ZodOptional<z.ZodString>;
+    dq: z.ZodOptional<z.ZodString>;
+    e: z.ZodOptional<z.ZodString>;
+    /** JWK "ext" (Extractable) Parameter. */
+    ext: z.ZodOptional<z.ZodBoolean>;
+    k: z.ZodOptional<z.ZodString>;
+    /** JWK "key_ops" (Key Operations) Parameter. */
+    key_ops: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** JWK "kid" (Key ID) Parameter. */
+    kid: z.ZodOptional<z.ZodString>;
+    /** JWK "kty" (Key Type) Parameter.
+     * This attribute is required to discriminate the
+     * type of EC/RSA algorithm */
+    kty: z.ZodUnion<[z.ZodLiteral<"RSA">, z.ZodLiteral<"EC">]>;
+    n: z.ZodOptional<z.ZodString>;
+    p: z.ZodOptional<z.ZodString>;
+    q: z.ZodOptional<z.ZodString>;
+    qi: z.ZodOptional<z.ZodString>;
+    /** JWK "use" (Public Key Use) Parameter. */
+    use: z.ZodOptional<z.ZodString>;
+    x: z.ZodOptional<z.ZodString>;
+    y: z.ZodOptional<z.ZodString>;
+    /** JWK "x5c" (X.509 Certificate Chain) Parameter. */
+    x5c: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** JWK "x5t" (X.509 Certificate SHA-1 Thumbprint) Parameter. */
+    x5t: z.ZodOptional<z.ZodString>;
+    /** "x5t#S256" (X.509 Certificate SHA-256 Thumbprint) Parameter. */
+    "x5t#S256": z.ZodOptional<z.ZodString>;
+    /** JWK "x5u" (X.509 URL) Parameter. */
+    x5u: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    kty: "RSA" | "EC";
+    alg?: string | undefined;
+    crv?: string | undefined;
+    d?: string | undefined;
+    dp?: string | undefined;
+    dq?: string | undefined;
+    e?: string | undefined;
+    ext?: boolean | undefined;
+    k?: string | undefined;
+    key_ops?: string[] | undefined;
+    kid?: string | undefined;
+    n?: string | undefined;
+    p?: string | undefined;
+    q?: string | undefined;
+    qi?: string | undefined;
+    use?: string | undefined;
+    x?: string | undefined;
+    y?: string | undefined;
+    x5c?: string[] | undefined;
+    x5t?: string | undefined;
+    "x5t#S256"?: string | undefined;
+    x5u?: string | undefined;
+}, {
+    kty: "RSA" | "EC";
+    alg?: string | undefined;
+    crv?: string | undefined;
+    d?: string | undefined;
+    dp?: string | undefined;
+    dq?: string | undefined;
+    e?: string | undefined;
+    ext?: boolean | undefined;
+    k?: string | undefined;
+    key_ops?: string[] | undefined;
+    kid?: string | undefined;
+    n?: string | undefined;
+    p?: string | undefined;
+    q?: string | undefined;
+    qi?: string | undefined;
+    use?: string | undefined;
+    x?: string | undefined;
+    y?: string | undefined;
+    x5c?: string[] | undefined;
+    x5t?: string | undefined;
+    "x5t#S256"?: string | undefined;
+    x5u?: string | undefined;
+}>;
+//# sourceMappingURL=jwk.d.ts.map

package/lib/typescript/utils/jwk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jwk.d.ts","sourceRoot":"","sources":["../../../src/utils/jwk.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,GAAG,CAAC,CAAC;AACtC,eAAO,MAAM,GAAG;IACd,uCAAuC;;;;;;;IAOvC,yCAAyC;;;IAGzC,gDAAgD;;IAEhD,oCAAoC;;IAEpC;;kCAE8B;;;;;;IAM9B,4CAA4C;;;;IAI5C,qDAAqD;;IAErD,gEAAgE;;IAEhE,mEAAmE;;IAEnE,uCAAuC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEvC,CAAC"}

package/lib/typescript/wallet-instance-attestation/index.d.ts

@@ -0,0 +1,36 @@
+import { WalletInstanceAttestationJwt } from "./types";
+import { Issuing } from "./issuing";
+export { Issuing };
+/**
+ * Decode a given JWT to get the parsed Wallet Instance Attestation object they define.
+ * It ensures provided data is in a valid shape.
+ *
+ * It DOES NOT verify token signature nor check disclosures are correctly referenced by the JWT.
+ * Use {@link verify} instead
+ *
+ * @function
+ * @param token The encoded token that represents a valid jwt for Wallet Instance Attestation
+ *
+ * @returns The validated Wallet Instance Attestation object
+ * @throws A decoding error if the token doesn't resolve in a valid JWT
+ * @throws A validation error if the provided data doesn't result in a valid Wallet Instance Attestation
+ *
+ */
+export declare function decode(token: string): WalletInstanceAttestationJwt;
+/**
+ * Verify a given JWT to get the parsed Wallet Instance Attestation object they define.
+ * Same as {@link decode} plus token signature verification
+ *
+ * @async @function
+ *
+ *
+ * @param token The encoded token that represents a valid jwt
+ *
+ * @returns {WalletInstanceAttestationJwt} The validated Wallet Instance Attestation object
+ * @throws A decoding error if the token doesn't resolve in a valid JWT
+ * @throws A validation error if the provided data doesn't result in a valid Wallet Instance Attestation
+ * @throws Invalid signature error if the token signature is not valid
+ *
+ */
+export declare function verify(token: string): Promise<WalletInstanceAttestationJwt>;
+//# sourceMappingURL=index.d.ts.map

package/lib/typescript/wallet-instance-attestation/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/wallet-instance-attestation/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,4BAA4B,EAAE,MAAM,SAAS,CAAC;AAIvD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,OAAO,EAAE,CAAC;AACnB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,MAAM,GAAG,4BAA4B,CAQlE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,MAAM,CAC1B,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,4BAA4B,CAAC,CAOvC"}

package/lib/typescript/wallet-instance-attestation/issuing.d.ts

@@ -0,0 +1,32 @@
+import { JWK } from "../utils/jwk";
+export declare class Issuing {
+    walletProviderBaseUrl: string;
+    constructor(walletProviderBaseUrl: string);
+    /**
+     * Get the Wallet Instance Attestation Request to sign
+     *
+     * @async @function
+     *
+     * @param jwk Public key of the wallet instance
+     *
+     * @returns {string} Wallet Instance Attestation Request to sign
+     *
+     */
+    getAttestationRequestToSign(jwk: JWK): Promise<string>;
+    /**
+     * Get the Wallet Instance Attestation given a
+     * Wallet Instance Attestation Request and signature
+     *
+     * @async @function
+     *
+     * @param attestationRequest Wallet Instance Attestaion Request
+     * obtained with {@link getAttestationRequestToSign}
+     * @param signature Signature of the Wallet Instance Attestaion Request
+     * @param appFetch Optional object with fetch function to use
+     *
+     * @returns {string} Wallet Instance Attestation
+     *
+     */
+    getAttestation(attestationRequest: string, signature: string, appFetch?: GlobalFetch): Promise<String>;
+}
+//# sourceMappingURL=issuing.d.ts.map

package/lib/typescript/wallet-instance-attestation/issuing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issuing.d.ts","sourceRoot":"","sources":["../../../src/wallet-instance-attestation/issuing.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAKnC,qBAAa,OAAO;IAClB,qBAAqB,EAAE,MAAM,CAAC;gBAElB,qBAAqB,EAAE,MAAM;IAIzC;;;;;;;;;OASG;IACG,2BAA2B,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IA0B5D;;;;;;;;;;;;;OAaG;IACG,cAAc,CAClB,kBAAkB,EAAE,MAAM,EAC1B,SAAS,EAAE,MAAM,EACjB,QAAQ,GAAE,WAAuB,GAChC,OAAO,CAAC,MAAM,CAAC;CAqCnB"}