Extract pool and txplan transformer to shelley tx planner

app/frontend/actions.ts

@@ -30,9 +30,7 @@ import {State, Ada, Lovelace, GetStateFn, SetStateFn} from './state'
 import CryptoProviderFactory from './wallet/byron/crypto-provider-factory'
 import ShelleyCryptoProviderFactory from './wallet/shelley/shelley-crypto-provider-factory'
 import {parseUnsignedTx} from './helpers/parser.tsx'
-import {buf2hex} from './wallet/shelley/helpers/chainlib-wrapper.ts'
-import {TxPlan} from './wallet/shelley/shelley-transaction-planner.ts'
-import bech32 from './wallet/shelley/helpers/bech32.ts'
+import {TxPlan, unsignedPoolTxToTxPlan} from './wallet/shelley/shelley-transaction-planner.ts'
 
 import {ShelleyWallet} from './wallet/shelley-wallet'
 // import loadWasmModule from './helpers/wasmLoader'
@@ -1170,105 +1168,6 @@ export default ({setState, getState}: {setState: SetStateFn; getState: GetStateF
     return parsedTx
   }
 
-  // TODO: kamil extract
-  const transformPoolParamsTypes = (
-    {
-      type,
-      poolKeyHashHex,
-      vrfKeyHashHex,
-      pledgeStr,
-      costStr,
-      margin,
-      rewardAccountKeyHash,
-      poolOwners,
-      relays,
-      metadata,
-    },
-    ownerCredentials
-  ) => ({
-    poolKeyHashHex: buf2hex(poolKeyHashHex),
-    vrfKeyHashHex: buf2hex(vrfKeyHashHex),
-    pledgeStr: pledgeStr.toString(),
-    costStr: costStr.toString(),
-    margin: {
-      numeratorStr: margin.value[0].toString(),
-      denominatorStr: margin.value[1].toString(),
-    },
-    rewardAccountKeyHash: buf2hex(rewardAccountKeyHash),
-    poolOwners: poolOwners.map((owner) => {
-      const ownerHash = buf2hex(owner)
-      if (ownerHash === ownerCredentials.pubKeyHex) {
-        return {
-          stakingPath: ownerCredentials.path,
-          pubKeyHex: ownerCredentials.pubKeyHex, // retain key hex for inverse operation
-        }
-      }
-      return {stakingKeyHashHex: ownerHash}
-    }),
-    relays: relays.map((relay) => {
-      let params
-      switch (relay[0]) {
-        case 0:
-          params = {
-            portNumber: relay[1],
-            ipv4Hex: relay[2] ? buf2hex(relay[2]) : null,
-            ipv6Hex: relay[3] ? buf2hex(relay[3]) : null,
-          }
-          break
-        case 1:
-          params = {
-            portNumber: relay[1],
-            dnsName: relay[2],
-          }
-          break
-        case 2:
-          params = {
-            dnsName: relay[1],
-          }
-          break
-        default:
-          throw NamedError('PoolRegInvalidRelay')
-      }
-      return {
-        type: relay[0],
-        params,
-      }
-    }),
-    metadata: {
-      metadataUrl: metadata.length ? metadata[0] : null,
-      metadataHashHex: metadata.length ? buf2hex(metadata[1]) : null,
-    },
-  })
-
-  // TODO: kamil extract
-  const unsignedPoolTxToTxPlan = async (unsignedTx): Promise<TxPlan> => {
-    const ownerCredentials = await wallet.getPoolOwnerCredentials()
-    return {
-      inputs: unsignedTx.inputs.map((input) => ({
-        outputIndex: input.outputIndex,
-        txHash: buf2hex(input.txHash),
-        address: null,
-        coins: null,
-        // path
-      })),
-      outputs: unsignedTx.outputs.map((output) => ({
-        coins: output.coins,
-        address: bech32.encode({prefix: 'addr', data: output.address}),
-        accountAddress: null,
-      })),
-      change: null,
-      certs: unsignedTx.certificates.map((cert) => ({
-        type: cert.type,
-        accountAddress: null,
-        poolHash: null,
-        poolRegistrationParams: transformPoolParamsTypes(cert, ownerCredentials),
-      })),
-      deposit: null,
-      fee: parseInt(unsignedTx.fee, 10),
-      withdrawals: unsignedTx.withdrawals,
-    }
-  }
-
   const loadPoolCertificateTx = async (state, fileObj) => {
     try {
       loadingAction(state, 'Loading pool registration certificate...', {
@@ -1330,8 +1229,10 @@ export default ({setState, getState}: {setState: SetStateFn; getState: GetStateF
     loadingAction(state, `Waiting for ${state.hwWalletName}...`)
     try {
       const deserializedTx = state.poolCertTxVars.deserializedTx
-      const poolTxPlan = await unsignedPoolTxToTxPlan(deserializedTx)
+      const ownerCredentials = await wallet.getPoolOwnerCredentials()
+      const poolTxPlan: TxPlan = unsignedPoolTxToTxPlan(deserializedTx, ownerCredentials)
       console.log('PLAN', poolTxPlan)
+      // @ts-ignore (Fix byron-shelley formats later)
       const txAux = await wallet.prepareTxAux(poolTxPlan, parseInt(deserializedTx.ttl, 10))
       console.log('TXAUX', txAux)
       const signature = await wallet.signTxAux(txAux)

app/frontend/wallet/shelley/shelley-transaction-planner.ts

@@ -10,6 +10,7 @@ import {Lovelace} from '../../state'
 import getDonationAddress from '../../helpers/getDonationAddress'
 import {base58} from 'cardano-crypto.js'
 import {isShelleyFormat, isV1Address} from './helpers/addresses'
+import {buf2hex} from './helpers/chainlib-wrapper.ts'
 
 export function txFeeFunction(txSizeInBytes: number): Lovelace {
   const a = 155381
@@ -312,3 +313,99 @@ export function selectMinimalTxPlan(
     error: {code: 'OutputTooSmall'},
   }
 }
+
+const transformPoolParamsTypes = (
+  {
+    type,
+    poolKeyHashHex,
+    vrfKeyHashHex,
+    pledgeStr,
+    costStr,
+    margin,
+    rewardAccountKeyHash,
+    poolOwners,
+    relays,
+    metadata,
+  },
+  ownerCredentials
+) => ({
+  poolKeyHashHex: buf2hex(poolKeyHashHex),
+  vrfKeyHashHex: buf2hex(vrfKeyHashHex),
+  pledgeStr: pledgeStr.toString(),
+  costStr: costStr.toString(),
+  margin: {
+    numeratorStr: margin.value[0].toString(),
+    denominatorStr: margin.value[1].toString(),
+  },
+  rewardAccountKeyHash: buf2hex(rewardAccountKeyHash),
+  poolOwners: poolOwners.map((owner) => {
+    const ownerHash = buf2hex(owner)
+    if (ownerHash === ownerCredentials.pubKeyHex) {
+      return {
+        stakingPath: ownerCredentials.path,
+        pubKeyHex: ownerCredentials.pubKeyHex, // retain key hex for inverse operation
+      }
+    }
+    return {stakingKeyHashHex: ownerHash}
+  }),
+  relays: relays.map((relay) => {
+    let params
+    switch (relay[0]) {
+      case 0:
+        params = {
+          portNumber: relay[1],
+          ipv4Hex: relay[2] ? buf2hex(relay[2]) : null,
+          ipv6Hex: relay[3] ? buf2hex(relay[3]) : null,
+        }
+        break
+      case 1:
+        params = {
+          portNumber: relay[1],
+          dnsName: relay[2],
+        }
+        break
+      case 2:
+        params = {
+          dnsName: relay[1],
+        }
+        break
+      default:
+        throw NamedError('PoolRegInvalidRelay')
+    }
+    return {
+      type: relay[0],
+      params,
+    }
+  }),
+  metadata: {
+    metadataUrl: metadata.length ? metadata[0] : null,
+    metadataHashHex: metadata.length ? buf2hex(metadata[1]) : null,
+  },
+})
+
+export const unsignedPoolTxToTxPlan = (unsignedTx, ownerCredentials): TxPlan => {
+  return {
+    inputs: unsignedTx.inputs.map((input) => ({
+      outputIndex: input.outputIndex,
+      txHash: buf2hex(input.txHash),
+      address: null,
+      coins: null,
+      // path
+    })),
+    outputs: unsignedTx.outputs.map((output) => ({
+      coins: output.coins,
+      address: bech32.encode({prefix: 'addr', data: output.address}),
+      accountAddress: null,
+    })),
+    change: null,
+    certs: unsignedTx.certificates.map((cert) => ({
+      type: cert.type,
+      accountAddress: null,
+      poolHash: null,
+      poolRegistrationParams: transformPoolParamsTypes(cert, ownerCredentials),
+    })),
+    deposit: null,
+    fee: parseInt(unsignedTx.fee, 10) as Lovelace,
+    withdrawals: unsignedTx.withdrawals,
+  }
+}