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

package/src/index.ts

@@ -1,2 +1,6 @@
-export { Guard } from './guard.gen'
-export * from './signer'
+export * from './types.js'
+export { PayloadType, SignatureType, type Signature } from './client/guard.gen.js'
+
+export * as Client from './client/guard.gen.js'
+export * as Sequence from './sequence.js'
+export * as Local from './local.js'

package/src/local.ts

@@ -0,0 +1,23 @@
+import { Address, Hex, Bytes, Secp256k1, Hash } from 'ox'
+import * as Client from './client/guard.gen.js'
+import * as Types from './types.js'
+
+export class Guard implements Types.Guard {
+  public readonly address: Address.Address
+
+  constructor(private readonly privateKey: Hex.Hex) {
+    const publicKey = Secp256k1.getPublicKey({ privateKey: this.privateKey })
+    this.address = Address.fromPublicKey(publicKey)
+  }
+
+  async signPayload(
+    wallet: Address.Address,
+    chainId: number,
+    type: Client.PayloadType,
+    digest: Bytes.Bytes,
+    message: Bytes.Bytes,
+    signatures?: Client.Signature[],
+  ) {
+    return Secp256k1.sign({ privateKey: this.privateKey, payload: digest })
+  }
+}

package/src/sequence.ts

@@ -0,0 +1,56 @@
+import { Address, Hex, Signature, Bytes, Hash } from 'ox'
+import * as Client from './client/guard.gen.js'
+import * as Types from './types.js'
+
+export class Guard implements Types.Guard {
+  private readonly guard?: Client.Guard
+  public readonly address: Address.Address
+
+  constructor(hostname: string, address: Address.Address, fetch?: Client.Fetch) {
+    if (hostname && address) {
+      this.guard = new Client.Guard(hostname, fetch ?? window.fetch)
+    }
+    this.address = address
+  }
+
+  async signPayload(
+    wallet: Address.Address,
+    chainId: number,
+    type: Client.PayloadType,
+    digest: Bytes.Bytes,
+    message: Bytes.Bytes,
+    signatures?: Client.Signature[],
+    token?: Client.AuthToken,
+  ) {
+    if (!this.guard || !this.address) {
+      throw new Error('Guard not initialized')
+    }
+
+    try {
+      const res = await this.guard.signWith({
+        signer: this.address,
+        request: {
+          chainId: chainId,
+          msg: Hex.fromBytes(digest),
+          wallet,
+          payloadType: type,
+          payloadData: Hex.fromBytes(message),
+          signatures,
+        },
+        token,
+      })
+
+      Hex.assert(res.sig)
+      return Signature.fromHex(res.sig)
+    } catch (error) {
+      if (error instanceof Client.RequiresTOTPError) {
+        throw new Types.AuthRequiredError('TOTP')
+      }
+      if (error instanceof Client.RequiresPINError) {
+        throw new Types.AuthRequiredError('PIN')
+      }
+      console.error(error)
+      throw new Error('Error signing with guard')
+    }
+  }
+}

package/src/types.ts

@@ -0,0 +1,27 @@
+import { Address, Bytes, Signature } from 'ox'
+import * as Client from './client/guard.gen.js'
+
+export interface Guard {
+  readonly address: Address.Address
+
+  signPayload(
+    wallet: Address.Address,
+    chainId: number,
+    type: Client.PayloadType,
+    digest: Bytes.Bytes,
+    message: Bytes.Bytes,
+    signatures?: Client.Signature[],
+    token?: Client.AuthToken,
+  ): Promise<Signature.Signature>
+}
+
+export class AuthRequiredError extends Error {
+  public readonly id: 'TOTP' | 'PIN'
+
+  constructor(id: 'TOTP' | 'PIN') {
+    super('auth required')
+    this.id = id
+    this.name = 'AuthRequiredError'
+    Object.setPrototypeOf(this, AuthRequiredError.prototype)
+  }
+}

package/test/sequence.test.ts

@@ -0,0 +1,189 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { Guard } from '../src/sequence'
+import { PayloadType } from '../src/client/guard.gen'
+import { Address, Bytes, Hex } from 'ox'
+
+// Mock fetch globally for guard API calls
+const mockFetch = vi.fn()
+global.fetch = mockFetch
+
+describe('Sequence', () => {
+  describe('GuardSigner', () => {
+    let guard: Guard
+    let testWallet: Address.Address
+    let testMessage: Bytes.Bytes
+    let testMessageDigest: Bytes.Bytes
+
+    beforeEach(() => {
+      vi.clearAllMocks()
+      guard = new Guard('https://guard.sequence.app', '0xaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeae', fetch)
+      testWallet = '0x1234567890123456789012345678901234567890' as Address.Address
+      testMessage = Bytes.fromString('Test message')
+      testMessageDigest = Bytes.fromHex('0x1234567890abcdef1234567890abcdef1234567890')
+    })
+
+    afterEach(() => {
+      vi.resetAllMocks()
+    })
+
+    describe('sign()', () => {
+      it('Should successfully sign a payload with guard service', async () => {
+        const mockSignature =
+          '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1b'
+
+        mockFetch.mockResolvedValueOnce({
+          json: async () => ({
+            sig: mockSignature,
+          }),
+          text: async () =>
+            JSON.stringify({
+              sig: mockSignature,
+            }),
+          ok: true,
+        })
+
+        const result = await guard.signPayload(
+          testWallet,
+          42161,
+          PayloadType.ConfigUpdate,
+          testMessageDigest,
+          testMessage,
+        )
+
+        expect(result).toBeDefined()
+        expect(result.r).toBeDefined()
+        expect(result.s).toBeDefined()
+        expect(result.yParity).toBeDefined()
+
+        // Verify API call was made correctly
+        expect(mockFetch).toHaveBeenCalledOnce()
+        const [url, options] = mockFetch.mock.calls[0]
+
+        expect(url).toContain('/rpc/Guard/SignWith')
+        expect(options.method).toBe('POST')
+        expect(options.headers['Content-Type']).toBe('application/json')
+
+        const requestBody = JSON.parse(options.body)
+        expect(requestBody.signer).toBe('0xaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeaeae')
+        expect(requestBody.request.chainId).toBe(42161)
+        expect(requestBody.request.msg).toBe(Hex.fromBytes(testMessageDigest).toString())
+        expect(requestBody.request.payloadType).toBe(PayloadType.ConfigUpdate)
+        expect(requestBody.request.payloadData).toBe(Hex.fromBytes(testMessage).toString())
+        expect(requestBody.request.wallet).toBe(testWallet)
+      })
+
+      it('Should handle custom chainId in sign request', async () => {
+        const customChainId = 1 // Ethereum mainnet
+
+        mockFetch.mockResolvedValueOnce({
+          json: async () => ({
+            sig: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1b',
+          }),
+          text: async () =>
+            JSON.stringify({
+              sig: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1b',
+            }),
+          ok: true,
+        })
+
+        await guard.signPayload(testWallet, 1, PayloadType.ConfigUpdate, testMessageDigest, testMessage)
+
+        const requestBody = JSON.parse(mockFetch.mock.calls[0][1].body)
+        expect(requestBody.request.chainId).toBe(1)
+      })
+
+      it('Should throw error when guard service fails', async () => {
+        mockFetch.mockRejectedValueOnce(new Error('Network error'))
+
+        await expect(
+          guard.signPayload(testWallet, 42161, PayloadType.ConfigUpdate, testMessageDigest, testMessage),
+        ).rejects.toThrow('Error signing with guard')
+      })
+
+      it('Should throw error when guard service returns invalid response', async () => {
+        mockFetch.mockResolvedValueOnce({
+          json: async () => {
+            throw new Error('Invalid JSON')
+          },
+          text: async () => {
+            throw new Error('Invalid JSON')
+          },
+          ok: true,
+        })
+
+        await expect(
+          guard.signPayload(testWallet, 42161, PayloadType.ConfigUpdate, testMessageDigest, testMessage),
+        ).rejects.toThrow('Error signing with guard')
+      })
+
+      it('Should include proper headers and signer address in request', async () => {
+        const mockGuardAddress = '0x9876543210987654321098765432109876543210' as Address.Address
+        const customGuard = new Guard('https://guard.sequence.app', mockGuardAddress, fetch)
+
+        mockFetch.mockResolvedValueOnce({
+          json: async () => ({
+            sig: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1b',
+          }),
+          text: async () =>
+            JSON.stringify({
+              sig: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1b',
+            }),
+          ok: true,
+        })
+
+        await customGuard.signPayload(testWallet, 42161, PayloadType.ConfigUpdate, testMessageDigest, testMessage)
+
+        const requestBody = JSON.parse(mockFetch.mock.calls[0][1].body)
+        expect(requestBody.signer).toBe(mockGuardAddress)
+      })
+
+      describe('Error Handling', () => {
+        it('Should handle malformed guard service response', async () => {
+          mockFetch.mockResolvedValueOnce({
+            json: async () => ({
+              // Missing 'sig' field
+              error: 'Invalid request',
+            }),
+            text: async () =>
+              JSON.stringify({
+                error: 'Invalid request',
+              }),
+            ok: true,
+          })
+
+          await expect(
+            guard.signPayload(testWallet, 42161, PayloadType.ConfigUpdate, testMessageDigest, testMessage),
+          ).rejects.toThrow('Error signing with guard')
+        })
+
+        it('Should handle network timeout errors', async () => {
+          mockFetch.mockImplementationOnce(
+            () => new Promise((_, reject) => setTimeout(() => reject(new Error('Timeout')), 100)),
+          )
+
+          await expect(
+            guard.signPayload(testWallet, 42161, PayloadType.ConfigUpdate, testMessageDigest, testMessage),
+          ).rejects.toThrow('Error signing with guard')
+        })
+
+        it('Should handle HTTP error responses', async () => {
+          mockFetch.mockResolvedValueOnce({
+            ok: false,
+            status: 500,
+            json: async () => ({
+              error: 'Internal server error',
+            }),
+            text: async () =>
+              JSON.stringify({
+                error: 'Internal server error',
+              }),
+          })
+
+          await expect(
+            guard.signPayload(testWallet, 42161, PayloadType.ConfigUpdate, testMessageDigest, testMessage),
+          ).rejects.toThrow('Error signing with guard')
+        })
+      })
+    })
+  })
+})

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "@repo/typescript-config/base.json",
+  "compilerOptions": {
+    "rootDir": "src",
+    "outDir": "dist",
+    "types": ["node"]
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist"]
+}

package/dist/0xsequence-guard.cjs.d.ts

@@ -1,2 +0,0 @@
-export * from "./declarations/src/index.js";
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMHhzZXF1ZW5jZS1ndWFyZC5janMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4vZGVjbGFyYXRpb25zL3NyYy9pbmRleC5kLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBIn0=