wip: update

Author: walker27

packages/neuron-ui/src/components/PaymentChannel/api.ts

@@ -45,7 +45,7 @@ export async function getChannels(publicKey: string, address: string) {
     payload: {
       requester: getParticipantByAddressAndPubkey(address, publicKey),
     },
-  }) as ControllerResponse<{ channels: { actorIdxs: (0|1)[], states: any[] } }>
+  }) as ControllerResponse<{ channels: { actorIdxs: (0 | 1)[], states: any[] } }>
   if (!isSuccessResponse(actionRes)) {
     return []
   }
@@ -95,20 +95,35 @@ export async function getChannels(publicKey: string, address: string) {
   return channels;
 }
 
-export async function openChannel(publicKey: string, address: string, peerUser: PeerUser, payload: [TradePayload, TradePayload], challengeDuration: number) {
+export async function openChannel(publicKey: string, address: string, peerUser: PerunAPI.PeerUser, payload: [TradePayload, TradePayload], challengeDuration: number) {
   // open channel request will return after both peer user signed transaction
   return perunServiceAction({
     type: 'open',
+    // payload: {
+    //   me: getParticipantByAddressAndPubkey(address, publicKey),
+    //   peer: getParticipantByAddressAndPubkey(peerUser.address, peerUser.publicKey),
+    //   // todo move TradePayload process to main progress
+    //   balances: [
+    //     bytes.bytify(equalNumPaddedHex(BigInt(payload[0].amount * 1e8))),
+    //     bytes.bytify(equalNumPaddedHex(BigInt(payload[1].amount * 1e8))),
+    //   ],
+    //   challengeDuration: Number(challengeDuration),
+    // },
     payload: {
-      me: getParticipantByAddressAndPubkey(address, publicKey),
-      peer: getParticipantByAddressAndPubkey(peerUser.address, peerUser.publicKey),
-      // todo move TradePayload process to main progress
+      me: { publicKey, address },
+      peer: peerUser,
       balances: [
-        bytes.bytify(equalNumPaddedHex(BigInt(payload[0].amount * 1e8))),
-        bytes.bytify(equalNumPaddedHex(BigInt(payload[1].amount * 1e8))),
+        {
+          type: null,
+          balances: [
+            BigInt(payload[0].amount * 1e8).toString(),
+            BigInt(payload[1].amount * 1e8).toString(),
+          ]
+        },
+        // { type: null, balances: [1, 2] }, // udt
       ],
       challengeDuration: Number(challengeDuration),
-    },
+    }
   })
 }
 

packages/neuron-ui/src/types/Controller/index.d.ts

@@ -219,7 +219,7 @@ declare namespace Controller {
   type PerunServiceActionParams =
     | { type: "startup", payload: PerunChannelServiceRunnerStartupsParams }
     | { type: "shutdown" }
-    | { type: "open", payload: OpenChannelParams }
+    | { type: "open", payload: PerunAPI.OpenChannelParams }
     | { type: "update", payload: UpdateChannelParams }
     | { type: "close", payload: CloseChannelParams }
     | { type: "get", payload: GetChannelParams }

packages/neuron-wallet/src/controllers/perun.ts

@@ -15,14 +15,20 @@ import { bytes } from '@ckb-lumos/codec'
 import { Allocation, Balances } from '../utils/perun-wallet-wrapper/wire'
 // import PerunPersistorService from '../services/perun/persistor'
 // import PerunChannelEntity from '../database/chain/entities/perun-channel'
-import { mol } from "@ckb-ccc/core"
+import { ccc, mol } from "@ckb-ccc/core"
+import participant from 'src/services/perun/tools/participant'
 
 const defaultAddressEncoder: AddressEncoder = (add: Uint8Array | string) => {
   if (typeof add === 'string') {
     return bytes.bytify(add)
   }
   return add
 }
+const equalNumPaddedHex = (num: bigint) => {
+  const hex = num.toString(16)
+  const res = hex.length % 2 === 0 ? hex : `0${hex}`
+  return `0x${res}`
+}
 
 export default class PerunController {
   static emiter = new EventEmitter()
@@ -137,21 +143,34 @@ export default class PerunController {
     } as Controller.Response
   }
 
-  async openChannel(params: Controller.Params.OpenChannelParams): Promise<Controller.Response> {
+  async openChannel(params: PerunAPI.OpenChannelParams): Promise<Controller.Response> {
     logger.info('PerunController: openChannel----------')
+    const { me, peer, balances, challengeDuration } = params;
+    const meRequestId = await participant.encode(me.publicKey, me.address);
+    const peerRequestId = await participant.encode(peer.publicKey, peer.address);
+    const { assets, balances: iBalances } = balances.reduce((obj, item) => {
+      obj.assets.push(item.type ? ccc.Script.from(item.type).toBytes() : new Uint8Array(0))
+      obj.balances.push(
+        item.balances.map(balance => bytes.bytify(equalNumPaddedHex(BigInt(balance)))),
+      )
+      return obj;
+    }, { assets: [] as Uint8Array[], balances: [] as Uint8Array[][] })
     const alloc = Allocation.create({
-      assets: [new Uint8Array(1)],
+      assets: assets,
       balances: Balances.create({
-        balances: [
-          {
-            balance: params.balances,
-          },
-        ],
+        balances: iBalances.map(balance => ({
+          balance
+        }))
+        // balances: [
+        //   {
+        //     balance: params.balances,
+        //   },
+        // ],
       }),
     })
 
     const res = await PerunController.serviceClient
-      .openChannel(params.me, params.peer, alloc, params.challengeDuration, mol.Uint32.encode(123))
+      .openChannel(meRequestId, peerRequestId, alloc, challengeDuration, mol.Uint32.encode(123))
       .catch(e => {
         logger.info('PerunController: openChannel-----error-----', e)
         return {
@@ -169,8 +188,8 @@ export default class PerunController {
       }
     }
     const channelId = channelIdToString(new Uint8Array(res.channelId!))
-    logger.log('Controler Buffer channelId', res.channelId!)
-    logger.log('Controler channelID', channelId)
+    // logger.log('Controler Buffer channelId', res.channelId!)
+    // logger.log('Controler channelID', channelId)
     return {
       status: ResponseCode.Success,
       result: {

packages/neuron-wallet/src/services/perun/fetchCell.ts

@@ -9,9 +9,10 @@ const networkMap = {
 } as const
 
 const testnetService = new ccc.ClientPublicTestnet({ url: networkMap.testnet })
+const mainnetService = new ccc.ClientPublicMainnet({ url: networkMap.mainnet })
 
-export async function fetchTargetCell(txhash: string, outputIndex: number) {
-  const txResponse = await testnetService.getTransaction(txhash);
+export async function fetchTargetCell(network: "testnet" | "mainnet", txhash: string, outputIndex: number) {
+  const txResponse = await (network === "testnet" ? testnetService : mainnetService).getTransaction(txhash);
   const tx = txResponse?.transaction;
   if (!tx) {
     return null;

packages/neuron-wallet/src/services/perun/tools/parser.sign-transaction.ts

@@ -7,20 +7,22 @@ import Transaction from '../../../models/chain/transaction'
 // import RpcService from '../../../services/rpc-service'
 import NetworksService from '../../networks'
 import { fetchTargetCell } from '../fetchCell'
-import { ccc, ClientPublicTestnet, ScriptLike } from '@ckb-ccc/core'
-import { NetworkType } from '../../../models/network'
+import { ccc, ClientPublicMainnet, ClientPublicTestnet, ScriptLike } from '@ckb-ccc/core'
+// import { NetworkType } from '../../../models/network'
+import { LIGHT_CLIENT_TESTNET } from '../../../utils/const'
 
 export async function parseSignTransactionRequest(serializedRequest: Perun.SerializedMessage.SignTransactionRequest) {
 
   const network = NetworksService.getInstance().getCurrent()
-  const isLightClient = network.type === NetworkType.Light
+  // const isLightClient = network.type === NetworkType.Light
+  const isTestnet = network.chain === LIGHT_CLIENT_TESTNET
   // const rpcService = new RpcService(network.remote, network.type)
   console.log("network:", network);
 
   const scriptStr = new TextDecoder("utf-8").decode(Buffer.from(serializedRequest.identifier.data))
   const sdkScript = JSON.parse(scriptStr, snakeCaseToCamelCase) as ScriptLike;
   // todo
-  const address = ccc.Address.fromScript(sdkScript, new ClientPublicTestnet()).toString();
+  const address = ccc.Address.fromScript(sdkScript, isTestnet ? new ClientPublicTestnet() : new ClientPublicMainnet()).toString();
 
   const txStr = new TextDecoder("utf-8").decode(Buffer.from(serializedRequest.transaction.data));
   // TODO: The transaction here has unresolved inputs, which are only referenced by their outpoints.
@@ -32,7 +34,7 @@ export async function parseSignTransactionRequest(serializedRequest: Perun.Seria
   // logger.info('PerunServiceRunner received signTransactionRequest:sdkTx', sdkTx)
   // Fetch live cells from txs input-outpoints.
   let resolvedInputs = []
-  
+
   for (const [idx, input] of sdkTx.txView.inputs.entries()) {
     let typedInput = input as { previousOutput: { txHash: string; index: string }; since: string }
     // logger.info('Fetching live cell', input.previousOutput)
@@ -60,8 +62,8 @@ export async function parseSignTransactionRequest(serializedRequest: Perun.Seria
       //   : await rpcService.getTransaction(input.previousOutput.txHash)
       // const targetCell = rpcTx?.transaction?.outputs[Number(input.previousOutput.index)]
       // logger.info('RPC-TX:', rpcTx)
-      // todo testnet only for now
-      const targetCell = await fetchTargetCell(input.previousOutput.txHash, input.previousOutput.index);
+      // todo Full Node Use RPC Service
+      const targetCell = await fetchTargetCell(isTestnet ? "testnet" : "mainnet", input.previousOutput.txHash, input.previousOutput.index);
       // console.log("iCell", targetCell);
 
       if (targetCell) {

packages/neuron-wallet/src/types/controller.d.ts

@@ -77,10 +77,16 @@ declare namespace Controller {
       message: string
     }
     interface OpenChannelParams {
-      me: Uint8Array
-      peer: Uint8Array
-      balances: [Uint8Array, Uint8Array]
+      // me: Uint8Array
+      // peer: Uint8Array
+      // balances: [Uint8Array, Uint8Array]
       challengeDuration: number
+      me: { publicKey: string, address: string },
+      peer: { publicKey: string, address: string },
+      balances: Array<{
+        type: null | { codeHash: string, hashType: string, args: string }
+        balances: [string, string]
+      }>
     }
     interface UpdateChannelParams {
       channelId: string

types/perun.d.ts

@@ -252,4 +252,20 @@ declare namespace Perun {
 
   }
 
+}
+
+
+declare namespace PerunAPI {
+  type PeerUser = Perun.ReadableMessage.PeerUser;
+  type Script = { codeHash: string, hashType: string, args: string }
+
+  type OpenChannelParams = {
+    me: PeerUser,
+    peer: PeerUser,
+    balances: Array<{
+      type: null | Script
+      balances: [string, string]
+    }>
+    challengeDuration: number
+  }
 }