@0xsequence/wallet-wdk 0.0.0-20250520201059

package/dist/sequence/signatures.d.ts

@@ -0,0 +1,21 @@
+import { Envelope } from '@0xsequence/wallet-core';
+import { Shared } from './manager.js';
+import { Action, ActionToPayload, BaseSignatureRequest, SignatureRequest } from './types/signature-request.js';
+export declare class Signatures {
+    private readonly shared;
+    constructor(shared: Shared);
+    initialize(): void;
+    private getBase;
+    list(): Promise<SignatureRequest[]>;
+    get(requestId: string): Promise<SignatureRequest>;
+    onSignatureRequestUpdate(requestId: string, cb: (requests: SignatureRequest) => void, onError?: (error: Error) => void, trigger?: boolean): () => void;
+    onSignatureRequestsUpdate(cb: (requests: BaseSignatureRequest[]) => void, trigger?: boolean): () => void;
+    complete(requestId: string): Promise<void>;
+    request<A extends Action>(envelope: Envelope.Envelope<ActionToPayload[A]>, action: A, options?: {
+        origin?: string;
+    }): Promise<string>;
+    addSignature(requestId: string, signature: Envelope.SapientSignature | Envelope.Signature): Promise<void>;
+    cancel(requestId: string): Promise<void>;
+    prune(): Promise<number>;
+}
+//# sourceMappingURL=signatures.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signatures.d.ts","sourceRoot":"","sources":["../../src/sequence/signatures.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAIlD,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AACrC,OAAO,EACL,MAAM,EACN,eAAe,EACf,oBAAoB,EACpB,gBAAgB,EAIjB,MAAM,8BAA8B,CAAA;AAGrC,qBAAa,UAAU;IACT,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAE3C,UAAU;YAUI,OAAO;IAQf,IAAI,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC;IAInC,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAyFvD,wBAAwB,CACtB,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,CAAC,QAAQ,EAAE,gBAAgB,KAAK,IAAI,EACxC,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,EAChC,OAAO,CAAC,EAAE,OAAO;IA4BnB,yBAAyB,CAAC,EAAE,EAAE,CAAC,QAAQ,EAAE,oBAAoB,EAAE,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO;IAYrF,QAAQ,CAAC,SAAS,EAAE,MAAM;IAuB1B,OAAO,CAAC,CAAC,SAAS,MAAM,EAC5B,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EAC/C,MAAM,EAAE,CAAC,EACT,OAAO,GAAE;QACP,MAAM,CAAC,EAAE,MAAM,CAAA;KACX,GACL,OAAO,CAAC,MAAM,CAAC;IAkCZ,YAAY,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,CAAC,gBAAgB,GAAG,QAAQ,CAAC,SAAS;IAQzF,MAAM,CAAC,SAAS,EAAE,MAAM;IAUxB,KAAK;CAOZ"}

package/dist/sequence/signatures.js

@@ -0,0 +1,192 @@
+import { Envelope } from '@0xsequence/wallet-core';
+import { Config, Payload } from '@0xsequence/wallet-primitives';
+import { Address, Hex } from 'ox';
+import { v7 as uuidv7 } from 'uuid';
+export class Signatures {
+    shared;
+    constructor(shared) {
+        this.shared = shared;
+    }
+    initialize() {
+        this.shared.modules.cron.registerJob('prune-signatures', 10 * 60 * 1000, async () => {
+            const prunedSignatures = await this.prune();
+            if (prunedSignatures > 0) {
+                this.shared.modules.logger.log(`Pruned ${prunedSignatures} signatures`);
+            }
+        });
+        this.shared.modules.logger.log('Signatures module initialized and job registered.');
+    }
+    async getBase(requestId) {
+        const request = await this.shared.databases.signatures.get(requestId);
+        if (!request) {
+            throw new Error(`Request not found for ${requestId}`);
+        }
+        return request;
+    }
+    async list() {
+        return this.shared.databases.signatures.list();
+    }
+    async get(requestId) {
+        const request = await this.getBase(requestId);
+        if (request.status !== 'pending' && request.scheduledPruning < Date.now()) {
+            await this.shared.databases.signatures.del(requestId);
+            throw new Error(`Request not found for ${requestId}`);
+        }
+        const signers = Config.getSigners(request.envelope.configuration.topology);
+        const signersAndKinds = await Promise.all([
+            ...signers.signers.map(async (signer) => {
+                const kind = await this.shared.modules.signers.kindOf(request.wallet, signer);
+                return {
+                    address: signer,
+                    imageHash: undefined,
+                    kind,
+                };
+            }),
+            ...signers.sapientSigners.map(async (signer) => {
+                const kind = await this.shared.modules.signers.kindOf(request.wallet, signer.address, Hex.from(signer.imageHash));
+                return {
+                    address: signer.address,
+                    imageHash: signer.imageHash,
+                    kind,
+                };
+            }),
+        ]);
+        const statuses = await Promise.all(signersAndKinds.map(async (sak) => {
+            const base = {
+                address: sak.address,
+                imageHash: sak.imageHash,
+            };
+            // We may have a signature for this signer already
+            const signed = request.envelope.signatures.some((sig) => {
+                if (Envelope.isSapientSignature(sig)) {
+                    return Address.isEqual(sig.signature.address, sak.address) && sig.imageHash === sak.imageHash;
+                }
+                return Address.isEqual(sig.address, sak.address);
+            });
+            if (!sak.kind) {
+                const status = {
+                    ...base,
+                    handler: undefined,
+                    reason: 'unknown-signer-kind',
+                    status: 'unavailable',
+                };
+                return status;
+            }
+            const handler = this.shared.handlers.get(sak.kind);
+            if (signed) {
+                const status = {
+                    ...base,
+                    handler,
+                    status: 'signed',
+                };
+                return status;
+            }
+            if (!handler) {
+                const status = {
+                    ...base,
+                    handler: undefined,
+                    reason: 'no-handler',
+                    status: 'unavailable',
+                };
+                return status;
+            }
+            return handler.status(sak.address, sak.imageHash, request);
+        }));
+        const signatureRequest = {
+            ...request,
+            ...Envelope.weightOf(request.envelope),
+            signers: statuses,
+        };
+        return signatureRequest;
+    }
+    onSignatureRequestUpdate(requestId, cb, onError, trigger) {
+        const undoDbListener = this.shared.databases.signatures.addListener(() => {
+            this.get(requestId)
+                .then((request) => cb(request))
+                .catch((error) => onError?.(error));
+        });
+        const undoHandlerListeners = Array.from(this.shared.handlers.values()).map((handler) => handler.onStatusChange(() => {
+            this.get(requestId)
+                .then((request) => cb(request))
+                .catch((error) => onError?.(error));
+        }));
+        if (trigger) {
+            this.get(requestId)
+                .then((request) => cb(request))
+                .catch((error) => onError?.(error));
+        }
+        return () => {
+            undoDbListener();
+            undoHandlerListeners.forEach((undoFn) => undoFn());
+        };
+    }
+    onSignatureRequestsUpdate(cb, trigger) {
+        const undo = this.shared.databases.signatures.addListener(() => {
+            this.list().then((l) => cb(l));
+        });
+        if (trigger) {
+            this.list().then((l) => cb(l));
+        }
+        return undo;
+    }
+    async complete(requestId) {
+        const request = await this.getBase(requestId);
+        if (request?.envelope.payload.type === 'config-update') {
+            // Clear pending config updates for the same wallet with a checkpoint equal or lower than the completed update
+            const pendingRequests = await this.shared.databases.signatures.list();
+            const pendingConfigUpdatesToClear = pendingRequests.filter((sig) => Address.isEqual(sig.wallet, request.wallet) &&
+                sig.envelope.payload.type === 'config-update' &&
+                sig.envelope.configuration.checkpoint <= request.envelope.configuration.checkpoint);
+            // This also deletes the requested id
+            await Promise.all(pendingConfigUpdatesToClear.map((sig) => this.shared.modules.signatures.cancel(sig.id)));
+        }
+        await this.shared.databases.signatures.set({
+            ...request,
+            status: 'completed',
+            scheduledPruning: Date.now() + this.shared.databases.pruningInterval,
+        });
+    }
+    async request(envelope, action, options = {}) {
+        // If the action is a config update, we need to remove all signature requests
+        // for the same wallet that also involve configuration updates
+        // as it may cause race conditions
+        // TODO: Eventually we should define a "delta configuration" signature request
+        if (Payload.isConfigUpdate(envelope.payload)) {
+            const pendingRequests = await this.shared.databases.signatures.list();
+            const pendingConfigUpdatesToClear = pendingRequests.filter((sig) => sig.wallet === envelope.wallet && Payload.isConfigUpdate(sig.envelope.payload));
+            console.warn('Deleting conflicting configuration updates for wallet', envelope.wallet, pendingConfigUpdatesToClear.map((pc) => pc.id));
+            await Promise.all(pendingConfigUpdatesToClear.map((sig) => this.shared.modules.signatures.cancel(sig.id)));
+        }
+        const id = uuidv7();
+        await this.shared.databases.signatures.set({
+            id,
+            wallet: envelope.wallet,
+            envelope: Envelope.toSigned(envelope),
+            origin: options.origin ?? 'unknown',
+            action,
+            createdAt: new Date().toISOString(),
+            status: 'pending',
+        });
+        return id;
+    }
+    async addSignature(requestId, signature) {
+        const request = await this.getBase(requestId);
+        Envelope.addSignature(request.envelope, signature);
+        await this.shared.databases.signatures.set(request);
+    }
+    async cancel(requestId) {
+        const request = await this.getBase(requestId);
+        await this.shared.databases.signatures.set({
+            ...request,
+            status: 'cancelled',
+            scheduledPruning: Date.now() + this.shared.databases.pruningInterval,
+        });
+    }
+    async prune() {
+        const now = Date.now();
+        const requests = await this.shared.databases.signatures.list();
+        const toPrune = requests.filter((req) => req.status !== 'pending' && req.scheduledPruning < now);
+        await Promise.all(toPrune.map((req) => this.shared.databases.signatures.del(req.id)));
+        return toPrune.length;
+    }
+}

package/dist/sequence/signers.d.ts

@@ -0,0 +1,14 @@
+import { Address, Hex } from 'ox';
+import { Shared } from './manager.js';
+import { Kind, SignerWithKind, WitnessExtraSignerKind } from './types/signer.js';
+export declare function isWitnessExtraSignerKind(extra: any): extra is WitnessExtraSignerKind;
+export declare class Signers {
+    private readonly shared;
+    constructor(shared: Shared);
+    kindOf(wallet: Address.Address, address: Address.Address, imageHash?: Hex.Hex): Promise<Kind | undefined>;
+    resolveKinds(wallet: Address.Address, signers: (Address.Address | {
+        address: Address.Address;
+        imageHash: Hex.Hex;
+    })[]): Promise<SignerWithKind[]>;
+}
+//# sourceMappingURL=signers.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"signers.d.ts","sourceRoot":"","sources":["../../src/sequence/signers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,IAAI,CAAA;AACjC,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AACrC,OAAO,EAAE,IAAI,EAAS,cAAc,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAEvF,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,GAAG,GAAG,KAAK,IAAI,sBAAsB,CAEpF;AAeD,qBAAa,OAAO;IACN,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAErC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,OAAO,CAAC,OAAO,EAAE,SAAS,CAAC,EAAE,GAAG,CAAC,GAAG,GAAG,OAAO,CAAC,IAAI,GAAG,SAAS,CAAC;IAuCzG,YAAY,CAChB,MAAM,EAAE,OAAO,CAAC,OAAO,EACvB,OAAO,EAAE,CAAC,OAAO,CAAC,OAAO,GAAG;QAAE,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC;QAAC,SAAS,EAAE,GAAG,CAAC,GAAG,CAAA;KAAE,CAAC,EAAE,GAC9E,OAAO,CAAC,cAAc,EAAE,CAAC;CAoB7B"}

package/dist/sequence/signers.js

@@ -0,0 +1,74 @@
+import { Payload } from '@0xsequence/wallet-primitives';
+import { Address, Hex } from 'ox';
+import { Kinds } from './types/signer.js';
+export function isWitnessExtraSignerKind(extra) {
+    return typeof extra === 'object' && extra !== null && 'signerKind' in extra;
+}
+function toKnownKind(kind) {
+    if (Object.values(Kinds).includes(kind)) {
+        return kind;
+    }
+    console.warn(`Unknown signer kind: ${kind}`);
+    return Kinds.Unknown;
+}
+// Signers is in charge to know (or figure out) the "kind" of each signer
+// i.e., when a signature is requested, we only get address and imageHash (if sapient)
+// this module takes care of figuring out the kind of signer (e.g., device, passkey, recovery, etc.)
+export class Signers {
+    shared;
+    constructor(shared) {
+        this.shared = shared;
+    }
+    async kindOf(wallet, address, imageHash) {
+        // // The device may be among the local devices, in that case it is a local device
+        // // TODO: Maybe signers shouldn't be getting in the way of devices, it feels like a
+        // //      different concern
+        // if (await this.devices.has(address)) {
+        //   return Kinds.LocalDevice
+        // }
+        // Some signers are known by the configuration of the wallet development kit, specifically
+        // some of the sapient signers, who always share the same address
+        if (Address.isEqual(this.shared.sequence.extensions.recovery, address)) {
+            return Kinds.Recovery;
+        }
+        // We need to use the state provider (and witness) this will tell us the kind of signer
+        // NOTICE: This looks expensive, but this operation should be cached by the state provider
+        const witness = await (imageHash
+            ? this.shared.sequence.stateProvider.getWitnessForSapient(wallet, address, imageHash)
+            : this.shared.sequence.stateProvider.getWitnessFor(wallet, address));
+        if (!witness) {
+            return undefined;
+        }
+        // Parse the payload, it may have the kind of signer
+        if (!Payload.isMessage(witness.payload)) {
+            return undefined;
+        }
+        try {
+            const message = JSON.parse(Hex.toString(witness.payload.message));
+            if (isWitnessExtraSignerKind(message)) {
+                return toKnownKind(message.signerKind);
+            }
+        }
+        catch { }
+        return undefined;
+    }
+    async resolveKinds(wallet, signers) {
+        return Promise.all(signers.map(async (signer) => {
+            if (typeof signer === 'string') {
+                const kind = await this.kindOf(wallet, signer);
+                return {
+                    address: signer,
+                    kind,
+                };
+            }
+            else {
+                const kind = await this.kindOf(wallet, signer.address, signer.imageHash);
+                return {
+                    address: signer.address,
+                    imageHash: signer.imageHash,
+                    kind,
+                };
+            }
+        }));
+    }
+}

package/dist/sequence/transactions.d.ts

@@ -0,0 +1,26 @@
+import { Payload } from '@0xsequence/wallet-primitives';
+import { Address } from 'ox';
+import { Shared } from './manager.js';
+import { Transaction, TransactionRequest } from './types/transaction-request.js';
+export declare class Transactions {
+    private readonly shared;
+    constructor(shared: Shared);
+    list(): Promise<Transaction[]>;
+    get(transactionId: string): Promise<Transaction>;
+    request(from: Address.Address, chainId: bigint, txs: TransactionRequest[], options?: {
+        skipDefineGas?: boolean;
+        source?: string;
+        noConfigUpdate?: boolean;
+    }): Promise<string>;
+    define(transactionId: string, changes?: {
+        nonce?: bigint;
+        space?: bigint;
+        calls?: Pick<Payload.Call, 'gasLimit'>[];
+    }): Promise<void>;
+    selectRelayer(transactionId: string, relayerOptionId: string): Promise<string>;
+    relay(transactionOrSignatureId: string): Promise<`0x${string}`>;
+    onTransactionsUpdate(cb: (transactions: Transaction[]) => void, trigger?: boolean): () => void;
+    onTransactionUpdate(transactionId: string, cb: (transaction: Transaction) => void, trigger?: boolean): () => void;
+    delete(transactionId: string): Promise<void>;
+}
+//# sourceMappingURL=transactions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transactions.d.ts","sourceRoot":"","sources":["../../src/sequence/transactions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAA;AAEvD,OAAO,EAAE,OAAO,EAA0B,MAAM,IAAI,CAAA;AAEpD,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AACrC,OAAO,EAEL,WAAW,EAGX,kBAAkB,EACnB,MAAM,gCAAgC,CAAA;AAEvC,qBAAa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAE9B,IAAI,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC;IAI9B,GAAG,CAAC,aAAa,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IASvD,OAAO,CACX,IAAI,EAAE,OAAO,CAAC,OAAO,EACrB,OAAO,EAAE,MAAM,EACf,GAAG,EAAE,kBAAkB,EAAE,EACzB,OAAO,CAAC,EAAE;QACR,aAAa,CAAC,EAAE,OAAO,CAAA;QACvB,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,cAAc,CAAC,EAAE,OAAO,CAAA;KACzB,GACA,OAAO,CAAC,MAAM,CAAC;IAuCZ,MAAM,CACV,aAAa,EAAE,MAAM,EACrB,OAAO,CAAC,EAAE;QACR,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,KAAK,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,UAAU,CAAC,EAAE,CAAA;KACzC,GACA,OAAO,CAAC,IAAI,CAAC;IAuDV,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA2B9E,KAAK,CAAC,wBAAwB,EAAE,MAAM;IAiF5C,oBAAoB,CAAC,EAAE,EAAE,CAAC,YAAY,EAAE,WAAW,EAAE,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO;IAYjF,mBAAmB,CAAC,aAAa,EAAE,MAAM,EAAE,EAAE,EAAE,CAAC,WAAW,EAAE,WAAW,KAAK,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO;IAY9F,MAAM,CAAC,aAAa,EAAE,MAAM;CASnC"}

package/dist/sequence/transactions.js

@@ -0,0 +1,201 @@
+import { Payload } from '@0xsequence/wallet-primitives';
+import { Envelope, Wallet } from '@0xsequence/wallet-core';
+import { Provider, RpcTransport } from 'ox';
+import { v7 as uuidv7 } from 'uuid';
+export class Transactions {
+    shared;
+    constructor(shared) {
+        this.shared = shared;
+    }
+    async list() {
+        return this.shared.databases.transactions.list();
+    }
+    async get(transactionId) {
+        const tx = await this.shared.databases.transactions.get(transactionId);
+        if (!tx) {
+            throw new Error(`Transaction ${transactionId} not found`);
+        }
+        return tx;
+    }
+    async request(from, chainId, txs, options) {
+        const network = this.shared.sequence.networks.find((network) => network.chainId === chainId);
+        if (!network) {
+            throw new Error(`Network not found for ${chainId}`);
+        }
+        const transport = RpcTransport.fromHttp(network.rpc);
+        const provider = Provider.from(transport);
+        const wallet = new Wallet(from, { stateProvider: this.shared.sequence.stateProvider });
+        const calls = txs.map((tx) => ({
+            to: tx.to,
+            value: tx.value ?? 0n,
+            data: tx.data ?? '0x',
+            gasLimit: tx.gasLimit ?? 0n, // TODO: Add gas estimation
+            delegateCall: false,
+            onlyFallback: false,
+            behaviorOnError: 'revert',
+        }));
+        const envelope = await wallet.prepareTransaction(provider, calls, {
+            noConfigUpdate: options?.noConfigUpdate,
+        });
+        const id = uuidv7();
+        await this.shared.databases.transactions.set({
+            id,
+            wallet: from,
+            requests: txs,
+            envelope,
+            source: options?.source ?? 'unknown',
+            status: 'requested',
+        });
+        return id;
+    }
+    async define(transactionId, changes) {
+        const tx = await this.get(transactionId);
+        if (tx.status !== 'requested') {
+            throw new Error(`Transaction ${transactionId} is not in the requested state`);
+        }
+        // Modify the envelope with the changes
+        if (changes?.nonce) {
+            tx.envelope.payload.nonce = changes.nonce;
+        }
+        if (changes?.space) {
+            tx.envelope.payload.space = changes.space;
+        }
+        if (changes?.calls) {
+            if (changes.calls.length !== tx.envelope.payload.calls.length) {
+                throw new Error(`Invalid number of calls for transaction ${transactionId}`);
+            }
+            for (let i = 0; i < changes.calls.length; i++) {
+                tx.envelope.payload.calls[i].gasLimit = changes.calls[i].gasLimit;
+            }
+        }
+        // Get relayer options
+        const allRelayerOptions = await Promise.all(this.shared.sequence.relayers.map(async (relayer) => {
+            const feeOptions = await relayer.feeOptions(tx.wallet, tx.envelope.chainId, tx.envelope.payload.calls);
+            if (feeOptions.options.length === 0) {
+                return [
+                    {
+                        id: uuidv7(),
+                        relayerId: relayer.id,
+                    },
+                ];
+            }
+            return feeOptions.options.map((feeOption) => ({
+                id: uuidv7(),
+                feeOption: feeOption,
+                relayerId: relayer.id,
+                quote: feeOptions.quote,
+            }));
+        }));
+        await this.shared.databases.transactions.set({
+            ...tx,
+            relayerOptions: allRelayerOptions.flat(),
+            status: 'defined',
+        });
+    }
+    async selectRelayer(transactionId, relayerOptionId) {
+        const tx = await this.get(transactionId);
+        if (tx.status !== 'defined') {
+            throw new Error(`Transaction ${transactionId} is not in the defined state`);
+        }
+        const selection = tx.relayerOptions.find((option) => option.id === relayerOptionId);
+        if (!selection) {
+            throw new Error(`Relayer option ${relayerOptionId} not found for transaction ${transactionId}`);
+        }
+        // Pass to the signatures manager
+        const signatureId = await this.shared.modules.signatures.request(tx.envelope, 'send-transaction', {
+            origin: tx.source,
+        });
+        await this.shared.databases.transactions.set({
+            ...tx,
+            relayerOptions: undefined,
+            relayerOption: selection,
+            status: 'formed',
+            signatureId,
+        });
+        return signatureId;
+    }
+    async relay(transactionOrSignatureId) {
+        // First, try to get the transaction directly
+        let tx;
+        try {
+            tx = await this.get(transactionOrSignatureId);
+        }
+        catch (e) {
+            // If not found, it might be a signature ID
+            const signature = await this.shared.modules.signatures.get(transactionOrSignatureId);
+            if (!signature) {
+                throw new Error(`Neither transaction nor signature found with ID ${transactionOrSignatureId}`);
+            }
+            // Find the transaction associated with this signature
+            const transactions = await this.list();
+            tx = transactions.find((t) => t.status === 'formed' && 'signatureId' in t && t.signatureId === transactionOrSignatureId);
+            if (!tx) {
+                throw new Error(`No transaction found for signature ${transactionOrSignatureId}`);
+            }
+        }
+        const transactionId = tx.id;
+        if (tx.status !== 'formed') {
+            throw new Error(`Transaction ${transactionId} is not in the formed state`);
+        }
+        const signature = await this.shared.modules.signatures.get(tx.signatureId);
+        if (!signature) {
+            throw new Error(`Signature ${tx.signatureId} not found for transaction ${transactionId}`);
+        }
+        const network = this.shared.sequence.networks.find((network) => network.chainId === tx.envelope.chainId);
+        if (!network) {
+            throw new Error(`Network not found for ${tx.envelope.chainId}`);
+        }
+        const transport = RpcTransport.fromHttp(network.rpc);
+        const provider = Provider.from(transport);
+        const wallet = new Wallet(tx.wallet, { stateProvider: this.shared.sequence.stateProvider });
+        if (!Payload.isCalls(signature.envelope.payload)) {
+            throw new Error(`Signature ${tx.signatureId} is not a calls payload`);
+        }
+        if (!Envelope.isSigned(signature.envelope)) {
+            throw new Error(`Transaction ${transactionId} is not signed`);
+        }
+        const { weight, threshold } = Envelope.weightOf(signature.envelope);
+        if (weight < threshold) {
+            throw new Error(`Transaction ${transactionId} has insufficient weight`);
+        }
+        const transaction = await wallet.buildTransaction(provider, signature.envelope);
+        const relayer = this.shared.sequence.relayers.find((relayer) => relayer.id === tx.relayerOption.relayerId);
+        if (!relayer) {
+            throw new Error(`Relayer ${tx.relayerOption.relayerId} not found for transaction ${transactionId}`);
+        }
+        const { opHash } = await relayer.relay(transaction.to, transaction.data, tx.envelope.chainId, tx.relayerOption.quote);
+        await this.shared.databases.transactions.set({
+            ...tx,
+            status: 'relayed',
+            opHash,
+        });
+        await this.shared.modules.signatures.complete(signature.id);
+        return opHash;
+    }
+    onTransactionsUpdate(cb, trigger) {
+        const undo = this.shared.databases.transactions.addListener(() => {
+            this.list().then((l) => cb(l));
+        });
+        if (trigger) {
+            this.list().then((l) => cb(l));
+        }
+        return undo;
+    }
+    onTransactionUpdate(transactionId, cb, trigger) {
+        const undo = this.shared.databases.transactions.addListener(() => {
+            this.get(transactionId).then((t) => cb(t));
+        });
+        if (trigger) {
+            this.get(transactionId).then((t) => cb(t));
+        }
+        return undo;
+    }
+    async delete(transactionId) {
+        const tx = await this.get(transactionId);
+        await this.shared.databases.transactions.del(transactionId);
+        // Cancel any signature requests associated with this transaction
+        if (tx.status === 'formed') {
+            await this.shared.modules.signatures.cancel(tx.signatureId);
+        }
+    }
+}

package/dist/sequence/types/index.d.ts

@@ -0,0 +1,9 @@
+export type { Message, MessageRequest, MessageRequested, MessageSigned } from './message-request.js';
+export type { QueuedRecoveryPayload } from './recovery.js';
+export { Actions } from './signature-request.js';
+export type { Action, ActionToPayload, BaseSignatureRequest, SignatureRequest, Signer, SignerActionable, SignerBase, SignerReady, SignerSigned, SignerUnavailable, } from './signature-request.js';
+export { Kinds } from './signer.js';
+export type { Kind, RecoverySigner, SignerWithKind, WitnessExtraSignerKind } from './signer.js';
+export type { RelayerOption, Transaction, TransactionDefined, TransactionFormed, TransactionRelayed, TransactionRequest, TransactionRequested, } from './transaction-request.js';
+export type { Wallet } from './wallet.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/sequence/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/sequence/types/index.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAA;AACpG,YAAY,EAAE,qBAAqB,EAAE,MAAM,eAAe,CAAA;AAC1D,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AAChD,YAAY,EACV,MAAM,EACN,eAAe,EACf,oBAAoB,EACpB,gBAAgB,EAChB,MAAM,EACN,gBAAgB,EAChB,UAAU,EACV,WAAW,EACX,YAAY,EACZ,iBAAiB,GAClB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAA;AACnC,YAAY,EAAE,IAAI,EAAE,cAAc,EAAE,cAAc,EAAE,sBAAsB,EAAE,MAAM,aAAa,CAAA;AAC/F,YAAY,EACV,aAAa,EACb,WAAW,EACX,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,0BAA0B,CAAA;AACjC,YAAY,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA"}

package/dist/sequence/types/index.js

@@ -0,0 +1,2 @@
+export { Actions } from './signature-request.js';
+export { Kinds } from './signer.js';

package/dist/sequence/types/message-request.d.ts

@@ -0,0 +1,23 @@
+import { Envelope } from '@0xsequence/wallet-core';
+import { Payload } from '@0xsequence/wallet-primitives';
+import { Address, Hex } from 'ox';
+export type MessageRequest = string | Hex.Hex | Payload.TypedDataToSign;
+type MessageBase = {
+    id: string;
+    wallet: Address.Address;
+    message: MessageRequest;
+    source: string;
+    signatureId: string;
+};
+export type MessageRequested = MessageBase & {
+    status: 'requested';
+    envelope: Envelope.Envelope<Payload.Message>;
+};
+export type MessageSigned = MessageBase & {
+    status: 'signed';
+    envelope: Envelope.Signed<Payload.Message>;
+    messageSignature: Hex.Hex;
+};
+export type Message = MessageRequested | MessageSigned;
+export {};
+//# sourceMappingURL=message-request.d.ts.map

package/dist/sequence/types/message-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-request.d.ts","sourceRoot":"","sources":["../../../src/sequence/types/message-request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAA;AACvD,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,IAAI,CAAA;AAEjC,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,GAAG,CAAC,GAAG,GAAG,OAAO,CAAC,eAAe,CAAA;AAEvE,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,OAAO,CAAC,OAAO,CAAA;IACvB,OAAO,EAAE,cAAc,CAAA;IACvB,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,WAAW,GAAG;IAC3C,MAAM,EAAE,WAAW,CAAA;IACnB,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;CAC7C,CAAA;AAED,MAAM,MAAM,aAAa,GAAG,WAAW,GAAG;IACxC,MAAM,EAAE,QAAQ,CAAA;IAChB,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,CAAA;IAC1C,gBAAgB,EAAE,GAAG,CAAC,GAAG,CAAA;CAC1B,CAAA;AAED,MAAM,MAAM,OAAO,GAAG,gBAAgB,GAAG,aAAa,CAAA"}

package/dist/sequence/types/message-request.js

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

package/dist/sequence/types/recovery.d.ts

@@ -0,0 +1,15 @@
+import { Payload } from '@0xsequence/wallet-primitives';
+import { Address, Hex } from 'ox';
+export type QueuedRecoveryPayload = {
+    id: string;
+    index: bigint;
+    recoveryModule: Address.Address;
+    wallet: Address.Address;
+    signer: Address.Address;
+    chainId: bigint;
+    startTimestamp: bigint;
+    endTimestamp: bigint;
+    payloadHash: Hex.Hex;
+    payload?: Payload.Payload;
+};
+//# sourceMappingURL=recovery.d.ts.map

package/dist/sequence/types/recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../../../src/sequence/types/recovery.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,+BAA+B,CAAA;AACvD,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,IAAI,CAAA;AAEjC,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,cAAc,EAAE,OAAO,CAAC,OAAO,CAAA;IAC/B,MAAM,EAAE,OAAO,CAAC,OAAO,CAAA;IACvB,MAAM,EAAE,OAAO,CAAC,OAAO,CAAA;IACvB,OAAO,EAAE,MAAM,CAAA;IACf,cAAc,EAAE,MAAM,CAAA;IACtB,YAAY,EAAE,MAAM,CAAA;IACpB,WAAW,EAAE,GAAG,CAAC,GAAG,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAC,OAAO,CAAA;CAC1B,CAAA"}

package/dist/sequence/types/recovery.js

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