rise-wallet 0.1.4-beta.2 → 0.2.29

package/src/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "../tsconfig.base.json",
+  "include": ["."],
+  "exclude": [
+    "**/_/**",
+    "**/*.test.ts",
+    "**/*.test.tsx",
+    "**/bin/**",
+    "**/tsdown.config.ts"
+  ],
+  "compilerOptions": {
+    "noEmit": true,
+    "jsx": "react-jsx"
+  }
+}

package/src/viem/Account.test.ts

@@ -0,0 +1,270 @@
+import { Hex } from 'ox'
+import { verifyHash } from 'viem/actions'
+import { describe, expect, test } from 'vitest'
+
+import { createAccount } from '../../test/src/actions.js'
+import * as TestConfig from '../../test/src/config.js'
+import * as Key from '../viem/Key.js'
+import * as Account from './Account.js'
+
+const porto = TestConfig.getPorto()
+const client = TestConfig.getRelayClient(porto)
+
+describe('from', () => {
+  test('default', () => {
+    const account = Account.from({
+      address: '0x0000000000000000000000000000000000000001',
+      keys: [
+        Key.fromP256({
+          expiry: 42069,
+          privateKey:
+            '0x59ff6b8de3b3b39e94b6f9fc0590cf4e3eaa9b6736e6a49c9a6b324c4f58cb9f',
+        }),
+      ],
+    })
+
+    expect(account).toMatchInlineSnapshot(`
+      {
+        "address": "0x0000000000000000000000000000000000000001",
+        "keys": [
+          {
+            "chainId": undefined,
+            "expiry": 42069,
+            "feeToken": undefined,
+            "hash": "0xed7ac7c7b35b77e97be67b84f5889e0ab3ecc69ab65d57db191e11f8811e9965",
+            "id": "0xec0effa5f2f378cbf7fd2fa7ca1e8dc51cf777c129fa1c00a0e9a9205f2e511ff3f20b34a4e0b50587d055c0e0fad33d32cf1147d3bb2538fbab0d15d8e65008",
+            "permissions": undefined,
+            "prehash": false,
+            "privateKey": [Function],
+            "publicKey": "0xec0effa5f2f378cbf7fd2fa7ca1e8dc51cf777c129fa1c00a0e9a9205f2e511ff3f20b34a4e0b50587d055c0e0fad33d32cf1147d3bb2538fbab0d15d8e65008",
+            "role": "admin",
+            "type": "p256",
+          },
+        ],
+        "sign": [Function],
+        "signMessage": [Function],
+        "signTransaction": [Function],
+        "signTypedData": [Function],
+        "source": "porto",
+        "type": "local",
+      }
+    `)
+  })
+
+  test('args: address', () => {
+    const account = Account.from('0x0000000000000000000000000000000000000000')
+
+    expect(account).toMatchInlineSnapshot(`
+      {
+        "address": "0x0000000000000000000000000000000000000000",
+        "keys": undefined,
+        "sign": [Function],
+        "signMessage": [Function],
+        "signTransaction": [Function],
+        "signTypedData": [Function],
+        "source": "porto",
+        "type": "local",
+      }
+    `)
+  })
+
+  test('behavior: custom sign', () => {
+    const account = Account.from({
+      address: '0x0000000000000000000000000000000000000000',
+      sign: async () => {
+        return '0x'
+      },
+    })
+
+    expect(account).toMatchInlineSnapshot(`
+      {
+        "address": "0x0000000000000000000000000000000000000000",
+        "keys": undefined,
+        "sign": [Function],
+        "signMessage": [Function],
+        "signTransaction": [Function],
+        "signTypedData": [Function],
+        "source": "privateKey",
+        "type": "local",
+      }
+    `)
+  })
+})
+
+describe('fromPrivateKey', () => {
+  test('default', () => {
+    const account = Account.fromPrivateKey(
+      '0x59ff6b8de3b3b39e94b6f9fc0590cf4e3eaa9b6736e6a49c9a6b324c4f58cb9f',
+    )
+
+    expect(account).toMatchInlineSnapshot(`
+      {
+        "address": "0x673ee8aabd3a62434cb9e3d7c6f9492e286bcb08",
+        "keys": undefined,
+        "sign": [Function],
+        "signMessage": [Function],
+        "signTransaction": [Function],
+        "signTypedData": [Function],
+        "source": "privateKey",
+        "type": "local",
+      }
+    `)
+  })
+})
+
+describe('sign', () => {
+  test('default', async () => {
+    const key = Key.createHeadlessWebAuthnP256()
+    const account = await createAccount(client, {
+      deploy: true,
+      keys: [key],
+    })
+
+    const payload = Hex.random(32)
+    const signature = await Account.sign(account, {
+      payload,
+    })
+
+    const valid = await verifyHash(client, {
+      address: account.address,
+      hash: payload,
+      signature,
+    })
+
+    expect(valid).toBe(true)
+  })
+
+  test('args: key', async () => {
+    const key = Key.createHeadlessWebAuthnP256()
+
+    const account = await createAccount(client, {
+      deploy: true,
+      keys: [key],
+    })
+
+    const payload = Hex.random(32)
+
+    {
+      const signature = await Account.sign(account, {
+        key,
+        payload,
+      })
+
+      const valid = await verifyHash(client, {
+        address: account.address,
+        hash: payload,
+        signature,
+      })
+
+      expect(valid).toBe(true)
+    }
+
+    {
+      const signature = await Account.sign(account, {
+        key: 0,
+        payload,
+      })
+
+      const valid = await verifyHash(client, {
+        address: account.address,
+        hash: payload,
+        signature,
+      })
+
+      expect(valid).toBe(true)
+    }
+  })
+
+  test('args: `role`', async () => {
+    const adminKey = Key.createHeadlessWebAuthnP256()
+    const sessionKey = Key.createP256({
+      role: 'session',
+    })
+    const account = Account.from({
+      address: '0x0000000000000000000000000000000000000000',
+      keys: [sessionKey, adminKey],
+    })
+
+    const payload = Hex.random(32)
+
+    {
+      // Expect the admin key to be used.
+      const signature = await Account.sign(account, {
+        payload,
+        role: 'admin',
+      })
+
+      expect(signature.includes(Key.hash(adminKey).slice(2))).toBe(true)
+    }
+
+    {
+      // Expect the session key to be used.
+      const signature = await Account.sign(account, {
+        payload,
+        role: 'session',
+      })
+
+      expect(signature.includes(Key.hash(sessionKey).slice(2))).toBe(true)
+    }
+  })
+
+  test('behavior: `role` not found', async () => {
+    const sessionKey = Key.createP256({
+      role: 'session',
+    })
+    const account = Account.from({
+      address: '0x0000000000000000000000000000000000000000',
+      keys: [sessionKey],
+    })
+
+    const payload = Hex.random(32)
+
+    await expect(
+      Account.sign(account, {
+        payload,
+        role: 'admin',
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Error: cannot find key to sign with.]',
+    )
+  })
+
+  test('behavior: with key', async () => {
+    const key = Key.createHeadlessWebAuthnP256()
+    const account = await createAccount(client, {
+      deploy: true,
+      keys: [key],
+    })
+
+    const payload = Hex.random(32)
+
+    const signature = await Account.sign(account, {
+      payload,
+    })
+
+    const valid = await verifyHash(client, {
+      address: account.address,
+      hash: payload,
+      signature,
+    })
+
+    expect(valid).toBe(true)
+  })
+
+  test('behavior: no keys', async () => {
+    const account = Account.from({
+      address: '0x0000000000000000000000000000000000000000',
+      keys: undefined,
+    })
+
+    const payload = Hex.random(32)
+
+    await expect(
+      Account.sign(account, {
+        payload,
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      '[Error: cannot find key to sign with.]',
+    )
+  })
+})

package/src/viem/Account.ts

@@ -0,0 +1,278 @@
+import * as Address from 'ox/Address'
+import type * as Hex from 'ox/Hex'
+import * as Secp256k1 from 'ox/Secp256k1'
+import * as Signature from 'ox/Signature'
+import * as TypedData from 'ox/TypedData'
+import type * as WebAuthnP256 from 'ox/WebAuthnP256'
+import {
+  hashMessage,
+  hashTypedData,
+  type LocalAccount,
+  type PartialBy,
+} from 'viem'
+import { toAccount } from 'viem/accounts'
+import type { Assign, Compute } from '../core/internal/types.js'
+import type * as Storage from '../core/Storage.js'
+import * as Key from './Key.js'
+
+export type Account<
+  source extends 'porto' | 'privateKey' = 'porto' | 'privateKey',
+> = LocalAccount<source> & {
+  keys?: readonly Key.Key[] | undefined
+  sign: NonNullable<LocalAccount['sign']>
+}
+
+/**
+ * Instantiates a delegated account.
+ *
+ * @param account - Account to instantiate.
+ * @returns An instantiated delegated account.
+ */
+export function from<const account extends from.Parameters>(
+  parameters: from.Parameters<account>,
+): Compute<from.ReturnType<account>> {
+  const account = (
+    typeof parameters === 'string' ? { address: parameters } : parameters
+  ) as from.AccountParameter
+  const source = account.sign ? 'privateKey' : 'porto'
+
+  const {
+    address,
+    sign: sign_,
+    signMessage,
+    signTransaction,
+    signTypedData,
+    type,
+  } = toAccount({
+    address: account.address,
+    sign({ hash }) {
+      if (source === 'privateKey') return account.sign!({ hash })
+      throw new Error('`sign` not supported on porto accounts.')
+    },
+    signMessage({ message }) {
+      return this.sign!({
+        hash: hashMessage(message),
+      })
+    },
+    signTransaction() {
+      throw new Error('`signTransaction` not supported on porto accounts.')
+    },
+    signTypedData(typedData) {
+      return this.sign!({
+        hash: hashTypedData(typedData),
+      })
+    },
+  })
+  return {
+    address,
+    keys: account.keys ?? undefined,
+    sign: sign_,
+    signMessage,
+    signTransaction,
+    signTypedData,
+    source,
+    type,
+  } as never
+}
+
+export declare namespace from {
+  type AccountParameter = PartialBy<
+    Pick<Account, 'address' | 'keys' | 'sign'>,
+    'sign'
+  >
+
+  type Parameters<
+    account extends Address.Address | AccountParameter =
+      | Address.Address
+      | AccountParameter,
+  > = account | Address.Address | AccountParameter
+
+  type ReturnType<
+    account extends Address.Address | AccountParameter =
+      | Address.Address
+      | AccountParameter,
+  > = Readonly<
+    Assign<
+      Account,
+      account extends AccountParameter ? account : { address: account }
+    > & {
+      source: account extends { sign: NonNullable<LocalAccount['sign']> }
+        ? 'privateKey'
+        : 'porto'
+    }
+  >
+}
+
+/**
+ * Instantiates a delegated account from a private key.
+ *
+ * @param privateKey - Private key.
+ * @param options - Options.
+ * @returns An instantiated delegated account.
+ */
+export function fromPrivateKey<
+  const options extends fromPrivateKey.Options = fromPrivateKey.Options,
+>(
+  privateKey: Hex.Hex,
+  options: options | fromPrivateKey.Options = {},
+): Compute<fromPrivateKey.ReturnType<options>> {
+  const { keys } = options
+  const address = Address.fromPublicKey(Secp256k1.getPublicKey({ privateKey }))
+  return from({
+    address,
+    keys,
+    async sign({ hash }) {
+      return Signature.toHex(
+        Secp256k1.sign({
+          payload: hash,
+          privateKey,
+        }),
+      )
+    },
+    source: 'privateKey',
+  }) as fromPrivateKey.ReturnType<options>
+}
+
+export declare namespace fromPrivateKey {
+  type Options = {
+    /**
+     * Keys to instantiate.
+     */
+    keys?: readonly Key.Key[] | undefined
+  }
+
+  type ReturnType<options extends Options = Options> = Readonly<
+    (Omit<Account, 'keys'> &
+      (options['keys'] extends readonly Key.Key[]
+        ? { keys: options['keys'] }
+        : { keys?: Account['keys'] })) & { source: 'privateKey' }
+  >
+}
+
+export function getKey(
+  account: Account,
+  parameters: getKey.Parameters = {},
+): Key.Key | undefined {
+  const { key, role } = parameters
+
+  if (key === null) return undefined
+
+  // Extract from `key` parameter.
+  if (typeof key === 'object') return key
+
+  // Extract from `account.keys` (with optional `key` index).
+  if (account.keys && account.keys.length > 0) {
+    if (typeof key === 'number') return account.keys[key]
+    return account.keys.find(
+      (key) => key.privateKey && (!role || key.role === role),
+    )
+  }
+
+  return undefined
+}
+
+export declare namespace getKey {
+  type Parameters = {
+    key?: number | Key.Key | null | undefined
+    role?: Key.Key['role'] | undefined
+  }
+}
+
+/**
+ * Extracts a signing key from a delegated account and signs a payload.
+ *
+ * @example
+ * TODO
+ *
+ * @param parameters - Parameters.
+ * @returns Signature.
+ */
+export async function sign(
+  account: Account,
+  parameters: sign.Parameters,
+): Promise<Compute<Hex.Hex>> {
+  const { storage, replaySafe = true, wrap = true, webAuthn } = parameters
+
+  const key = getKey(account, parameters)
+
+  const payload = (() => {
+    if (!replaySafe) return parameters.payload
+    return TypedData.getSignPayload({
+      domain: { verifyingContract: account.address },
+      message: {
+        digest: parameters.payload,
+      },
+      primaryType: 'ERC1271Sign',
+      types: {
+        ERC1271Sign: [{ name: 'digest', type: 'bytes32' }],
+      },
+    })
+  })()
+
+  const sign = (() => {
+    if (!key) {
+      if (account.source === 'privateKey') return account.sign
+      return undefined
+    }
+    return ({ hash }: { hash: Hex.Hex }) =>
+      Key.sign(key, {
+        address: null,
+        payload: hash,
+        storage,
+        webAuthn,
+        wrap,
+      })
+  })()
+
+  // If the account has no valid signing key, then we cannot sign the payload.
+  if (!sign) throw new Error('cannot find key to sign with.')
+
+  // Sign the payload.
+  return await sign({ hash: payload })
+}
+
+export declare namespace sign {
+  type Parameters = {
+    /**
+     * Key to sign the payloads with.
+     *
+     * - If number, the key at the index will be used.
+     * - If `Key.Key`, the provided key will be used.
+     * - If `null`, the account's root signing key will be used.
+     * - If not provided, a key will be extracted from the `account`.
+     */
+    key?: number | Key.Key | null | undefined
+    /**
+     * Payload to sign.
+     */
+    payload: Hex.Hex
+    /**
+     * Whether to use replay-safe signing.
+     * `false` if replay-safe signing is not needed (e.g. signing call bundles).
+     */
+    replaySafe?: boolean
+    /**
+     * Role to extract the key from the `account` for signing.
+     */
+    role?: Key.Key['role'] | undefined
+    /**
+     * Storage to use for keytype-specific caching (e.g. WebAuthn user verification).
+     */
+    storage?: Storage.Storage | undefined
+    /**
+     * Whether to wrap the signature with key metadata.
+     */
+    wrap?: boolean | undefined
+    /**
+     * WebAuthn helpers for non-browser environments (e.g., React Native passkeys).
+     */
+    webAuthn?:
+      | {
+          createFn?:
+            | WebAuthnP256.createCredential.Options['createFn']
+            | undefined
+          getFn?: WebAuthnP256.sign.Options['getFn'] | undefined
+        }
+      | undefined
+  }
+}

package/src/viem/AccountActions.test.ts

@@ -0,0 +1,3 @@
+import { describe } from 'vitest'
+
+describe.todo('verifyEmail')

package/src/viem/AccountActions.ts

@@ -0,0 +1,30 @@
+/**
+ * Porto Account Actions.
+ */
+
+import type { Client } from 'viem'
+import * as z from 'zod/mini'
+import * as RpcSchema from '../core/RpcSchema.js'
+import type * as RpcSchema_viem from './RpcSchema.js'
+
+export async function verifyEmail(
+  client: Client,
+  parameters: verifyEmail.Parameters,
+): Promise<verifyEmail.ReturnType> {
+  const method = 'account_verifyEmail' as const
+  type Method = typeof method
+  const response = await client.request<
+    Extract<RpcSchema_viem.Wallet[number], { Method: Method }>
+  >({
+    method,
+    params: [z.encode(RpcSchema.account_verifyEmail.Parameters, parameters)],
+  })
+
+  return z.decode(RpcSchema.account_verifyEmail.Response, response)
+}
+
+export declare namespace verifyEmail {
+  type Parameters = RpcSchema.account_verifyEmail.Parameters
+
+  type ReturnType = RpcSchema.account_verifyEmail.Response
+}

package/src/viem/CapabilitiesSchema.ts

@@ -0,0 +1,18 @@
+import type { ValueOf } from 'viem'
+import type * as Rpc from '../core/internal/schema/rpc.js'
+
+export type CapabilitiesSchema = {
+  connect: {
+    Request: Pick<Rpc.wallet_connect.Capabilities, 'grantPermissions'>
+    Response: Pick<Rpc.wallet_connect.ResponseCapabilities, 'permissions'>
+  }
+  getCapabilities: {
+    Response: ValueOf<Rpc.wallet_getCapabilities.Response>
+  }
+  sendCalls: {
+    Request: Pick<
+      Rpc.wallet_prepareCalls.Capabilities,
+      'feeToken' | 'permissions' | 'merchantUrl'
+    >
+  }
+}