@0xsequence/wallet-wdk 0.0.0-20250520201059

package/src/sequence/transactions.ts

@@ -0,0 +1,281 @@
+import { Payload } from '@0xsequence/wallet-primitives'
+import { Envelope, Wallet } from '@0xsequence/wallet-core'
+import { Address, Provider, RpcTransport } from 'ox'
+import { v7 as uuidv7 } from 'uuid'
+import { Shared } from './manager.js'
+import {
+  RelayerOption,
+  Transaction,
+  TransactionFormed,
+  TransactionRelayed,
+  TransactionRequest,
+} from './types/transaction-request.js'
+
+export class Transactions {
+  constructor(private readonly shared: Shared) {}
+
+  public async list(): Promise<Transaction[]> {
+    return this.shared.databases.transactions.list()
+  }
+
+  public async get(transactionId: string): Promise<Transaction> {
+    const tx = await this.shared.databases.transactions.get(transactionId)
+    if (!tx) {
+      throw new Error(`Transaction ${transactionId} not found`)
+    }
+
+    return tx
+  }
+
+  async request(
+    from: Address.Address,
+    chainId: bigint,
+    txs: TransactionRequest[],
+    options?: {
+      skipDefineGas?: boolean
+      source?: string
+      noConfigUpdate?: boolean
+    },
+  ): Promise<string> {
+    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): Payload.Call => ({
+        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: string,
+    changes?: {
+      nonce?: bigint
+      space?: bigint
+      calls?: Pick<Payload.Call, 'gasLimit'>[]
+    },
+  ): Promise<void> {
+    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): Promise<RelayerOption[]> => {
+        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,
+            } as RelayerOption,
+          ]
+        }
+
+        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: string, relayerOptionId: string): Promise<string> {
+    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,
+    } as TransactionFormed)
+
+    return signatureId
+  }
+
+  async relay(transactionOrSignatureId: string) {
+    // First, try to get the transaction directly
+    let tx: Transaction | undefined
+    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 as Envelope.Signed<Payload.Calls>)
+    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,
+    } as TransactionRelayed)
+
+    await this.shared.modules.signatures.complete(signature.id)
+
+    return opHash
+  }
+
+  onTransactionsUpdate(cb: (transactions: Transaction[]) => void, trigger?: boolean) {
+    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: string, cb: (transaction: Transaction) => void, trigger?: boolean) {
+    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: string) {
+    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/src/sequence/types/index.ts

@@ -0,0 +1,27 @@
+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'

package/src/sequence/types/message-request.ts

@@ -0,0 +1,26 @@
+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

package/src/sequence/types/recovery.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
+}

package/src/sequence/types/signature-request.ts

@@ -0,0 +1,89 @@
+import { Envelope } from '@0xsequence/wallet-core'
+import { Payload } from '@0xsequence/wallet-primitives'
+import { Address, Hex } from 'ox'
+import { Handler } from '../handlers/handler.js'
+
+export type ActionToPayload = {
+  [Actions.Logout]: Payload.ConfigUpdate
+  [Actions.Login]: Payload.ConfigUpdate
+  [Actions.SendTransaction]: Payload.Calls
+  [Actions.SignMessage]: Payload.Message
+  [Actions.SessionUpdate]: Payload.ConfigUpdate
+  [Actions.Recovery]: Payload.Recovery<Payload.Calls>
+  [Actions.AddRecoverySigner]: Payload.ConfigUpdate
+  [Actions.RemoveRecoverySigner]: Payload.ConfigUpdate
+  [Actions.SessionImplicitAuthorize]: Payload.SessionImplicitAuthorize
+}
+
+export const Actions = {
+  Logout: 'logout',
+  Login: 'login',
+  SendTransaction: 'send-transaction',
+  SignMessage: 'sign-message',
+  SessionUpdate: 'session-update',
+  Recovery: 'recovery',
+  AddRecoverySigner: 'add-recovery-signer',
+  RemoveRecoverySigner: 'remove-recovery-signer',
+  SessionImplicitAuthorize: 'session-implicit-authorize',
+} as const
+
+export type Action = (typeof Actions)[keyof typeof Actions]
+export type BaseSignatureRequest<A extends Action = Action> =
+  | {
+      id: string
+      wallet: Address.Address
+      origin: string
+      createdAt: string
+
+      action: A
+      envelope: Envelope.Signed<ActionToPayload[A]>
+      status: 'pending'
+    }
+  | {
+      id: string
+      wallet: Address.Address
+      origin: string
+      createdAt: string
+
+      action: A
+      envelope: Envelope.Signed<ActionToPayload[A]>
+      status: 'cancelled' | 'completed'
+      scheduledPruning: number
+    }
+
+export type SignerBase = {
+  address: Address.Address
+  imageHash?: Hex.Hex
+}
+
+export type SignerSigned = SignerBase & {
+  handler?: Handler
+  status: 'signed'
+}
+
+export type SignerUnavailable = SignerBase & {
+  handler?: Handler
+  reason: string
+  status: 'unavailable'
+}
+
+export type SignerReady = SignerBase & {
+  handler: Handler
+  status: 'ready'
+  handle: () => Promise<boolean>
+}
+
+export type SignerActionable = SignerBase & {
+  handler: Handler
+  status: 'actionable'
+  message: string // TODO: Localization?
+  handle: () => Promise<boolean>
+}
+
+export type Signer = SignerSigned | SignerUnavailable | SignerReady | SignerActionable
+
+export type SignatureRequest = BaseSignatureRequest & {
+  weight: bigint
+  threshold: bigint
+  signers: Signer[]
+}

package/src/sequence/types/signer.ts

@@ -0,0 +1,32 @@
+import { Address, Hex } from 'ox'
+
+export const Kinds = {
+  LocalDevice: 'local-device',
+  LoginPasskey: 'login-passkey',
+  LoginMnemonic: 'login-mnemonic', // Todo: do not name it login-mnemonic, just mnemonic
+  LoginEmailOtp: 'login-email-otp',
+  LoginGooglePkce: 'login-google-pkce',
+  LoginApple: 'login-apple',
+  Recovery: 'recovery-extension',
+  Unknown: 'unknown',
+} as const
+
+export type Kind = (typeof Kinds)[keyof typeof Kinds]
+
+export type WitnessExtraSignerKind = {
+  signerKind: string
+}
+
+export type SignerWithKind = {
+  address: Address.Address
+  kind?: Kind
+  imageHash?: Hex.Hex
+}
+
+export type RecoverySigner = {
+  kind: Kind
+  isRecovery: true
+  address: Address.Address
+  minTimestamp: bigint
+  requiredDeltaTime: bigint
+}

package/src/sequence/types/transaction-request.ts

@@ -0,0 +1,47 @@
+import { Envelope, Relayer } from '@0xsequence/wallet-core'
+import { Payload } from '@0xsequence/wallet-primitives'
+import { Address, Hex } from 'ox'
+
+export type TransactionRequest = {
+  to: Address.Address
+  value?: bigint
+  data?: Hex.Hex
+  gasLimit?: bigint
+}
+
+export type RelayerOption = {
+  id: string
+  relayerId: string
+  feeOption?: Relayer.FeeOption
+  quote?: Relayer.FeeQuote
+}
+
+type TransactionBase = {
+  id: string
+  wallet: Address.Address
+  requests: TransactionRequest[]
+  source: string
+  envelope: Envelope.Envelope<Payload.Calls>
+}
+
+export type TransactionRequested = TransactionBase & {
+  status: 'requested'
+}
+
+export type TransactionDefined = TransactionBase & {
+  status: 'defined'
+  relayerOptions: RelayerOption[]
+}
+
+export type TransactionFormed = TransactionBase & {
+  relayerOption: RelayerOption
+  status: 'formed'
+  signatureId: string
+}
+
+export type TransactionRelayed = TransactionBase & {
+  status: 'relayed'
+  opHash: string
+}
+
+export type Transaction = TransactionRequested | TransactionDefined | TransactionFormed | TransactionRelayed

package/src/sequence/types/wallet.ts

@@ -0,0 +1,24 @@
+import { Address } from 'ox'
+
+export interface Wallet {
+  address: Address.Address
+  status: 'ready' | 'logging-in' | 'logging-out'
+  loginDate: string
+  device: Address.Address
+  loginType: string
+  useGuard: boolean
+}
+
+export type WalletSelectionContext = {
+  isRedirect: boolean
+  target?: string
+  signupKind?: string
+}
+
+export type WalletSelectionOptions = {
+  existingWallets: Address.Address[]
+  signerAddress: Address.Address
+  context: WalletSelectionContext
+}
+
+export type WalletSelectionUiHandler = (options: WalletSelectionOptions) => Promise<Address.Address | undefined>