@0xsequence/guard 1.4.0 → 1.4.2

package/dist/0xsequence-guard.esm.js

@@ -1,5 +1,7 @@
-import { ethers } from 'ethers';
 import { commons, universal } from '@0xsequence/core';
+import { signers } from '@0xsequence/signhub';
+import { encodeTypedDataDigest } from '@0xsequence/utils';
+import { ethers } from 'ethers';
 
 function _extends() {
   _extends = Object.assign ? Object.assign.bind() : function (target) {
@@ -16,22 +18,6 @@ function _extends() {
   return _extends.apply(this, arguments);
 }
 
-/* eslint-disable */
-// sequence-guard v0.4.0 a29651d1d5f63268e8d03b51e46557e0632c144d
-// --
-// Code generated by webrpc-gen@v0.10.x-dev with typescript generator. DO NOT EDIT.
-//
-// webrpc-gen -schema=guard.ridl -target=typescript -client -out=./clients/guard.gen.ts
-
-// WebRPC description and code-gen version
-const WebRPCVersion = 'v1';
-
-// Schema version of your RIDL schema
-const WebRPCSchemaVersion = 'v0.4.0';
-
-// Schema hash generated from your RIDL schema
-const WebRPCSchemaHash = 'a29651d1d5f63268e8d03b51e46557e0632c144d';
-
 //
 // Types
 //
@@ -95,6 +81,80 @@ class Guard {
         });
       });
     };
+    this.authMethods = (args, headers) => {
+      return this.fetch(this.url('AuthMethods'), createHTTPRequest(args, headers)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            methods: _data.methods,
+            active: _data.active
+          };
+        });
+      });
+    };
+    this.setPIN = (args, headers) => {
+      return this.fetch(this.url('SetPIN'), createHTTPRequest(args, headers)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {};
+        });
+      });
+    };
+    this.resetPIN = (args, headers) => {
+      return this.fetch(this.url('ResetPIN'), createHTTPRequest(args, headers)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {};
+        });
+      });
+    };
+    this.createTOTP = (args, headers) => {
+      return this.fetch(this.url('CreateTOTP'), createHTTPRequest(args, headers)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            uri: _data.uri
+          };
+        });
+      });
+    };
+    this.commitTOTP = (args, headers) => {
+      return this.fetch(this.url('CommitTOTP'), createHTTPRequest(args, headers)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            codes: _data.codes
+          };
+        });
+      });
+    };
+    this.resetTOTP = (args, headers) => {
+      return this.fetch(this.url('ResetTOTP'), createHTTPRequest(args, headers)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {};
+        });
+      });
+    };
+    this.reset2FA = (args, headers) => {
+      return this.fetch(this.url('Reset2FA'), createHTTPRequest(args, headers)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {};
+        });
+      });
+    };
+    this.recoveryCodes = (args, headers) => {
+      return this.fetch(this.url('RecoveryCodes'), createHTTPRequest(args, headers)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            codes: _data.codes
+          };
+        });
+      });
+    };
+    this.resetRecoveryCodes = (args, headers) => {
+      return this.fetch(this.url('ResetRecoveryCodes'), createHTTPRequest(args, headers)).then(res => {
+        return buildResponse(res).then(_data => {
+          return {
+            codes: _data.codes
+          };
+        });
+      });
+    };
     this.hostname = hostname;
     this.fetch = (input, init) => fetch(input, init);
   }
@@ -133,12 +193,10 @@ const buildResponse = res => {
 
 const fetch = typeof global === 'object' ? global.fetch : window.fetch;
 class GuardSigner {
-  constructor(address, url, appendSuffix = false, onError) {
-    this.requests = new Map();
+  constructor(address, url, appendSuffix = false) {
     this.address = address;
     this.url = url;
     this.appendSuffix = appendSuffix;
-    this.onError = onError;
     this.guard = new Guard(url, fetch);
   }
   async getAddress() {
@@ -153,32 +211,18 @@ class GuardSigner {
   async decorateTransactions(bundle, _metadata) {
     return bundle;
   }
-  async requestSignature(id, _message, metadata, callbacks) {
-    if (!commons.isWalletSignRequestMetadata(metadata)) {
-      callbacks.onRejection('Expected Sequence-like metadata');
-    } else {
-      // Queue the request first, this method only does that
-      // the requesting to the API is later handled on every status change
-      this.requests.set(id, callbacks);
-    }
-    return true;
-  }
-  notifyStatusChange(id, status, metadata) {
-    if (!this.requests.has(id)) return;
+  async requestSignature(_id, message, metadata, callbacks) {
+    var _metadata$parts;
+    const {
+      onSignature,
+      onRejection
+    } = callbacks;
     if (!commons.isWalletSignRequestMetadata(metadata)) {
-      this.requests.get(id).onRejection('Expected Sequence-like metadata (status update)');
-      return;
+      onRejection('expected sequence signature request metadata');
+      return false;
     }
-    this.evaluateRequest(id, status.message, status, metadata);
-  }
-  packMsgAndSig(address, msg, sig, chainId) {
-    return ethers.utils.defaultAbiCoder.encode(['address', 'uint256', 'bytes', 'bytes'], [address, chainId, msg, sig]);
-  }
-  keyOfRequest(signer, msg, auxData, chainId) {
-    return ethers.utils.solidityKeccak256(['address', 'uint256', 'bytes', 'bytes'], [signer, chainId, msg, auxData]);
-  }
-  async evaluateRequest(id, message, _, metadata) {
-    var _metadata$parts;
+    const guardTotpCode = metadata.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);
@@ -186,37 +230,250 @@ class GuardSigner {
       encoded
     } = coder.signature.encodeSigners(metadata.config, (_metadata$parts = metadata.parts) != null ? _metadata$parts : new Map(), [], metadata.chainId);
     try {
-      var _this$requests$get;
-      const key = this.keyOfRequest(this.address, message, encoded, metadata.chainId);
-      const lastAttempt = (_this$requests$get = this.requests.get(id)) == null ? void 0 : _this$requests$get.lastAttempt;
-      if (lastAttempt === key) {
-        return;
-      }
-      this.requests.get(id).lastAttempt = key;
-      const result = await this.guard.signWith({
+      const {
+        sig: signature
+      } = await this.guard.signWith({
         signer: this.address,
         request: {
           msg: ethers.utils.hexlify(message),
           auxData: this.packMsgAndSig(metadata.address, metadata.digest, encoded, metadata.chainId),
-          chainId: ethers.BigNumber.from(metadata.chainId).toNumber() // TODO: This should be a string (in the API)
-        }
+          chainId: ethers.BigNumber.from(metadata.chainId).toNumber()
+        },
+        token: guardTotpCode ? {
+          id: AuthMethod.TOTP,
+          token: guardTotpCode
+        } : undefined
       });
-
-      if (ethers.utils.arrayify(result.sig).length !== 0) {
-        this.requests.get(id).onSignature(result.sig);
-        this.requests.delete(id);
+      if (ethers.utils.arrayify(signature).length === 0) {
+        throw new Error('guard response contained no signature data');
       }
-    } catch (e) {
-      var _this$onError;
-      // The guard signer may reject the request for a number of reasons
-      // like for example, if it's being the first signer (it waits for other signers to sign first)
-      // We always forward the error here and filter on client side.
-      (_this$onError = this.onError) == null ? void 0 : _this$onError.call(this, e);
+      onSignature(signature);
+      return true;
+    } catch (error) {
+      var _ref, _error$message;
+      onRejection(`unable to request guard signature: ${(_ref = (_error$message = error.message) != null ? _error$message : error.msg) != null ? _ref : error}`);
+      return false;
+    }
+  }
+  notifyStatusChange(_id, _status, _metadata) {}
+  async getAuthMethods(proof) {
+    let response;
+    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.map(parseAuthMethod);
+  }
+  async setPin(pin, proof) {
+    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) {
+    return this.setPin(undefined, proof);
+  }
+  async createTotp(proof) {
+    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, jwt) {
+    const {
+      codes
+    } = await this.guard.commitTOTP({
+      token
+    }, {
+      Authorization: `BEARER ${jwt}`
+    });
+    return codes;
+  }
+  async resetTotp(proof) {
+    const signedProof = await signAuthUpdateProof(proof);
+    await this.guard.resetTOTP({
+      timestamp: signedProof.timestamp.getTime(),
+      signature: signedProof.signature
+    }, {
+      Authorization: `BEARER ${proof.jwt}`
+    });
+  }
+  async reset2fa(recoveryCode, proof) {
+    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) {
+    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) {
+    const signedProof = await signAuthUpdateProof(proof);
+    const {
+      codes
+    } = await this.guard.resetRecoveryCodes({
+      timestamp: signedProof.timestamp.getTime(),
+      signature: signedProof.signature
+    }, {
+      Authorization: `BEARER ${proof.jwt}`
+    });
+    return codes;
+  }
+  packMsgAndSig(address, msg, sig, chainId) {
+    return ethers.utils.defaultAbiCoder.encode(['address', 'uint256', 'bytes', 'bytes'], [address, chainId, msg, sig]);
+  }
   suffix() {
     return this.appendSuffix ? [3] : [];
   }
 }
+let AuthMethod = /*#__PURE__*/function (AuthMethod) {
+  AuthMethod["PIN"] = "PIN";
+  AuthMethod["TOTP"] = "TOTP";
+  return AuthMethod;
+}({});
+function parseAuthMethod(method) {
+  switch (method) {
+    case AuthMethod.PIN:
+    case AuthMethod.TOTP:
+      return method;
+    default:
+      throw new Error(`unknown auth method '${method}'`);
+  }
+}
+function isSignedOwnershipProof(proof) {
+  return 'signerAddress' in proof && typeof proof.signerAddress === 'string';
+}
+async function signOwnershipProof(proof) {
+  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);
+    const randomId = ethers.utils.hexlify(ethers.utils.randomBytes(32));
+    return new Promise((resolve, reject) => signer.requestSignature(randomId, digest, {}, {
+      onSignature(signature) {
+        resolve({
+          walletAddress: proof.walletAddress,
+          timestamp,
+          signerAddress,
+          signature: ethers.utils.hexlify(signature)
+        });
+      },
+      onRejection: reject,
+      onStatus(_situation) {}
+    }));
+  }
+}
+async function signAuthUpdateProof(proof) {
+  if ('wallet' in proof) {
+    var _typedData$domain$cha;
+    const timestamp = new Date();
+    const typedData = getAuthUpdateProofTypedData(timestamp);
+    const signature = await proof.wallet.signTypedData(typedData.domain, typedData.types, typedData.message, (_typedData$domain$cha = typedData.domain.chainId) != null ? _typedData$domain$cha : 1, 'eip6492');
+    return {
+      jwt: proof.jwt,
+      timestamp,
+      signature
+    };
+  } else {
+    return proof;
+  }
+}
+function getOwnershipProofTypedData(wallet, timestamp) {
+  return {
+    domain,
+    types: {
+      AuthMethods: [{
+        name: 'wallet',
+        type: 'address'
+      }, {
+        name: 'timestamp',
+        type: 'string'
+      }]
+    },
+    message: {
+      wallet: ethers.utils.getAddress(wallet),
+      timestamp: toUTCString(timestamp)
+    }
+  };
+}
+function getAuthUpdateProofTypedData(timestamp) {
+  return {
+    domain,
+    types: {
+      AuthUpdate: [{
+        name: 'timestamp',
+        type: 'string'
+      }]
+    },
+    message: {
+      timestamp: toUTCString(timestamp)
+    }
+  };
+}
+const domain = {
+  name: 'Sequence Guard',
+  version: '1',
+  chainId: 1
+};
+function toUTCString(date) {
+  return date.toUTCString().replace('GMT', 'UTC');
+}
 
-export { Guard, GuardSigner, WebRPCSchemaHash, WebRPCSchemaVersion, WebRPCVersion };
+export { AuthMethod, GuardSigner, getAuthUpdateProofTypedData, getOwnershipProofTypedData };

package/dist/declarations/src/guard.gen.d.ts

@@ -1,6 +1,6 @@
 export declare const WebRPCVersion = "v1";
 export declare const WebRPCSchemaVersion = "v0.4.0";
-export declare const WebRPCSchemaHash = "a29651d1d5f63268e8d03b51e46557e0632c144d";
+export declare const WebRPCSchemaHash = "2e5d6a4c9b797598078365d7439f330bc7bbf29c";
 export interface Version {
     webrpcVersion: string;
     schemaVersion: string;
@@ -28,6 +28,20 @@ export interface SignRequest {
     msg: string;
     auxData: string;
 }
+export interface OwnershipProof {
+    wallet: string;
+    timestamp: number;
+    signer: string;
+    signature: string;
+}
+export interface AuthToken {
+    id: string;
+    token: string;
+}
+export interface RecoveryCode {
+    code: string;
+    used: boolean;
+}
 export interface Guard {
     ping(headers?: object): Promise<PingReturn>;
     version(headers?: object): Promise<VersionReturn>;
@@ -35,6 +49,15 @@ export interface Guard {
     getSignerConfig(args: GetSignerConfigArgs, headers?: object): Promise<GetSignerConfigReturn>;
     sign(args: SignArgs, headers?: object): Promise<SignReturn>;
     signWith(args: SignWithArgs, headers?: object): Promise<SignWithReturn>;
+    authMethods(args: AuthMethodsArgs, headers?: object): Promise<AuthMethodsReturn>;
+    setPIN(args: SetPINArgs, headers?: object): Promise<SetPINReturn>;
+    resetPIN(args: ResetPINArgs, headers?: object): Promise<ResetPINReturn>;
+    createTOTP(args: CreateTOTPArgs, headers?: object): Promise<CreateTOTPReturn>;
+    commitTOTP(args: CommitTOTPArgs, headers?: object): Promise<CommitTOTPReturn>;
+    resetTOTP(args: ResetTOTPArgs, headers?: object): Promise<ResetTOTPReturn>;
+    reset2FA(args: Reset2FAArgs, headers?: object): Promise<Reset2FAReturn>;
+    recoveryCodes(args: RecoveryCodesArgs, headers?: object): Promise<RecoveryCodesReturn>;
+    resetRecoveryCodes(args: ResetRecoveryCodesArgs, headers?: object): Promise<ResetRecoveryCodesReturn>;
 }
 export interface PingArgs {
 }
@@ -59,6 +82,7 @@ export interface GetSignerConfigReturn {
 }
 export interface SignArgs {
     request: SignRequest;
+    token?: AuthToken;
 }
 export interface SignReturn {
     sig: string;
@@ -66,10 +90,70 @@ export interface SignReturn {
 export interface SignWithArgs {
     signer: string;
     request: SignRequest;
+    token?: AuthToken;
 }
 export interface SignWithReturn {
     sig: string;
 }
+export interface AuthMethodsArgs {
+    proof?: OwnershipProof;
+}
+export interface AuthMethodsReturn {
+    methods: Array<string>;
+    active: boolean;
+}
+export interface SetPINArgs {
+    pin: string;
+    timestamp: number;
+    signature: string;
+}
+export interface SetPINReturn {
+}
+export interface ResetPINArgs {
+    timestamp: number;
+    signature: string;
+}
+export interface ResetPINReturn {
+}
+export interface CreateTOTPArgs {
+    timestamp: number;
+    signature: string;
+}
+export interface CreateTOTPReturn {
+    uri: string;
+}
+export interface CommitTOTPArgs {
+    token: string;
+}
+export interface CommitTOTPReturn {
+    codes: Array<RecoveryCode>;
+}
+export interface ResetTOTPArgs {
+    timestamp: number;
+    signature: string;
+}
+export interface ResetTOTPReturn {
+}
+export interface Reset2FAArgs {
+    code: string;
+    proof?: OwnershipProof;
+}
+export interface Reset2FAReturn {
+}
+export interface RecoveryCodesArgs {
+    timestamp: number;
+    signature: string;
+}
+export interface RecoveryCodesReturn {
+    codes: Array<RecoveryCode>;
+}
+export interface ResetRecoveryCodesArgs {
+    timestamp: number;
+    signature: string;
+}
+export interface ResetRecoveryCodesReturn {
+    codes: Array<RecoveryCode>;
+}
 export declare class Guard implements Guard {
     protected hostname: string;
     protected fetch: Fetch;
@@ -82,6 +166,15 @@ export declare class Guard implements Guard {
     getSignerConfig: (args: GetSignerConfigArgs, headers?: object | undefined) => Promise<GetSignerConfigReturn>;
     sign: (args: SignArgs, headers?: object | undefined) => Promise<SignReturn>;
     signWith: (args: SignWithArgs, headers?: object | undefined) => Promise<SignWithReturn>;
+    authMethods: (args: AuthMethodsArgs, headers?: object | undefined) => Promise<AuthMethodsReturn>;
+    setPIN: (args: SetPINArgs, headers?: object | undefined) => Promise<SetPINReturn>;
+    resetPIN: (args: ResetPINArgs, headers?: object | undefined) => Promise<ResetPINReturn>;
+    createTOTP: (args: CreateTOTPArgs, headers?: object | undefined) => Promise<CreateTOTPReturn>;
+    commitTOTP: (args: CommitTOTPArgs, headers?: object | undefined) => Promise<CommitTOTPReturn>;
+    resetTOTP: (args: ResetTOTPArgs, headers?: object | undefined) => Promise<ResetTOTPReturn>;
+    reset2FA: (args: Reset2FAArgs, headers?: object | undefined) => Promise<Reset2FAReturn>;
+    recoveryCodes: (args: RecoveryCodesArgs, headers?: object | undefined) => Promise<RecoveryCodesReturn>;
+    resetRecoveryCodes: (args: ResetRecoveryCodesArgs, headers?: object | undefined) => Promise<ResetRecoveryCodesReturn>;
 }
 export interface WebRPCError extends Error {
     code: string;

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

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

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

@@ -1,26 +1,60 @@
-import { signers, Status } from '@0xsequence/signhub';
-import { BytesLike } from 'ethers';
+import { Account } from '@0xsequence/account';
 import { commons } from '@0xsequence/core';
+import { signers, Status } from '@0xsequence/signhub';
+import { TypedData } from '@0xsequence/utils';
+import { BytesLike, 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;
-    private readonly onError?;
     private guard;
-    private requests;
-    constructor(address: string, url: string, appendSuffix?: boolean, onError?: ((err: Error) => void) | undefined);
+    constructor(address: string, url: string, appendSuffix?: boolean);
     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>;
-    requestSignature(id: string, _message: BytesLike, metadata: object, callbacks: {
+    requestSignature(_id: string, message: BytesLike, metadata: object, callbacks: {
         onSignature: (signature: BytesLike) => void;
         onRejection: (error: string) => void;
         onStatus: (situation: string) => void;
     }): Promise<boolean>;
-    notifyStatusChange(id: string, status: Status, metadata: object): void;
+    notifyStatusChange(_id: string, _status: Status, _metadata: object): void;
+    getAuthMethods(proof: OwnershipProof): Promise<AuthMethod[]>;
+    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;
-    private keyOfRequest;
-    private evaluateRequest;
     suffix(): BytesLike;
 }
+export type RecoveryCode = GuardRecoveryCode;
+export declare enum AuthMethod {
+    PIN = "PIN",
+    TOTP = "TOTP"
+}
+export type OwnershipProof = {
+    jwt: string;
+} | {
+    walletAddress: string;
+    timestamp: Date;
+    signerAddress: string;
+    signature: string;
+} | {
+    walletAddress: string;
+    signer: ethers.Signer | signers.SapientSigner;
+};
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/guard",
-  "version": "1.4.0",
+  "version": "1.4.2",
   "description": "guard sub-package for Sequence",
   "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/guard",
   "source": "src/index.ts",
@@ -10,8 +10,10 @@
   "license": "Apache-2.0",
   "dependencies": {
     "ethers": "^5.7.2",
-    "@0xsequence/core": "1.4.0",
-    "@0xsequence/signhub": "1.4.0"
+    "@0xsequence/account": "1.4.2",
+    "@0xsequence/core": "1.4.2",
+    "@0xsequence/signhub": "1.4.2",
+    "@0xsequence/utils": "1.4.2"
   },
   "files": [
     "src",