@0xsequence/guard 2.3.35 → 3.0.0-beta.2

package/dist/declarations/src/index.d.ts

@@ -1,2 +0,0 @@
-export { Guard } from "./guard.gen.js";
-export * from "./signer.js";

package/dist/declarations/src/signer.d.ts

@@ -1,66 +0,0 @@
-import { Account } from '@0xsequence/account';
-import { commons } from '@0xsequence/core';
-import { signers, Status } from '@0xsequence/signhub';
-import { TypedData } from '@0xsequence/utils';
-import { ethers } from 'ethers';
-import { RecoveryCode as GuardRecoveryCode } from "./guard.gen.js";
-export declare class GuardSigner implements signers.SapientSigner {
-    readonly address: string;
-    readonly url: string;
-    readonly appendSuffix: boolean;
-    readonly projectAccessKey?: string | undefined;
-    private guard;
-    constructor(address: string, url: string, appendSuffix?: boolean, projectAccessKey?: string | undefined);
-    _fetch: (input: RequestInfo, init?: RequestInit) => Promise<Response>;
-    getAddress(): Promise<string>;
-    buildDeployTransaction(_metadata: object): Promise<commons.transaction.TransactionBundle | undefined>;
-    predecorateSignedTransactions(_metadata: object): Promise<commons.transaction.SignedTransactionBundle[]>;
-    decorateTransactions(bundle: commons.transaction.IntendedTransactionBundle, _metadata: object): Promise<commons.transaction.IntendedTransactionBundle>;
-    sign(message: ethers.BytesLike, metadata: object): Promise<ethers.BytesLike>;
-    notifyStatusChange(_id: string, _status: Status, _metadata: object): void;
-    getAuthMethods(proof: OwnershipProof): Promise<{
-        methods: AuthMethod[];
-        active: boolean;
-    }>;
-    setPin(pin: string | undefined, proof: AuthUpdateProof): Promise<void>;
-    resetPin(proof: AuthUpdateProof): Promise<void>;
-    createTotp(proof: AuthUpdateProof): Promise<URL>;
-    commitTotp(token: string, jwt: string): Promise<RecoveryCode[]>;
-    resetTotp(proof: AuthUpdateProof): Promise<void>;
-    reset2fa(recoveryCode: string, proof: OwnershipProof): Promise<void>;
-    getRecoveryCodes(proof: AuthUpdateProof): Promise<RecoveryCode[]>;
-    resetRecoveryCodes(proof: AuthUpdateProof): Promise<RecoveryCode[]>;
-    private packMsgAndSig;
-    suffix(): ethers.BytesLike;
-}
-export type RecoveryCode = GuardRecoveryCode;
-export declare enum AuthMethod {
-    PIN = "PIN",
-    TOTP = "TOTP"
-}
-export type SignedOwnershipProof = {
-    walletAddress: string;
-    timestamp: Date;
-    signerAddress: string;
-    signature: string;
-};
-export type OwnershipProof = SignedOwnershipProof | {
-    jwt: string;
-} | {
-    walletAddress: string;
-    signer: ethers.Signer | signers.SapientSigner;
-};
-export declare function isSignedOwnershipProof(proof: OwnershipProof): proof is SignedOwnershipProof;
-export declare function signOwnershipProof(proof: Exclude<OwnershipProof, {
-    jwt: string;
-}>): Promise<SignedOwnershipProof>;
-export type AuthUpdateProof = {
-    jwt: string;
-} & ({
-    timestamp: Date;
-    signature: string;
-} | {
-    wallet: Account;
-});
-export declare function getOwnershipProofTypedData(wallet: string, timestamp: Date): TypedData;
-export declare function getAuthUpdateProofTypedData(timestamp: Date): TypedData;

package/src/signer.ts

@@ -1,308 +0,0 @@
-import { Account } from '@0xsequence/account'
-import { commons, universal } from '@0xsequence/core'
-import { signers, Status } from '@0xsequence/signhub'
-import { encodeTypedDataDigest, TypedData } from '@0xsequence/utils'
-import { ethers } from 'ethers'
-import { AuthMethodsReturn, Guard, RecoveryCode as GuardRecoveryCode } from './guard.gen'
-
-export class GuardSigner implements signers.SapientSigner {
-  private guard: Guard
-
-  constructor(
-    public readonly address: string,
-    public readonly url: string,
-    public readonly appendSuffix: boolean = false,
-    public readonly projectAccessKey?: string
-  ) {
-    this.guard = new Guard(url, this._fetch)
-  }
-
-  _fetch = (input: RequestInfo, init?: RequestInit): Promise<Response> => {
-    const headers: { [key: string]: any } = {}
-
-    const projectAccessKey = this.projectAccessKey
-
-    if (projectAccessKey && projectAccessKey.length > 0) {
-      headers['X-Access-Key'] = projectAccessKey
-    }
-
-    // before the request is made
-    init!.headers = { ...init!.headers, ...headers }
-
-    return fetch(input, init)
-  }
-
-  async getAddress(): Promise<string> {
-    return this.address
-  }
-
-  async buildDeployTransaction(_metadata: object): Promise<commons.transaction.TransactionBundle | undefined> {
-    return undefined
-  }
-
-  async predecorateSignedTransactions(_metadata: object): Promise<commons.transaction.SignedTransactionBundle[]> {
-    return []
-  }
-
-  async decorateTransactions(
-    bundle: commons.transaction.IntendedTransactionBundle,
-    _metadata: object
-  ): Promise<commons.transaction.IntendedTransactionBundle> {
-    return bundle
-  }
-
-  async sign(message: ethers.BytesLike, metadata: object): Promise<ethers.BytesLike> {
-    if (!commons.isWalletSignRequestMetadata(metadata)) {
-      throw new Error('expected sequence signature request metadata')
-    }
-
-    const guardTotpCode = (metadata as { guardTotpCode?: string }).guardTotpCode
-
-    // Building auxData, notice: this uses the old v1 format
-    // TODO: We should update the guard API so we can pass the metadata directly
-    const coder = universal.genericCoderFor(metadata.config.version)
-    const { encoded } = coder.signature.encodeSigners(metadata.config, metadata.parts ?? new Map(), [], metadata.chainId)
-
-    return (
-      await this.guard.signWith({
-        signer: this.address,
-        request: {
-          msg: ethers.hexlify(message),
-          auxData: this.packMsgAndSig(metadata.address, metadata.digest, encoded, metadata.chainId),
-          chainId: Number(metadata.chainId)
-        },
-        token: guardTotpCode ? { id: AuthMethod.TOTP, token: guardTotpCode } : undefined
-      })
-    ).sig
-  }
-
-  notifyStatusChange(_id: string, _status: Status, _metadata: object): void {}
-
-  async getAuthMethods(proof: OwnershipProof): Promise<{ methods: AuthMethod[]; active: boolean }> {
-    let response: AuthMethodsReturn
-
-    if ('jwt' in proof) {
-      response = await this.guard.authMethods({}, { Authorization: `BEARER ${proof.jwt}` })
-    } else {
-      const signedProof = await signOwnershipProof(proof)
-
-      response = await this.guard.authMethods({
-        proof: {
-          wallet: signedProof.walletAddress,
-          timestamp: signedProof.timestamp.getTime(),
-          signer: signedProof.signerAddress,
-          signature: signedProof.signature
-        }
-      })
-    }
-
-    return { ...response, methods: response.methods.map(parseAuthMethod) }
-  }
-
-  async setPin(pin: string | undefined, proof: AuthUpdateProof): Promise<void> {
-    const signedProof = await signAuthUpdateProof(proof)
-
-    if (pin === undefined) {
-      await this.guard.resetPIN(
-        { timestamp: signedProof.timestamp.getTime(), signature: signedProof.signature },
-        { Authorization: `BEARER ${proof.jwt}` }
-      )
-    } else {
-      await this.guard.setPIN(
-        { pin, timestamp: signedProof.timestamp.getTime(), signature: signedProof.signature },
-        { Authorization: `BEARER ${proof.jwt}` }
-      )
-    }
-  }
-
-  resetPin(proof: AuthUpdateProof): Promise<void> {
-    return this.setPin(undefined, proof)
-  }
-
-  async createTotp(proof: AuthUpdateProof): Promise<URL> {
-    const signedProof = await signAuthUpdateProof(proof)
-
-    const { uri } = await this.guard.createTOTP(
-      { timestamp: signedProof.timestamp.getTime(), signature: signedProof.signature },
-      { Authorization: `BEARER ${proof.jwt}` }
-    )
-
-    return new URL(uri)
-  }
-
-  async commitTotp(token: string, jwt: string): Promise<RecoveryCode[]> {
-    const { codes } = await this.guard.commitTOTP({ token }, { Authorization: `BEARER ${jwt}` })
-    return codes
-  }
-
-  async resetTotp(proof: AuthUpdateProof): Promise<void> {
-    const signedProof = await signAuthUpdateProof(proof)
-
-    await this.guard.resetTOTP(
-      { timestamp: signedProof.timestamp.getTime(), signature: signedProof.signature },
-      { Authorization: `BEARER ${proof.jwt}` }
-    )
-  }
-
-  async reset2fa(recoveryCode: string, proof: OwnershipProof): Promise<void> {
-    if ('jwt' in proof) {
-      await this.guard.reset2FA({ code: recoveryCode }, { Authorization: `BEARER ${proof.jwt}` })
-    } else {
-      const signedProof = await signOwnershipProof(proof)
-
-      await this.guard.reset2FA({
-        code: recoveryCode,
-        proof: {
-          wallet: signedProof.walletAddress,
-          timestamp: signedProof.timestamp.getTime(),
-          signer: signedProof.signerAddress,
-          signature: signedProof.signature
-        }
-      })
-    }
-  }
-
-  async getRecoveryCodes(proof: AuthUpdateProof): Promise<RecoveryCode[]> {
-    const signedProof = await signAuthUpdateProof(proof)
-
-    const { codes } = await this.guard.recoveryCodes(
-      { timestamp: signedProof.timestamp.getTime(), signature: signedProof.signature },
-      { Authorization: `BEARER ${proof.jwt}` }
-    )
-
-    return codes
-  }
-
-  async resetRecoveryCodes(proof: AuthUpdateProof): Promise<RecoveryCode[]> {
-    const signedProof = await signAuthUpdateProof(proof)
-
-    const { codes } = await this.guard.resetRecoveryCodes(
-      { timestamp: signedProof.timestamp.getTime(), signature: signedProof.signature },
-      { Authorization: `BEARER ${proof.jwt}` }
-    )
-
-    return codes
-  }
-
-  private packMsgAndSig(address: string, msg: ethers.BytesLike, sig: ethers.BytesLike, chainId: ethers.BigNumberish): string {
-    return ethers.AbiCoder.defaultAbiCoder().encode(['address', 'uint256', 'bytes', 'bytes'], [address, chainId, msg, sig])
-  }
-
-  suffix(): ethers.BytesLike {
-    return new Uint8Array(this.appendSuffix ? [3] : [])
-  }
-}
-
-export type RecoveryCode = GuardRecoveryCode
-
-export enum AuthMethod {
-  PIN = 'PIN',
-  TOTP = 'TOTP'
-}
-
-function parseAuthMethod(method: string): AuthMethod {
-  switch (method) {
-    case AuthMethod.PIN:
-    case AuthMethod.TOTP:
-      return method
-    default:
-      throw new Error(`unknown auth method '${method}'`)
-  }
-}
-
-export type SignedOwnershipProof = {
-  walletAddress: string
-  timestamp: Date
-  signerAddress: string
-  signature: string
-}
-
-export type OwnershipProof =
-  | SignedOwnershipProof
-  | { jwt: string }
-  | {
-      walletAddress: string
-      signer: ethers.Signer | signers.SapientSigner
-    }
-
-export function isSignedOwnershipProof(proof: OwnershipProof): proof is SignedOwnershipProof {
-  return 'signerAddress' in proof && typeof proof.signerAddress === 'string'
-}
-
-export async function signOwnershipProof(proof: Exclude<OwnershipProof, { jwt: string }>): Promise<SignedOwnershipProof> {
-  if (isSignedOwnershipProof(proof)) {
-    return proof
-  } else {
-    const signer = signers.isSapientSigner(proof.signer) ? proof.signer : new signers.SignerWrapper(proof.signer)
-    const signerAddress = await signer.getAddress()
-    const timestamp = new Date()
-    const typedData = getOwnershipProofTypedData(proof.walletAddress, timestamp)
-    const digest = encodeTypedDataDigest(typedData)
-
-    return {
-      walletAddress: proof.walletAddress,
-      timestamp,
-      signerAddress,
-      signature: ethers.hexlify(await signer.sign(digest, {}))
-    }
-  }
-}
-
-export type AuthUpdateProof = { jwt: string } & ({ timestamp: Date; signature: string } | { wallet: Account })
-
-async function signAuthUpdateProof(proof: AuthUpdateProof): Promise<{ jwt: string; timestamp: Date; signature: string }> {
-  if ('wallet' in proof) {
-    const timestamp = new Date()
-    const typedData = getAuthUpdateProofTypedData(timestamp)
-
-    const signature = await proof.wallet.signTypedData(
-      typedData.domain,
-      typedData.types,
-      typedData.message,
-      typedData.domain.chainId ?? 1,
-      'eip6492'
-    )
-
-    return { jwt: proof.jwt, timestamp, signature }
-  } else {
-    return proof
-  }
-}
-
-export function getOwnershipProofTypedData(wallet: string, timestamp: Date): TypedData {
-  return {
-    domain,
-    types: {
-      AuthMethods: [
-        { name: 'wallet', type: 'address' },
-        { name: 'timestamp', type: 'string' }
-      ]
-    },
-    message: {
-      wallet: ethers.getAddress(wallet),
-      timestamp: toUTCString(timestamp)
-    }
-  }
-}
-
-export function getAuthUpdateProofTypedData(timestamp: Date): TypedData {
-  return {
-    domain,
-    types: {
-      AuthUpdate: [{ name: 'timestamp', type: 'string' }]
-    },
-    message: {
-      timestamp: toUTCString(timestamp)
-    }
-  }
-}
-
-const domain: ethers.TypedDataDomain = {
-  name: 'Sequence Guard',
-  version: '1',
-  chainId: 1
-}
-
-function toUTCString(date: Date): string {
-  return date.toUTCString().replace('GMT', 'UTC')
-}