@0xsequence/wallet-wdk 0.0.0-20250520201059

package/dist/dbs/signatures.js

@@ -0,0 +1,13 @@
+import { Generic } from './generic.js';
+const TABLE_NAME = 'envelopes';
+export class Signatures extends Generic {
+    constructor(dbName = 'sequence-signature-requests') {
+        super(dbName, TABLE_NAME, 'id', [
+            (db) => {
+                if (!db.objectStoreNames.contains(TABLE_NAME)) {
+                    db.createObjectStore(TABLE_NAME);
+                }
+            },
+        ]);
+    }
+}

package/dist/dbs/transactions.d.ts

@@ -0,0 +1,6 @@
+import { Transaction } from '../sequence/types/transaction-request.js';
+import { Generic } from './generic.js';
+export declare class Transactions extends Generic<Transaction, 'id'> {
+    constructor(dbName?: string);
+}
+//# sourceMappingURL=transactions.d.ts.map

package/dist/dbs/transactions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactions.d.ts","sourceRoot":"","sources":["../../src/dbs/transactions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0CAA0C,CAAA;AACtE,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAItC,qBAAa,YAAa,SAAQ,OAAO,CAAC,WAAW,EAAE,IAAI,CAAC;gBAC9C,MAAM,GAAE,MAAgC;CASrD"}

package/dist/dbs/transactions.js

@@ -0,0 +1,13 @@
+import { Generic } from './generic.js';
+const TABLE_NAME = 'transactions';
+export class Transactions extends Generic {
+    constructor(dbName = 'sequence-transactions') {
+        super(dbName, TABLE_NAME, 'id', [
+            (db) => {
+                if (!db.objectStoreNames.contains(TABLE_NAME)) {
+                    db.createObjectStore(TABLE_NAME);
+                }
+            },
+        ]);
+    }
+}

package/dist/dbs/wallets.d.ts

@@ -0,0 +1,6 @@
+import { Generic } from './generic.js';
+import { Wallet } from '../sequence/types/wallet.js';
+export declare class Wallets extends Generic<Wallet, 'address'> {
+    constructor(dbName?: string);
+}
+//# sourceMappingURL=wallets.d.ts.map

package/dist/dbs/wallets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wallets.d.ts","sourceRoot":"","sources":["../../src/dbs/wallets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,MAAM,EAAE,MAAM,6BAA6B,CAAA;AAIpD,qBAAa,OAAQ,SAAQ,OAAO,CAAC,MAAM,EAAE,SAAS,CAAC;gBACzC,MAAM,GAAE,MAA2B;CAShD"}

package/dist/dbs/wallets.js

@@ -0,0 +1,13 @@
+import { Generic } from './generic.js';
+const TABLE_NAME = 'wallets';
+export class Wallets extends Generic {
+    constructor(dbName = 'sequence-manager') {
+        super(dbName, TABLE_NAME, 'address', [
+            (db) => {
+                if (!db.objectStoreNames.contains(TABLE_NAME)) {
+                    db.createObjectStore(TABLE_NAME);
+                }
+            },
+        ]);
+    }
+}

package/dist/identity/signer.d.ts

@@ -0,0 +1,17 @@
+import { Address, Bytes } from 'ox';
+import { Signers, State } from '@0xsequence/wallet-core';
+import { IdentityInstrument } from '@0xsequence/identity-instrument';
+import { AuthKey } from '../dbs/auth-keys.js';
+import { Payload, Signature as SequenceSignature } from '@0xsequence/wallet-primitives';
+import * as Identity from '@0xsequence/identity-instrument';
+export declare function toIdentityAuthKey(authKey: AuthKey): Identity.AuthKey;
+export declare class IdentitySigner implements Signers.Signer {
+    readonly identityInstrument: IdentityInstrument;
+    readonly authKey: AuthKey;
+    constructor(identityInstrument: IdentityInstrument, authKey: AuthKey);
+    get address(): `0x${string}`;
+    sign(wallet: Address.Address, chainId: bigint, payload: Payload.Parented): Promise<SequenceSignature.SignatureOfSignerLeaf>;
+    signDigest(digest: Bytes.Bytes): Promise<SequenceSignature.SignatureOfSignerLeafHash>;
+    witness(stateWriter: State.Writer, wallet: Address.Address, extra?: Object): Promise<void>;
+}
+//# sourceMappingURL=signer.d.ts.map

package/dist/identity/signer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signer.d.ts","sourceRoot":"","sources":["../../src/identity/signer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAkB,KAAK,EAAmB,MAAM,IAAI,CAAA;AACpE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,EAAE,kBAAkB,EAAW,MAAM,iCAAiC,CAAA;AAC7E,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAA;AAC7C,OAAO,EAAE,OAAO,EAAE,SAAS,IAAI,iBAAiB,EAAE,MAAM,+BAA+B,CAAA;AACvF,OAAO,KAAK,QAAQ,MAAM,iCAAiC,CAAA;AAE3D,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,OAAO,GAAG,QAAQ,CAAC,OAAO,CAiBpE;AAED,qBAAa,cAAe,YAAW,OAAO,CAAC,MAAM;IAEjD,QAAQ,CAAC,kBAAkB,EAAE,kBAAkB;IAC/C,QAAQ,CAAC,OAAO,EAAE,OAAO;gBADhB,kBAAkB,EAAE,kBAAkB,EACtC,OAAO,EAAE,OAAO;IAG3B,IAAI,OAAO,IAAI,KAAK,MAAM,EAAE,CAK3B;IAEK,IAAI,CACR,MAAM,EAAE,OAAO,CAAC,OAAO,EACvB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,OAAO,CAAC,QAAQ,GACxB,OAAO,CAAC,iBAAiB,CAAC,qBAAqB,CAAC;IAK7C,UAAU,CAAC,MAAM,EAAE,KAAK,CAAC,KAAK,GAAG,OAAO,CAAC,iBAAiB,CAAC,yBAAyB,CAAC;IASrF,OAAO,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAoBjG"}

package/dist/identity/signer.js

@@ -0,0 +1,58 @@
+import { Address, Signature, Hex } from 'ox';
+import { Payload } from '@0xsequence/wallet-primitives';
+import * as Identity from '@0xsequence/identity-instrument';
+export function toIdentityAuthKey(authKey) {
+    return {
+        address: authKey.address,
+        keyType: Identity.KeyType.P256R1,
+        signer: authKey.identitySigner,
+        async sign(digest) {
+            const authKeySignature = await window.crypto.subtle.sign({
+                name: 'ECDSA',
+                hash: 'SHA-256',
+            }, authKey.privateKey, digest);
+            return Hex.fromBytes(new Uint8Array(authKeySignature));
+        },
+    };
+}
+export class IdentitySigner {
+    identityInstrument;
+    authKey;
+    constructor(identityInstrument, authKey) {
+        this.identityInstrument = identityInstrument;
+        this.authKey = authKey;
+    }
+    get address() {
+        if (!Address.validate(this.authKey.identitySigner)) {
+            throw new Error('No signer address found');
+        }
+        return Address.checksum(this.authKey.identitySigner);
+    }
+    async sign(wallet, chainId, payload) {
+        const payloadHash = Payload.hash(wallet, chainId, payload);
+        return this.signDigest(payloadHash);
+    }
+    async signDigest(digest) {
+        const sigHex = await this.identityInstrument.sign(toIdentityAuthKey(this.authKey), digest);
+        const sig = Signature.fromHex(sigHex);
+        return {
+            type: 'hash',
+            ...sig,
+        };
+    }
+    async witness(stateWriter, wallet, extra) {
+        const payload = Payload.fromMessage(Hex.fromString(JSON.stringify({
+            action: 'consent-to-be-part-of-wallet',
+            wallet,
+            signer: this.address,
+            timestamp: Date.now(),
+            ...extra,
+        })));
+        const signature = await this.sign(wallet, 0n, payload);
+        await stateWriter.saveWitnesses(wallet, 0n, payload, {
+            type: 'unrecovered-signer',
+            weight: 1n,
+            signature,
+        });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * as Identity from './identity/signer.js';
+export * as Sequence from './sequence/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,QAAQ,MAAM,sBAAsB,CAAA;AAChD,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAA"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export * as Identity from './identity/signer.js';
+export * as Sequence from './sequence/index.js';

package/dist/sequence/cron.d.ts

@@ -0,0 +1,19 @@
+import { Shared } from './manager.js';
+export declare class Cron {
+    private readonly shared;
+    private jobs;
+    private checkInterval?;
+    private readonly STORAGE_KEY;
+    private isStopping;
+    private currentCheckJobsPromise;
+    constructor(shared: Shared);
+    private start;
+    private executeCheckJobsChain;
+    stop(): Promise<void>;
+    registerJob(id: string, interval: number, handler: () => Promise<void>): void;
+    unregisterJob(id: string): void;
+    private checkJobs;
+    private getStorageState;
+    private syncWithStorage;
+}
+//# sourceMappingURL=cron.d.ts.map

package/dist/sequence/cron.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cron.d.ts","sourceRoot":"","sources":["../../src/sequence/cron.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AASrC,qBAAa,IAAI;IAOH,OAAO,CAAC,QAAQ,CAAC,MAAM;IANnC,OAAO,CAAC,IAAI,CAAkC;IAC9C,OAAO,CAAC,aAAa,CAAC,CAAgC;IACtD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAuB;IACnD,OAAO,CAAC,UAAU,CAAiB;IACnC,OAAO,CAAC,uBAAuB,CAAmC;gBAErC,MAAM,EAAE,MAAM;IAI3C,OAAO,CAAC,KAAK;IAOb,OAAO,CAAC,qBAAqB;IAWhB,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAelC,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC;IAStE,aAAa,CAAC,EAAE,EAAE,MAAM;YAIV,SAAS;YAwDT,eAAe;YAMf,eAAe;CAK9B"}

package/dist/sequence/cron.js

@@ -0,0 +1,118 @@
+export class Cron {
+    shared;
+    jobs = new Map();
+    checkInterval;
+    STORAGE_KEY = 'sequence-cron-jobs';
+    isStopping = false;
+    currentCheckJobsPromise = Promise.resolve();
+    constructor(shared) {
+        this.shared = shared;
+        this.start();
+    }
+    start() {
+        if (this.isStopping)
+            return;
+        this.executeCheckJobsChain();
+        this.checkInterval = setInterval(() => this.executeCheckJobsChain(), 60 * 1000);
+    }
+    // Wraps checkJobs to chain executions and manage currentCheckJobsPromise
+    executeCheckJobsChain() {
+        this.currentCheckJobsPromise = this.currentCheckJobsPromise
+            .catch(() => { }) // Ignore errors from previous chain link for sequencing
+            .then(() => {
+            if (!this.isStopping) {
+                return this.checkJobs();
+            }
+            return Promise.resolve();
+        });
+    }
+    async stop() {
+        this.isStopping = true;
+        if (this.checkInterval) {
+            clearInterval(this.checkInterval);
+            this.checkInterval = undefined;
+            this.shared.modules.logger.log('Cron: Interval cleared.');
+        }
+        // Wait for the promise of the last (or current) checkJobs execution
+        await this.currentCheckJobsPromise.catch((err) => {
+            console.error('Cron: Error during currentCheckJobsPromise settlement in stop():', err);
+        });
+    }
+    registerJob(id, interval, handler) {
+        if (this.jobs.has(id)) {
+            throw new Error(`Job with ID ${id} already exists`);
+        }
+        const job = { id, interval, lastRun: 0, handler };
+        this.jobs.set(id, job);
+        // No syncWithStorage needed here, it happens in checkJobs
+    }
+    unregisterJob(id) {
+        this.jobs.delete(id);
+    }
+    async checkJobs() {
+        if (this.isStopping) {
+            return;
+        }
+        try {
+            await navigator.locks.request('sequence-cron-jobs', async (lock) => {
+                if (this.isStopping) {
+                    return;
+                }
+                if (!lock) {
+                    return;
+                }
+                const now = Date.now();
+                const storage = await this.getStorageState();
+                for (const [id, job] of this.jobs) {
+                    if (this.isStopping) {
+                        break;
+                    }
+                    const lastRun = storage.get(id)?.lastRun ?? job.lastRun;
+                    const timeSinceLastRun = now - lastRun;
+                    if (timeSinceLastRun >= job.interval) {
+                        try {
+                            await job.handler();
+                            if (!this.isStopping) {
+                                job.lastRun = now;
+                                storage.set(id, { lastRun: now });
+                            }
+                            else {
+                            }
+                        }
+                        catch (error) {
+                            if (error instanceof DOMException && error.name === 'AbortError') {
+                                this.shared.modules.logger.log(`Cron: Job ${id} was aborted.`);
+                            }
+                            else {
+                                console.error(`Cron job ${id} failed:`, error);
+                            }
+                        }
+                    }
+                }
+                if (!this.isStopping) {
+                    await this.syncWithStorage();
+                }
+            });
+        }
+        catch (error) {
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                this.shared.modules.logger.log('Cron: navigator.locks.request was aborted.');
+            }
+            else {
+                console.error('Cron: Error in navigator.locks.request:', error);
+            }
+        }
+    }
+    async getStorageState() {
+        if (this.isStopping)
+            return new Map();
+        const state = localStorage.getItem(this.STORAGE_KEY);
+        return new Map(state ? JSON.parse(state) : []);
+    }
+    async syncWithStorage() {
+        if (this.isStopping)
+            return;
+        const state = Array.from(this.jobs.entries()).map(([id, job]) => [id, { lastRun: job.lastRun }]);
+        localStorage.setItem(this.STORAGE_KEY, JSON.stringify(state));
+    }
+}

package/dist/sequence/devices.d.ts

@@ -0,0 +1,14 @@
+import { Signers } from '@0xsequence/wallet-core';
+import { Address } from 'ox';
+import { Shared } from './manager.js';
+export declare class Devices {
+    private readonly shared;
+    constructor(shared: Shared);
+    list(): Promise<`0x${string}`[]>;
+    has(address: Address.Address): Promise<boolean>;
+    create(): Promise<Signers.Pk.Pk>;
+    get(address: Address.Address): Promise<Signers.Pk.Pk | undefined>;
+    witness(address: Address.Address, wallet: Address.Address): Promise<void>;
+    remove(address: Address.Address): Promise<void>;
+}
+//# sourceMappingURL=devices.d.ts.map

package/dist/sequence/devices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devices.d.ts","sourceRoot":"","sources":["../../src/sequence/devices.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAA;AACjD,OAAO,EAAE,OAAO,EAAE,MAAM,IAAI,CAAA;AAE5B,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAErC,qBAAa,OAAO;IACN,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAErC,IAAI;IAIJ,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO;IAK5B,MAAM;IAYN,GAAG,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO;IAS5B,OAAO,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,OAAO;IAWzD,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO;CAGtC"}

package/dist/sequence/devices.js

@@ -0,0 +1,43 @@
+import { Signers } from '@0xsequence/wallet-core';
+import { Kinds } from './types/signer.js';
+export class Devices {
+    shared;
+    constructor(shared) {
+        this.shared = shared;
+    }
+    async list() {
+        return this.shared.databases.encryptedPks.listAddresses();
+    }
+    async has(address) {
+        const entry = await this.shared.databases.encryptedPks.getEncryptedEntry(address);
+        return entry !== undefined;
+    }
+    async create() {
+        const e = await this.shared.databases.encryptedPks.generateAndStore();
+        const s = await this.shared.databases.encryptedPks.getEncryptedPkStore(e.address);
+        if (!s) {
+            throw new Error('Failed to create session');
+        }
+        this.shared.modules.logger.log('Created new session:', s.address);
+        return new Signers.Pk.Pk(s);
+    }
+    async get(address) {
+        const s = await this.shared.databases.encryptedPks.getEncryptedPkStore(address);
+        if (!s) {
+            return undefined;
+        }
+        return new Signers.Pk.Pk(s);
+    }
+    async witness(address, wallet) {
+        const signer = await this.get(address);
+        if (!signer) {
+            throw new Error('Signer not found');
+        }
+        await signer.witness(this.shared.sequence.stateProvider, wallet, {
+            signerKind: Kinds.LocalDevice,
+        });
+    }
+    async remove(address) {
+        await this.shared.databases.encryptedPks.remove(address);
+    }
+}

package/dist/sequence/handlers/authcode-pkce.d.ts

@@ -0,0 +1,14 @@
+import { Handler } from './handler.js';
+import * as Db from '../../dbs/index.js';
+import { Signatures } from '../signatures.js';
+import * as Identity from '@0xsequence/identity-instrument';
+import { IdentitySigner } from '../../identity/signer.js';
+import { AuthCodeHandler } from './authcode.js';
+export declare class AuthCodePkceHandler extends AuthCodeHandler implements Handler {
+    constructor(signupKind: 'google-pkce', issuer: string, audience: string, nitro: Identity.IdentityInstrument, signatures: Signatures, commitments: Db.AuthCommitments, authKeys: Db.AuthKeys);
+    commitAuth(target: string, isSignUp: boolean, state?: string, signer?: string): Promise<string>;
+    completeAuth(commitment: Db.AuthCommitment, code: string): Promise<[IdentitySigner, {
+        [key: string]: string;
+    }]>;
+}
+//# sourceMappingURL=authcode-pkce.d.ts.map

package/dist/sequence/handlers/authcode-pkce.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authcode-pkce.d.ts","sourceRoot":"","sources":["../../../src/sequence/handlers/authcode-pkce.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,KAAK,EAAE,MAAM,oBAAoB,CAAA;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,KAAK,QAAQ,MAAM,iCAAiC,CAAA;AAC3D,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAE/C,qBAAa,mBAAoB,SAAQ,eAAgB,YAAW,OAAO;gBAEvE,UAAU,EAAE,aAAa,EACzB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,QAAQ,CAAC,kBAAkB,EAClC,UAAU,EAAE,UAAU,EACtB,WAAW,EAAE,EAAE,CAAC,eAAe,EAC/B,QAAQ,EAAE,EAAE,CAAC,QAAQ;IAKV,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IAmC7E,YAAY,CACvB,UAAU,EAAE,EAAE,CAAC,cAAc,EAC7B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,CAAC,cAAc,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC,CAAC;CAUxD"}

package/dist/sequence/handlers/authcode-pkce.js

@@ -0,0 +1,48 @@
+import { Hex, Bytes } from 'ox';
+import * as Identity from '@0xsequence/identity-instrument';
+import { AuthCodeHandler } from './authcode.js';
+export class AuthCodePkceHandler extends AuthCodeHandler {
+    constructor(signupKind, issuer, audience, nitro, signatures, commitments, authKeys) {
+        super(signupKind, issuer, audience, nitro, signatures, commitments, authKeys);
+    }
+    async commitAuth(target, isSignUp, state, signer) {
+        let challenge = new Identity.AuthCodePkceChallenge(this.issuer, this.audience, this.redirectUri);
+        if (signer) {
+            challenge = challenge.withSigner(signer);
+        }
+        const { verifier, loginHint, challenge: codeChallenge } = await this.nitroCommitVerifier(challenge);
+        if (!state) {
+            state = Hex.fromBytes(Bytes.random(32));
+        }
+        await this.commitments.set({
+            id: state,
+            kind: this.signupKind,
+            verifier,
+            challenge: codeChallenge,
+            target,
+            metadata: {},
+            isSignUp,
+        });
+        const searchParams = new URLSearchParams({
+            code_challenge: codeChallenge,
+            code_challenge_method: 'S256',
+            client_id: this.audience,
+            redirect_uri: this.redirectUri,
+            login_hint: loginHint,
+            response_type: 'code',
+            scope: 'openid profile email',
+            state,
+        });
+        const oauthUrl = this.oauthUrl();
+        return `${oauthUrl}?${searchParams.toString()}`;
+    }
+    async completeAuth(commitment, code) {
+        const challenge = new Identity.AuthCodePkceChallenge('', '', '');
+        if (!commitment.verifier) {
+            throw new Error('Missing verifier in commitment');
+        }
+        const signer = await this.nitroCompleteAuth(challenge.withAnswer(commitment.verifier, code));
+        await this.commitments.del(commitment.id);
+        return [signer, commitment.metadata];
+    }
+}

package/dist/sequence/handlers/authcode.d.ts

@@ -0,0 +1,25 @@
+import { Hex, Address } from 'ox';
+import { Handler } from './handler.js';
+import * as Db from '../../dbs/index.js';
+import { Signatures } from '../signatures.js';
+import * as Identity from '@0xsequence/identity-instrument';
+import { SignerUnavailable, SignerReady, SignerActionable, BaseSignatureRequest } from '../types/signature-request.js';
+import { IdentitySigner } from '../../identity/signer.js';
+import { IdentityHandler } from './identity.js';
+export declare class AuthCodeHandler extends IdentityHandler implements Handler {
+    readonly signupKind: 'apple' | 'google-pkce';
+    readonly issuer: string;
+    readonly audience: string;
+    protected readonly commitments: Db.AuthCommitments;
+    protected redirectUri: string;
+    constructor(signupKind: 'apple' | 'google-pkce', issuer: string, audience: string, nitro: Identity.IdentityInstrument, signatures: Signatures, commitments: Db.AuthCommitments, authKeys: Db.AuthKeys);
+    get kind(): string;
+    setRedirectUri(redirectUri: string): void;
+    commitAuth(target: string, isSignUp: boolean, state?: string, signer?: string): Promise<string>;
+    completeAuth(commitment: Db.AuthCommitment, code: string): Promise<[IdentitySigner, {
+        [key: string]: string;
+    }]>;
+    status(address: Address.Address, _imageHash: Hex.Hex | undefined, request: BaseSignatureRequest): Promise<SignerUnavailable | SignerReady | SignerActionable>;
+    protected oauthUrl(): "https://accounts.google.com/o/oauth2/v2/auth" | "https://appleid.apple.com/auth/authorize";
+}
+//# sourceMappingURL=authcode.d.ts.map

package/dist/sequence/handlers/authcode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authcode.d.ts","sourceRoot":"","sources":["../../../src/sequence/handlers/authcode.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,GAAG,EAAE,OAAO,EAAS,MAAM,IAAI,CAAA;AACxC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,KAAK,EAAE,MAAM,oBAAoB,CAAA;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,KAAK,QAAQ,MAAM,iCAAiC,CAAA;AAC3D,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAA;AACtH,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAE/C,qBAAa,eAAgB,SAAQ,eAAgB,YAAW,OAAO;aAInD,UAAU,EAAE,OAAO,GAAG,aAAa;aACnC,MAAM,EAAE,MAAM;aACd,QAAQ,EAAE,MAAM;IAGhC,SAAS,CAAC,QAAQ,CAAC,WAAW,EAAE,EAAE,CAAC,eAAe;IARpD,SAAS,CAAC,WAAW,EAAE,MAAM,CAAK;gBAGhB,UAAU,EAAE,OAAO,GAAG,aAAa,EACnC,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,MAAM,EAChC,KAAK,EAAE,QAAQ,CAAC,kBAAkB,EAClC,UAAU,EAAE,UAAU,EACH,WAAW,EAAE,EAAE,CAAC,eAAe,EAClD,QAAQ,EAAE,EAAE,CAAC,QAAQ;IAKvB,IAAW,IAAI,WAEd;IAEM,cAAc,CAAC,WAAW,EAAE,MAAM;IAI5B,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM;IA0B7E,YAAY,CACvB,UAAU,EAAE,EAAE,CAAC,cAAc,EAC7B,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,CAAC,cAAc,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC,CAAC;IAWjD,MAAM,CACV,OAAO,EAAE,OAAO,CAAC,OAAO,EACxB,UAAU,EAAE,GAAG,CAAC,GAAG,GAAG,SAAS,EAC/B,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,iBAAiB,GAAG,WAAW,GAAG,gBAAgB,CAAC;IA6B9D,SAAS,CAAC,QAAQ;CAUnB"}

package/dist/sequence/handlers/authcode.js

@@ -0,0 +1,91 @@
+import { Hex, Address, Bytes } from 'ox';
+import * as Identity from '@0xsequence/identity-instrument';
+import { IdentityHandler } from './identity.js';
+export class AuthCodeHandler extends IdentityHandler {
+    signupKind;
+    issuer;
+    audience;
+    commitments;
+    redirectUri = '';
+    constructor(signupKind, issuer, audience, nitro, signatures, commitments, authKeys) {
+        super(nitro, authKeys, signatures, Identity.IdentityType.OIDC);
+        this.signupKind = signupKind;
+        this.issuer = issuer;
+        this.audience = audience;
+        this.commitments = commitments;
+    }
+    get kind() {
+        return 'login-' + this.signupKind;
+    }
+    setRedirectUri(redirectUri) {
+        this.redirectUri = redirectUri;
+    }
+    async commitAuth(target, isSignUp, state, signer) {
+        if (!state) {
+            state = Hex.fromBytes(Bytes.random(32));
+        }
+        await this.commitments.set({
+            id: state,
+            kind: this.signupKind,
+            signer,
+            target,
+            metadata: {},
+            isSignUp,
+        });
+        const searchParams = new URLSearchParams({
+            client_id: this.audience,
+            redirect_uri: this.redirectUri,
+            response_type: 'code',
+            scope: 'openid',
+            state,
+        });
+        const oauthUrl = this.oauthUrl();
+        return `${oauthUrl}?${searchParams.toString()}`;
+    }
+    async completeAuth(commitment, code) {
+        let challenge = new Identity.AuthCodeChallenge(this.issuer, this.audience, this.redirectUri, code);
+        if (commitment.signer) {
+            challenge = challenge.withSigner(commitment.signer);
+        }
+        await this.nitroCommitVerifier(challenge);
+        const signer = await this.nitroCompleteAuth(challenge);
+        return [signer, {}];
+    }
+    async status(address, _imageHash, request) {
+        // Normalize address
+        const normalizedAddress = Address.checksum(address);
+        const signer = await this.getAuthKeySigner(normalizedAddress);
+        if (signer) {
+            return {
+                address: normalizedAddress,
+                handler: this,
+                status: 'ready',
+                handle: async () => {
+                    await this.sign(signer, request);
+                    return true;
+                },
+            };
+        }
+        return {
+            address: normalizedAddress,
+            handler: this,
+            status: 'actionable',
+            message: 'request-redirect',
+            handle: async () => {
+                const url = await this.commitAuth(window.location.pathname, false, request.id, normalizedAddress);
+                window.location.href = url;
+                return true;
+            },
+        };
+    }
+    oauthUrl() {
+        switch (this.issuer) {
+            case 'https://accounts.google.com':
+                return 'https://accounts.google.com/o/oauth2/v2/auth';
+            case 'https://appleid.apple.com':
+                return 'https://appleid.apple.com/auth/authorize';
+            default:
+                throw new Error('unsupported-issuer');
+        }
+    }
+}

package/dist/sequence/handlers/devices.d.ts

@@ -0,0 +1,14 @@
+import { Signatures } from '../signatures.js';
+import { Address, Hex } from 'ox';
+import { Devices } from '../devices.js';
+import { Handler } from './handler.js';
+import { SignerReady, SignerUnavailable, BaseSignatureRequest } from '../types/index.js';
+export declare class DevicesHandler implements Handler {
+    private readonly signatures;
+    private readonly devices;
+    kind: "local-device";
+    constructor(signatures: Signatures, devices: Devices);
+    onStatusChange(cb: () => void): () => void;
+    status(address: Address.Address, _imageHash: Hex.Hex | undefined, request: BaseSignatureRequest): Promise<SignerUnavailable | SignerReady>;
+}
+//# sourceMappingURL=devices.d.ts.map

package/dist/sequence/handlers/devices.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devices.d.ts","sourceRoot":"","sources":["../../../src/sequence/handlers/devices.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAC7C,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,IAAI,CAAA;AACjC,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AAExF,qBAAa,cAAe,YAAW,OAAO;IAI1C,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJ1B,IAAI,iBAAoB;gBAGL,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,OAAO;IAGnC,cAAc,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI;IAIpC,MAAM,CACV,OAAO,EAAE,OAAO,CAAC,OAAO,EACxB,UAAU,EAAE,GAAG,CAAC,GAAG,GAAG,SAAS,EAC/B,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,iBAAiB,GAAG,WAAW,CAAC;CA6B5C"}

package/dist/sequence/handlers/devices.js

@@ -0,0 +1,39 @@
+import { Kinds } from '../types/signer.js';
+export class DevicesHandler {
+    signatures;
+    devices;
+    kind = Kinds.LocalDevice;
+    constructor(signatures, devices) {
+        this.signatures = signatures;
+        this.devices = devices;
+    }
+    onStatusChange(cb) {
+        return () => { };
+    }
+    async status(address, _imageHash, request) {
+        const signer = await this.devices.get(address);
+        if (!signer) {
+            const status = {
+                address,
+                handler: this,
+                reason: 'not-local-key',
+                status: 'unavailable',
+            };
+            return status;
+        }
+        const status = {
+            address,
+            handler: this,
+            status: 'ready',
+            handle: async () => {
+                const signature = await signer.sign(request.envelope.wallet, request.envelope.chainId, request.envelope.payload);
+                await this.signatures.addSignature(request.id, {
+                    address,
+                    signature,
+                });
+                return true;
+            },
+        };
+        return status;
+    }
+}

package/dist/sequence/handlers/handler.d.ts

@@ -0,0 +1,8 @@
+import { Address, Hex } from 'ox';
+import { SignerActionable, SignerReady, SignerUnavailable, BaseSignatureRequest } from '../types/index.js';
+export interface Handler {
+    kind: string;
+    onStatusChange(cb: () => void): () => void;
+    status(address: Address.Address, imageHash: Hex.Hex | undefined, request: BaseSignatureRequest): Promise<SignerUnavailable | SignerReady | SignerActionable>;
+}
+//# sourceMappingURL=handler.d.ts.map

package/dist/sequence/handlers/handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.ts","sourceRoot":"","sources":["../../../src/sequence/handlers/handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,IAAI,CAAA;AACjC,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,iBAAiB,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAA;AAE1G,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAA;IAEZ,cAAc,CAAC,EAAE,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAA;IAE1C,MAAM,CACJ,OAAO,EAAE,OAAO,CAAC,OAAO,EACxB,SAAS,EAAE,GAAG,CAAC,GAAG,GAAG,SAAS,EAC9B,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,iBAAiB,GAAG,WAAW,GAAG,gBAAgB,CAAC,CAAA;CAC/D"}

package/dist/sequence/handlers/handler.js

@@ -0,0 +1 @@
+export {};