@alephium/ledger-app 0.2.0 → 0.3.0

package/docker/devnet.conf

@@ -0,0 +1,55 @@
+# Import this mnemonic to have 4'000'000 token allocated for your addresses
+#
+# vault alarm sad mass witness property virus style good flower rice alpha viable evidence run glare pretty scout evil judge enroll refuse another lava
+
+alephium.genesis.allocations = [
+  {
+    address = "1DrDyTr9RpRsQnDnXo2YRiPzPW4ooHX5LLoqXrqfMrpQH",
+    amount = 1000000000000000000000000,
+    lock-duration = 0 seconds
+  },
+  {
+    address = "14UAjZ3qcmEVKdTo84Kwf4RprTQi86w2TefnnGFjov9xF",
+    amount = 1000000000000000000000000,
+    lock-duration = 0 seconds
+  },
+  {
+    address = "15jjExDyS8q3Wqk9v29PCQ21jDqubDrD8WQdgn6VW2oi4",
+    amount = 1000000000000000000000000,
+    lock-duration = 0 seconds
+  },
+  {
+    address = "17cBiTcWhung3WDLuc9ja5Y7BMus5Q7CD9wYBxS1r1P2R",
+    amount = 1000000000000000000000000,
+    lock-duration = 0 seconds
+  }
+]
+alephium.consensus.num-zeros-at-least-in-hash = 0
+alephium.consensus.mainnet.block-target-time = 10 millis
+alephium.consensus.mainnet.uncle-dependency-gap-time = 0 seconds
+alephium.consensus.rhone.block-target-time = 5 millis
+alephium.consensus.rhone.uncle-dependency-gap-time = 0 seconds
+alephium.network.leman-hard-fork-timestamp = 0
+alephium.network.rhone-hard-fork-timestamp = 0
+
+alephium.network.network-id = 4
+alephium.discovery.bootstrap = []
+alephium.wallet.locking-timeout = 99999 minutes
+alephium.mempool.auto-mine-for-dev = true
+alephium.node.event-log.enabled=true
+alephium.node.event-log.index-by-tx-id = true
+alephium.node.event-log.index-by-block-hash = true
+
+alephium.network.rest-port = 22973
+alephium.network.ws-port = 21973
+alephium.network.miner-api-port = 20973
+alephium.api.network-interface = "0.0.0.0"
+alephium.api.api-key-enabled = false
+
+# arbitrary mining addresses
+alephium.mining.miner-addresses = [
+"1FsroWmeJPBhcPiUr37pWXdojRBe6jdey9uukEXk1TheA",
+"1CQvSXsmM5BMFKguKDPpNUfw1idiut8UifLtT8748JdHc",
+"193maApeJWrz9GFwWCfa982ccLARVE9Y1WgKSJaUs7UAx",
+"16fZKYPCZJv2TP3FArA9FLUQceTS9U8xVnSjxFG9MBKyY"
+]

package/docker/docker-compose.yaml

@@ -0,0 +1,22 @@
+version: "3.3"
+
+services:
+  alephium:
+    image: alephium/alephium:v3.3.0
+    restart: "no"
+    ports:
+      - 19973:19973/tcp
+      - 19973:19973/udp
+      - 127.0.0.1:20973:20973
+      - 127.0.0.1:21973:21973
+      - 127.0.0.1:22973:22973
+    security_opt:
+      - no-new-privileges:true
+    volumes:
+      - ./devnet.conf:/alephium-home/.alephium/user.conf
+      # - ~/.alephium:/alephium-home/.alephium
+    environment:
+      ALEPHIUM_FILE_LOG_LEVEL: "DEBUG"
+    healthcheck:
+      test: ["CMD", "curl", "http://127.0.0.1:22973/infos/self-clique"]
+      timeout: 45s

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/ledger-app",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "license": "GPL",
   "types": "dist/src/index.d.ts",
   "exports": {
@@ -25,19 +25,19 @@
     "trailingComma": "none"
   },
   "dependencies": {
-    "@alephium/cli": "0.10.2",
-    "@alephium/web3": "0.10.2",
-    "@alephium/web3-test": "0.10.2",
-    "@alephium/web3-wallet": "0.10.2",
-    "@ledgerhq/hw-transport": "6.27.10"
+    "@alephium/web3": "^1.2.0",
+    "@alephium/web3-wallet": "^1.2.0",
+    "@ledgerhq/hw-transport": "^6.31.0"
   },
   "devDependencies": {
-    "@ledgerhq/hw-transport-node-hid": "^6.27.9",
-    "@ledgerhq/hw-transport-node-speculos": "^6.27.9",
+    "@alephium/web3-test": "^1.2.0",
+    "@alephium/cli": "^1.2.0",
+    "@ledgerhq/hw-transport-node-hid": "^6.29.1",
+    "@ledgerhq/hw-transport-node-speculos": "^6.29.0",
     "@ledgerhq/logs": "^6.10.1",
     "@types/elliptic": "^6.4.13",
     "@types/jest": "^27.5.1",
-    "@types/node": "^16.7.8",
+    "@types/node": "^20.8.10",
     "@typescript-eslint/eslint-plugin": "^4.30.0",
     "@typescript-eslint/parser": "^4.30.0",
     "eslint": "^7.32.0",

package/src/index.ts

@@ -9,7 +9,7 @@ export const CLA = 0x80
 export enum INS {
   GET_VERSION = 0x00,
   GET_PUBLIC_KEY = 0x01,
-  SIGN_HASH = 0x02
+  SIGN_TX = 0x02
 }
 
 export const GROUP_NUM = 4
@@ -53,22 +53,37 @@ export default class AlephiumApp {
     return [{ publicKey: publicKey, address: address, group: group, keyType: keyType ?? 'default' }, hdIndex] as const
   }
 
-  async signHash(path: string, hash: Buffer): Promise<string> {
-    if (hash.length !== HASH_LEN) {
-      throw new Error('Invalid hash length')
+  async signUnsignedTx(path: string, unsignedTx: Buffer): Promise<string> {
+    console.log(`unsigned tx size: ${unsignedTx.length}`)
+    const encodedPath = serde.serializePath(path)
+    const firstFrameTxLength = 256 - 25;
+    const txData = unsignedTx.slice(0, unsignedTx.length > firstFrameTxLength ? firstFrameTxLength : unsignedTx.length)
+    const data = Buffer.concat([encodedPath, txData])
+    let response = await this.transport.send(CLA, INS.SIGN_TX, 0x00, 0x00, data, [StatusCodes.OK])
+    if (unsignedTx.length <= firstFrameTxLength) {
+      return decodeSignature(response)
     }
 
-    const data = Buffer.concat([serde.serializePath(path), hash])
-    console.log(`data ${data.length}`)
-    const response = await this.transport.send(CLA, INS.SIGN_HASH, 0x00, 0x00, data, [StatusCodes.OK])
-    console.log(`response ${response.length} - ${response.toString('hex')}`)
+    const frameLength = 256 - 5
+    let fromIndex = firstFrameTxLength
+    while (fromIndex < unsignedTx.length) {
+      const remain = unsignedTx.length - fromIndex
+      const toIndex = remain > frameLength ? (fromIndex + frameLength) : unsignedTx.length
+      const data = unsignedTx.slice(fromIndex, toIndex)
+      response = await this.transport.send(CLA, INS.SIGN_TX, 0x01, 0x00, data, [StatusCodes.OK])
+      fromIndex = toIndex
+    }
 
-    // Decode signature: https://bitcoin.stackexchange.com/a/12556
-    const rLen = response.slice(3, 4)[0]
-    const r = response.slice(4, 4 + rLen)
-    const sLen = response.slice(5 + rLen, 6 + rLen)[0]
-    const s = response.slice(6 + rLen, 6 + rLen + sLen)
-    console.log(`${rLen} - ${r.toString('hex')}\n${sLen} - ${s.toString('hex')}`)
-    return encodeHexSignature(r.toString('hex'), s.toString('hex'))
+    return decodeSignature(response)
   }
 }
+
+function decodeSignature(response: Buffer): string {
+  // Decode signature: https://bitcoin.stackexchange.com/a/12556
+  const rLen = response.slice(3, 4)[0]
+  const r = response.slice(4, 4 + rLen)
+  const sLen = response.slice(5 + rLen, 6 + rLen)[0]
+  const s = response.slice(6 + rLen, 6 + rLen + sLen)
+  console.log(`${rLen} - ${r.toString('hex')}\n${sLen} - ${s.toString('hex')}`)
+  return encodeHexSignature(r.toString('hex'), s.toString('hex'))
+}

package/test/release.test.ts

@@ -1,28 +1,152 @@
 import NodeTransport from '@ledgerhq/hw-transport-node-hid'
 import { listen } from '@ledgerhq/logs'
-import blake from 'blakejs'
 
-import { transactionVerifySignature } from '@alephium/web3'
+import { ALPH_TOKEN_ID, Address, NodeProvider, ONE_ALPH, transactionVerifySignature, web3, waitForTxConfirmation } from '@alephium/web3'
 
 import AlephiumApp from '../src'
+import { getSigner, mintToken, transfer } from '@alephium/web3-test'
+import { PrivateKeyWallet } from '@alephium/web3-wallet'
 
 describe.skip('Integration', () => {
   const path = `m/44'/1234'/0'/0/0`
+  const nodeProvider = new NodeProvider("http://127.0.0.1:22973")
+  web3.setCurrentNodeProvider(nodeProvider)
+
+  function randomP2PKHAddress(groupIndex: number): string {
+    return PrivateKeyWallet.Random(groupIndex, nodeProvider).address
+  }
+
+  async function getALPHBalance(address: Address) {
+    const balances = await nodeProvider.addresses.getAddressesAddressBalance(address)
+    return BigInt(balances.balance)
+  }
+
+  async function transferToTestAccount(address: Address) {
+    const fromAccount = await getSigner()
+    const transferResult = await transfer(fromAccount, address, ALPH_TOKEN_ID, ONE_ALPH * 10n)
+    await waitForTxConfirmation(transferResult.txId, 1, 1000)
+  }
 
   // enable this for integration test
-  it('should test node', async () => {
+  it('should transfer ALPH', async () => {
+    const transport = await NodeTransport.open('')
+    listen((log) => console.log(log))
+    const app = new AlephiumApp(transport)
+    const [testAccount] = await app.getAccount(path)
+    await transferToTestAccount(testAccount.address)
+
+    const balance0 = await getALPHBalance(testAccount.address)
+    const buildTxResult = await nodeProvider.transactions.postTransactionsBuild({
+      fromPublicKey: testAccount.publicKey,
+      destinations: [
+        {
+          address: randomP2PKHAddress(0),
+          attoAlphAmount: (ONE_ALPH * 2n).toString(),
+        },
+        {
+          address: randomP2PKHAddress(0),
+          attoAlphAmount: (ONE_ALPH * 3n).toString(),
+        },
+      ]
+    })
+
+    const signature = await app.signUnsignedTx(path, Buffer.from(buildTxResult.unsignedTx, 'hex'))
+    expect(transactionVerifySignature(buildTxResult.txId, testAccount.publicKey, signature)).toBe(true)
+
+    const submitResult = await nodeProvider.transactions.postTransactionsSubmit({
+      unsignedTx: buildTxResult.unsignedTx,
+      signature: signature
+    })
+    await waitForTxConfirmation(submitResult.txId, 1, 1000)
+    const balance1 = await getALPHBalance(testAccount.address)
+    const gasFee = BigInt(buildTxResult.gasAmount) * BigInt(buildTxResult.gasPrice)
+    expect(balance1).toEqual(balance0 - gasFee - ONE_ALPH * 5n)
+
+    await app.close()
+  }, 120000)
+
+  it('should transfer token', async () => {
+    const transport = await NodeTransport.open('')
+    listen((log) => console.log(log))
+    const app = new AlephiumApp(transport)
+    const [testAccount] = await app.getAccount(path)
+    await transferToTestAccount(testAccount.address)
+
+    const tokenAmount = 2222222222222222222222222n
+    const tokenInfo = await mintToken(testAccount.address, tokenAmount)
+    const balances0 = await nodeProvider.addresses.getAddressesAddressBalance(testAccount.address)
+
+    const transferAmount = 2222222222222222222222222n / 2n
+    const buildTxResult = await nodeProvider.transactions.postTransactionsBuild({
+      fromPublicKey: testAccount.publicKey,
+      destinations: [
+        {
+          address: '1BmVCLrjttchZMW7i6df7mTdCKzHpy38bgDbVL1GqV6P7',
+          attoAlphAmount: (ONE_ALPH * 2n).toString(),
+          tokens: [{ id: tokenInfo.contractId, amount: transferAmount.toString() }]
+        }
+      ]
+    })
+
+    const signature = await app.signUnsignedTx(path, Buffer.from(buildTxResult.unsignedTx, 'hex'))
+    expect(transactionVerifySignature(buildTxResult.txId, testAccount.publicKey, signature)).toBe(true)
+
+    const submitResult = await nodeProvider.transactions.postTransactionsSubmit({
+      unsignedTx: buildTxResult.unsignedTx,
+      signature: signature
+    })
+    await waitForTxConfirmation(submitResult.txId, 1, 1000)
+    const balances1 = await nodeProvider.addresses.getAddressesAddressBalance(testAccount.address)
+    const gasFee = BigInt(buildTxResult.gasAmount) * BigInt(buildTxResult.gasPrice)
+    const alphBalance = BigInt(balances1.balance)
+    expect(alphBalance).toEqual(BigInt(balances0.balance) - gasFee - ONE_ALPH * 2n)
+
+    const tokenBalance = balances1.tokenBalances!.find((t) => t.id === tokenInfo.contractId)!
+    expect(tokenBalance.amount).toEqual((tokenAmount - transferAmount).toString())
+
+    await app.close()
+  }, 120000)
+
+  it('should transfer to multisig address', async () => {
     const transport = await NodeTransport.open('')
     listen((log) => console.log(log))
     const app = new AlephiumApp(transport)
+    const [testAccount] = await app.getAccount(path)
+    await transferToTestAccount(testAccount.address)
+
+    const tokenAmount = 2222222222222222222222222n
+    const tokenInfo = await mintToken(testAccount.address, tokenAmount)
+    const balances0 = await nodeProvider.addresses.getAddressesAddressBalance(testAccount.address)
+
+    const transferAmount = 2222222222222222222222222n / 2n
+    const multiSigAddress = 'X3KYVteDjsKuUP1F68Nv9iEUecnnkMuwjbC985AnA6MvciDFJ5bAUEso2Sd7sGrwZ5rfNLj7Rp4n9XjcyzDiZsrPxfhNkPYcDm3ce8pQ9QasNFByEufMi3QJ3cS9Vk6cTpqNcq';
+    const buildTxResult = await nodeProvider.transactions.postTransactionsBuild({
+      fromPublicKey: testAccount.publicKey,
+      destinations: [
+        {
+          address: multiSigAddress,
+          attoAlphAmount: (ONE_ALPH * 2n).toString(),
+          tokens: [{ id: tokenInfo.contractId, amount: transferAmount.toString() }]
+        }
+      ]
+    })
+
+    const signature = await app.signUnsignedTx(path, Buffer.from(buildTxResult.unsignedTx, 'hex'))
+    expect(transactionVerifySignature(buildTxResult.txId, testAccount.publicKey, signature)).toBe(true)
 
-    const [account] = await app.getAccount(path)
-    console.log(`${JSON.stringify(account)}`)
+    const submitResult = await nodeProvider.transactions.postTransactionsSubmit({
+      unsignedTx: buildTxResult.unsignedTx,
+      signature: signature
+    })
+    await waitForTxConfirmation(submitResult.txId, 1, 1000)
+    const balances1 = await nodeProvider.addresses.getAddressesAddressBalance(testAccount.address)
+    const gasFee = BigInt(buildTxResult.gasAmount) * BigInt(buildTxResult.gasPrice)
+    const alphBalance = BigInt(balances1.balance)
+    expect(alphBalance).toEqual(BigInt(balances0.balance) - gasFee - ONE_ALPH * 2n)
 
-    const hash = Buffer.from(blake.blake2b(Buffer.from([0, 1, 2, 3, 4]), undefined, 32))
-    const signature = await app.signHash(path, hash)
-    console.log(signature)
-    expect(transactionVerifySignature(hash.toString('hex'), account.publicKey, signature)).toBe(true)
+    const tokenBalance = balances1.tokenBalances!.find((t) => t.id === tokenInfo.contractId)!
+    expect(tokenBalance.amount).toEqual((tokenAmount - transferAmount).toString())
 
     await app.close()
-  }, 100000)
+  }, 120000)
 })