Migrations work with v3 wallet

Author: ScreamingHawk

packages/utils/migration/src/index.ts

@@ -1,2 +1,2 @@
 export * as migration from './migrations/index.js'
-export * as migrator from './migrator.js'
+export * from './types.js'

packages/utils/migration/src/migrations/index.ts

@@ -1,8 +1,10 @@
+import { State } from '@0xsequence/wallet-core'
+import { Payload } from '@0xsequence/wallet-primitives'
 import { Address, Hex } from 'ox'
-import { UnsignedMigration, VersionedContext } from '../migrator.js'
-import { Migration_v1v3 } from './v1/migration_v1_v3.js'
+import { UnsignedMigration, VersionedContext } from '../types.js'
+import { MigrationEncoder_v1v3 } from './v1/migration_v1_v3.js'
 
-export interface Migration<FromConfigType, ToConfigType, ConvertOptionsType> {
+export interface MigrationEncoder<FromConfigType, ToConfigType, ConvertOptionsType, PrepareOptionsType> {
   fromVersion: number
   toVersion: number
 
@@ -19,20 +21,32 @@ export interface Migration<FromConfigType, ToConfigType, ConvertOptionsType> {
    * @param walletAddress The wallet address to prepare the migration for
    * @param contexts The contexts to prepare the migration for
    * @param toConfig The configuration to prepare the migration for
-   * @returns The prepared migration
+   * @param options The prepare options
+   * @returns The migration payload to be signed
    */
   prepareMigration: (
     walletAddress: Address.Address,
     contexts: VersionedContext,
     toConfig: ToConfigType,
+    options: PrepareOptionsType,
   ) => Promise<UnsignedMigration>
 
   /**
-   * Decodes the transactions from a migration
-   * @param transactions The transactions to decode
-   * @returns The decoded address and resulting image hash for the migration transactions
+   * Encodes the a transaction for a given migration
+   * @param migration The migration to encode the transaction for
+   * @returns The encoded transaction
    */
-  decodeTransactions: (transactions: UnsignedMigration['transactions']) => Promise<{
+  toTransactionData: (migration: State.Migration) => Promise<{
+    to: Address.Address
+    data: Hex.Hex
+  }>
+
+  /**
+   * Decodes the payload from a migration
+   * @param payload The payload to decode
+   * @returns The decoded address and resulting image hash for the migration payload
+   */
+  decodePayload: (payload: Payload.Calls) => Promise<{
     address: Address.Address
     toImageHash: Hex.Hex
   }>
@@ -45,4 +59,15 @@ export interface Migrator<FromWallet, ToWallet, ConvertOptionsType> {
   convertWallet: (fromWallet: FromWallet, options: ConvertOptionsType) => Promise<ToWallet>
 }
 
-export const v1v3 = new Migration_v1v3()
+export const encoders: MigrationEncoder<any, any, any, any>[] = [new MigrationEncoder_v1v3()]
+
+export function getMigrationEncoder<FromConfigType, ToConfigType, ConvertOptionsType, PrepareOptionsType>(
+  fromVersion: number,
+  toVersion: number,
+): MigrationEncoder<FromConfigType, ToConfigType, ConvertOptionsType, PrepareOptionsType> {
+  const encoder = encoders.find((encoder) => encoder.fromVersion === fromVersion && encoder.toVersion === toVersion)
+  if (!encoder) {
+    throw new Error(`Unsupported from version: ${fromVersion} to version: ${toVersion}`)
+  }
+  return encoder
+}

packages/utils/migration/src/migrations/v1/migration_v1_v3.ts

@@ -1,9 +1,14 @@
 import { v1, commons as v2commons } from '@0xsequence/v2core'
-import { WalletV1 } from '@0xsequence/v2wallet'
-import { Config as V3Config, Context as V3Context, Extensions as V3Extensions } from '@0xsequence/wallet-primitives'
+import { State } from '@0xsequence/wallet-core'
+import {
+  Payload,
+  Config as V3Config,
+  Context as V3Context,
+  Extensions as V3Extensions,
+} from '@0xsequence/wallet-primitives'
 import { AbiFunction, Address, Hex } from 'ox'
-import { SignedMigration, UnsignedMigration, VersionedContext } from '../../migrator.js'
-import { Migration } from '../index.js'
+import { UnsignedMigration, VersionedContext } from '../../types.js'
+import { MigrationEncoder } from '../index.js'
 import { createDefaultV3Topology } from '../v3/config.js'
 
 // uint160(keccak256("org.sequence.sdk.migration.v1v3.space.nonce"))
@@ -17,25 +22,31 @@ export type ConvertOptions = {
   extensions?: V3Extensions.Extensions
 }
 
-export class Migration_v1v3 implements Migration<v1.config.WalletConfig, V3Config.Config, ConvertOptions> {
+export type PrepareOptions = {
+  space?: bigint
+}
+
+export class MigrationEncoder_v1v3
+  implements MigrationEncoder<v1.config.WalletConfig, V3Config.Config, ConvertOptions, PrepareOptions>
+{
   fromVersion = 1
   toVersion = 3
 
-  async convertConfig(v1Config: v1.config.WalletConfig, options: ConvertOptions): Promise<V3Config.Config> {
-    const signerLeaves: V3Config.SignerLeaf[] = v1Config.signers.map((signer) => ({
+  async convertConfig(fromConfig: v1.config.WalletConfig, options: ConvertOptions): Promise<V3Config.Config> {
+    const signerLeaves: V3Config.SignerLeaf[] = fromConfig.signers.map((signer) => ({
       type: 'signer',
       address: Address.from(signer.address),
       weight: BigInt(signer.weight),
     }))
     const v1NestedTopology = V3Config.flatLeavesToTopology(signerLeaves)
-    const v3Config: V3Config.Config = {
+    return {
       threshold: 1n,
       checkpoint: 0n,
       topology: [
         {
           type: 'nested',
           weight: 1n,
-          threshold: BigInt(v1Config.threshold),
+          threshold: BigInt(fromConfig.threshold),
           tree: v1NestedTopology,
         },
         {
@@ -46,80 +57,101 @@ export class Migration_v1v3 implements Migration<v1.config.WalletConfig, V3Confi
         },
       ],
     }
-    return v3Config
   }
 
   async prepareMigration(
     walletAddress: Address.Address,
     contexts: VersionedContext,
     toConfig: V3Config.Config,
+    options: PrepareOptions,
   ): Promise<UnsignedMigration> {
     const v3Context = contexts[3] || V3Context.Rc3
     if (!V3Context.isContext(v3Context)) {
       throw new Error('Invalid context')
     }
 
-    const nonce = v2commons.transaction.encodeNonce(MIGRATION_V1_V3_NONCE_SPACE, 0)
+    const space = options?.space ?? BigInt(MIGRATION_V1_V3_NONCE_SPACE)
+    const nonce = 0n // Nonce must be unused
+    // const v2Nonce = v2commons.transaction.encodeNonce(space, nonce)
 
     // Update implementation to v3
     const updateImplementationAbi = AbiFunction.from('function updateImplementation(address implementation)')
-    const updateImplementationTx = {
+    const updateImplementationTx: Payload.Call = {
       to: walletAddress,
       data: AbiFunction.encodeData(updateImplementationAbi, [v3Context.stage2]),
+      value: 0n,
+      gasLimit: 0n,
+      delegateCall: false,
+      onlyFallback: false,
+      behaviorOnError: 'revert',
     }
     // Update configuration to v3
-    const v3ImageHash = Hex.fromBytes(V3Config.hashConfiguration(toConfig))
+    const toImageHash = Hex.fromBytes(V3Config.hashConfiguration(toConfig))
     const updateImageHashAbi = AbiFunction.from('function updateImageHash(bytes32 imageHash)')
-    const updateImageHashTx = {
+    const updateImageHashTx: Payload.Call = {
       to: walletAddress,
-      data: AbiFunction.encodeData(updateImageHashAbi, [v3ImageHash]),
+      data: AbiFunction.encodeData(updateImageHashAbi, [toImageHash]),
+      value: 0n,
+      gasLimit: 0n,
+      delegateCall: false,
+      onlyFallback: false,
+      behaviorOnError: 'revert',
+    }
+
+    const payload: Payload.Calls = {
+      type: 'call',
+      space,
+      nonce,
+      calls: [updateImplementationTx, updateImageHashTx],
     }
 
     return {
-      transactions: [updateImplementationTx, updateImageHashTx],
+      payload,
       fromVersion: this.fromVersion,
       toVersion: this.toVersion,
-      nonce,
+      toConfig,
     }
   }
 
-  /**
-   * Signs a migration with a wallet
-   * @notice V1 Wallets must call this method for each chain they are migrating on
-   * @param migration The unsigned migration to sign
-   * @param wallet The wallet to sign the migration with
-   * @returns The signed migration
-   */
-  //FIXME Remove this function. Signing is not a responsibility of the migration class.
-  async signMigration(migration: UnsignedMigration, wallet: WalletV1): Promise<SignedMigration> {
-    const { address } = await this.decodeTransactions(migration.transactions)
-    if (address !== wallet.address) {
-      throw new Error('Wallet address does not match migration address')
+  async toTransactionData(migration: State.Migration): Promise<{ to: Address.Address; data: Hex.Hex }> {
+    const { payload, signature, chainId } = migration
+    const walletAddress = payload.calls[0]!.to
+    const v2Nonce = v2commons.transaction.encodeNonce(payload.space, payload.nonce)
+    const transactions = payload.calls.map((tx) => ({
+      to: tx.to,
+      data: tx.data,
+      gasLimit: tx.gasLimit,
+      revertOnError: tx.behaviorOnError === 'revert',
+    }))
+    const digest = v2commons.transaction.digestOfTransactions(v2Nonce, transactions)
+    const txBundle: v2commons.transaction.SignedTransactionBundle = {
+      entrypoint: walletAddress,
+      transactions,
+      nonce: v2Nonce,
+      chainId,
+      signature,
+      intent: {
+        id: digest,
+        wallet: walletAddress,
+      },
     }
-    const txBundle: v2commons.transaction.TransactionBundle = {
-      entrypoint: wallet.address,
-      transactions: migration.transactions.map((tx) => ({
-        to: tx.to,
-        data: tx.data,
-        gasLimit: 0n,
-        revertOnError: true,
-      })),
-      nonce: migration.nonce,
+    const encodedData = v2commons.transaction.encodeBundleExecData(txBundle)
+    Hex.assert(encodedData)
+    return {
+      to: walletAddress,
+      data: encodedData,
     }
-    const { signature } = await wallet.signTransactionBundle(txBundle)
-    Hex.assert(signature)
-    return { ...migration, signature }
   }
 
-  async decodeTransactions(transactions: UnsignedMigration['transactions']): Promise<{
+  async decodePayload(payload: Payload.Calls): Promise<{
     address: Address.Address
     toImageHash: Hex.Hex
   }> {
-    if (transactions.length !== 2) {
-      throw new Error('Invalid transactions')
+    if (payload.calls.length !== 2) {
+      throw new Error('Invalid calls')
     }
-    const tx1 = transactions[0]!
-    const tx2 = transactions[1]!
+    const tx1 = payload.calls[0]!
+    const tx2 = payload.calls[1]!
     if (tx1.to !== tx2.to) {
       throw new Error('Invalid to address')
     }