@alephium/web3 0.0.3 → 0.1.0-rc.2

package/src/utils/password-crypto.ts

@@ -0,0 +1,77 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { Buffer } from 'buffer/'
+import { randomBytes, createCipheriv, createDecipheriv, pbkdf2Sync, CipherKey, BinaryLike } from 'crypto'
+
+const saltByteLength = 64
+const ivByteLength = 64
+const authTagLength = 16
+
+export const encrypt = (password: string, dataRaw: string): string => {
+  const data = Buffer.from(dataRaw, 'utf8')
+
+  const salt = randomBytes(saltByteLength)
+  const derivedKey = keyFromPassword(password, salt)
+  const iv = randomBytes(ivByteLength)
+  const cipher = createCipher(derivedKey, iv)
+  const encrypted = Buffer.concat([cipher.update(data), cipher.final()])
+  const authTag = cipher.getAuthTag()
+  const payload = {
+    salt: salt.toString('hex'),
+    iv: iv.toString('hex'),
+    encrypted: Buffer.concat([encrypted, authTag]).toString('hex'),
+    version: 1
+  }
+
+  return JSON.stringify(payload)
+}
+
+export const decrypt = (password: string, payloadRaw: string): string => {
+  const payload = JSON.parse(payloadRaw)
+
+  const version = payload.version
+  if (version !== 1) {
+    throw new Error(`Invalid version: got ${version}, expected: 1`)
+  }
+
+  const salt = Buffer.from(payload.salt, 'hex')
+  const iv = Buffer.from(payload.iv, 'hex')
+  const encrypted = Buffer.from(payload.encrypted, 'hex')
+
+  const derivedKey = keyFromPassword(password, salt)
+  const decipher = createDecipher(derivedKey, iv)
+  const data = encrypted.slice(0, encrypted.length - authTagLength)
+  const authTag = encrypted.slice(encrypted.length - authTagLength, encrypted.length)
+  decipher.setAuthTag(authTag)
+  const decrypted = Buffer.concat([decipher.update(data), decipher.final()])
+
+  return decrypted.toString('utf8')
+}
+
+const createCipher = (key: CipherKey, iv: BinaryLike | null) => {
+  return createCipheriv('aes-256-gcm', key, iv)
+}
+
+const createDecipher = (key: CipherKey, iv: BinaryLike | null) => {
+  return createDecipheriv('aes-256-gcm', key, iv)
+}
+
+const keyFromPassword = (password: BinaryLike, salt: BinaryLike) => {
+  return pbkdf2Sync(password, salt, 10000, 32, 'sha256')
+}

package/src/utils/transaction.test.ts

@@ -0,0 +1,50 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import EC from 'elliptic'
+import assert from 'assert'
+
+import { transactionSign, transactionVerifySignature } from './transaction'
+
+describe('transaction', function () {
+  it('should verify signature', () => {
+    const txHash = '8fc5f0d120b730f97f6cea5f02ae4a6ee7bf451d9261c623ea69d85e870201d2'
+    const pubKey = '02625b26ae1c5f7986475009e4037b3e6fe6320fde3c3f3332bea11ecadc35dd13'
+    const txSig =
+      '78471e7c97e558c98ac307ef699ed535ece319102fc69ea416dbb44fbb3cbf9c42dbfbf4ce73eb68c5e0d66122eb25d2ebe1cf9e37ef4c4f4e7a2ed35de141bc'
+    const unnormalizedSig =
+      '78471e7c97e558c98ac307ef699ed535ece319102fc69ea416dbb44fbb3cbf9cbd24040b318c14973a1f299edd14da2bcecd0d48775953ec71582fb97254ff85'
+    const wrongSig =
+      '88471e7c97e558c98ac307ef699ed535ece319102fc69ea416dbb44fbb3cbf9c42dbfbf4ce73eb68c5e0d66122eb25d2ebe1cf9e37ef4c4f4e7a2ed35de141bc'
+
+    assert.strictEqual(transactionVerifySignature(txHash, pubKey, txSig), true)
+    assert.strictEqual(transactionVerifySignature(txHash, pubKey, unnormalizedSig), false)
+    assert.strictEqual(transactionVerifySignature(txHash, pubKey, wrongSig), false)
+  })
+
+  it('should sign and verify signature', () => {
+    const ec = new EC.ec('secp256k1')
+    const key = ec.genKeyPair()
+    const privateKey = key.getPrivate().toString('hex')
+    const publicKey = key.getPublic().encode('hex', true)
+
+    const txHash = '8fc5f0d120b730f97f6cea5f02ae4a6ee7bf451d9261c623ea69d85e870201d2'
+    const signature = transactionSign(txHash, privateKey)
+    assert.strictEqual(transactionVerifySignature(txHash, publicKey, signature), true)
+  })
+})

package/src/utils/transaction.ts

@@ -0,0 +1,39 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { ec as EC } from 'elliptic'
+
+import * as utils from './utils'
+
+const ec = new EC('secp256k1')
+
+export function transactionSign(txHash: string, privateKey: string): string {
+  const keyPair = ec.keyFromPrivate(privateKey)
+  const signature = keyPair.sign(txHash)
+
+  return utils.signatureEncode(signature)
+}
+
+export function transactionVerifySignature(txHash: string, publicKey: string, signature: string): boolean {
+  try {
+    const key = ec.keyFromPublic(publicKey, 'hex')
+    return key.verify(txHash, utils.signatureDecode(ec, signature))
+  } catch (error) {
+    return false
+  }
+}

package/src/utils/utils.test.ts

@@ -0,0 +1,160 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import EC from 'elliptic'
+import assert from 'assert'
+
+import * as utils from './utils'
+
+describe('utils', function () {
+  it('should throw an error when decoding invalid signature', () => {
+    const ec = new EC.ec('secp256k1')
+    const signature = 'signature-with-wrong-length'
+
+    expect(() => utils.signatureDecode(ec, signature)).toThrowError('Invalid signature length')
+  })
+
+  it('should compress signature', () => {
+    const vectors = [
+      [
+        'Satoshi Nakamoto',
+        '0000000000000000000000000000000000000000000000000000000000000001',
+        '934b1ea10a4b3c1757e2b0c017d0b6143ce3c9a7e6a4a49860d7a6ab210ee3d82442ce9d2b916064108014783e923ec36b49743e2ffa1c4496f01a512aafd9e5'
+      ],
+      [
+        'Everything should be made as simple as possible, but not simpler.',
+        '0000000000000000000000000000000000000000000000000000000000000001',
+        '33a69cd2065432a30f3d1ce4eb0d59b8ab58c74f27c41a7fdb5696ad4e6108c96f807982866f785d3f6418d24163ddae117b7db4d5fdf0071de069fa54342262'
+      ],
+      [
+        'All those moments will be lost in time, like tears in rain. Time to die...',
+        '0000000000000000000000000000000000000000000000000000000000000001',
+        '8600dbd41e348fe5c9465ab92d23e3db8b98b873beecd930736488696438cb6b547fe64427496db33bf66019dacbf0039c04199abb0122918601db38a72cfc21'
+      ],
+      [
+        'Satoshi Nakamoto',
+        'fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140',
+        'fd567d121db66e382991534ada77a6bd3106f0a1098c231e47993447cd6af2d06b39cd0eb1bc8603e159ef5c20a5c8ad685a45b06ce9bebed3f153d10d93bed5'
+      ],
+      [
+        'Alan Turing',
+        'f8b8af8ce3c7cca5e300d33939540c10d45ce001b8f252bfbc57ba0342904181',
+        '7063ae83e7f62bbb171798131b4a0564b956930092b33b07b395615d9ec7e15c58dfcc1e00a35e1572f366ffe34ba0fc47db1e7189759b9fb233c5b05ab388ea'
+      ],
+      [
+        "There is a computer disease that anybody who works with computers knows about. It's a very serious disease and it interferes completely with the work. The trouble with computers is that you 'play' with them!",
+        'e91671c46231f833a6406ccbea0e3e392c76c167bac1cb013f6f1013980455c2',
+        'b552edd27580141f3b2a5463048cb7cd3e047b97c9f98076c32dbdf85a68718b279fa72dd19bfae05577e06c7c0c1900c371fcd5893f7e1d56a37d30174671f6'
+      ]
+    ]
+
+    const ec = new EC.ec('secp256k1')
+
+    vectors.forEach((vector) => {
+      const privateKey = vector[1]
+      const signatureExpected = vector[2]
+      const keyPair = ec.keyFromPrivate(privateKey)
+
+      const message = vector[0]
+      const sha256 = ec.hash().update(message).digest()
+      const signature = utils.signatureEncode(keyPair.sign(sha256))
+      assert.deepStrictEqual(signature, signatureExpected)
+    })
+  })
+
+  it('should calculate the group of addresses', () => {
+    expect(utils.groupOfAddress('15EM5rGtt7dPRZScE4Z9oL2EDfj84JnoSgq3NNgdcGFyu')).toBe(0),
+      expect(utils.groupOfAddress('1D59jXR9NpD9ZQqZTRVcVbKVh6ko5TUMt89WvkA8P9P7w')).toBe(1),
+      expect(utils.groupOfAddress('14tAT3nm7UqVP7gZ35icSdT3AEffv1kaUUMbWQK5PFygr')).toBe(2),
+      expect(utils.groupOfAddress('12F5aVQoQ7cNrgsVN2YPciwYvwmtJp4ohLa2x4R5KgLbG')).toBe(3),
+      expect(
+        utils.groupOfAddress(
+          '2jW1n2icPtc55Cdm8TF9FjGH681cWthsaZW3gaUFekFZepJoeyY3ZbY7y5SCtAjyCjLL24c4L2Vnfv3KDdAypCddfAY'
+        )
+      ).toBe(0),
+      expect(
+        utils.groupOfAddress(
+          '2jXboVD9p66wrAHkPHx2AQocAzYXUWeppmRT3PuVT3ccxX9u8puTnwLeQ2VbTd4sNkgSEgk1cLbyVGLFshGweJCk1Mr'
+        )
+      ).toBe(1),
+      expect(
+        utils.groupOfAddress(
+          '2je1yvQHpg8bKCDmvr1koELSNbty5DHrHYRkXomiRNvP5VcsZTK3WisBco2sCtCULM2YbxRxPd7QwhdP2hz9PEQwB1S'
+        )
+      ).toBe(2),
+      expect(
+        utils.groupOfAddress(
+          '2jWukVCejM4Zifz9LvMG4dfR6SEecHLX8VqbswhGwnu61d28B861UhLu3ZmTHu4N14m1kk9rbxreBYzcxta1WPawKzG'
+        )
+      ).toBe(3),
+      expect(utils.groupOfAddress('eBrjfQNeyUCuxE4zpbfMZcbS3PuvbMJDQBCyk4HRHtX4')).toBe(0),
+      expect(utils.groupOfAddress('euWxyF55nGTxavL6mgGeMrFdvSRzHor8AmhgPXm8Lm9D')).toBe(1),
+      expect(utils.groupOfAddress('n2pYTzmA27tkp7UNFPhMJpjz3jr5vgessxqJ7kwomBMF')).toBe(2),
+      expect(utils.groupOfAddress('tLf6hDfrUugmxZhKxGoZMpAUBt3NcZ2hrTspTCmZ6JdQ')).toBe(3)
+  })
+
+  it('should extract token id from addresses', () => {
+    expect(utils.binToHex(utils.tokenIdFromAddress('wCTeteGBeSEC54GpkS8jWBzYiYNTBUuTW3WzxGd9yExT'))).toBe(
+      '25469eb0d0d0a55deea832924547b7b166c70a3554fe321e81886d3c18f19d64'
+    ),
+      expect(utils.binToHex(utils.tokenIdFromAddress('xrY8dxgVm38QCQXhiUFcivFutLFUNMoo8qu8vYf7wJps'))).toBe(
+        '3de370f893cb1383c828c0eb22c89aceb13fa56ddced1848db27ce7fa419c80c'
+      ),
+      expect(() => utils.tokenIdFromAddress('eBrjfQNeyUCuxE4zpbfMZcbS3PuvbMJDQBCyk4HRHtX4')).toThrow(
+        'Invalid contract address type: 2'
+      ),
+      expect(() => utils.tokenIdFromAddress('..')).toThrow('Non-base58 character')
+  })
+
+  it('should compute public key from private key', () => {
+    expect(utils.publicKeyFromPrivateKey('91411e484289ec7e8b3058697f53f9b26fa7305158b4ef1a81adfbabcf090e45')).toBe(
+      '030f9f042a9410969f1886f85fa20f6e43176ae23fc5e64db15b3767c84c5db2dc'
+    )
+  })
+
+  it('should compute address from public key', () => {
+    expect(utils.publicKeyFromPrivateKey('91411e484289ec7e8b3058697f53f9b26fa7305158b4ef1a81adfbabcf090e45')).toBe(
+      '030f9f042a9410969f1886f85fa20f6e43176ae23fc5e64db15b3767c84c5db2dc'
+    )
+    expect(utils.addressFromPublicKey('030f9f042a9410969f1886f85fa20f6e43176ae23fc5e64db15b3767c84c5db2dc')).toBe(
+      '1ACCkgFfmTif46T3qK12znuWjb5Bk9jXpqaeWt2DXx8oc'
+    )
+  })
+
+  it('should convert between contract id and address', () => {
+    expect(utils.addressFromContractId('1f6b937b935d7fac894fb22ffe2b974cae9c8c166501372f1b9155144e0ff4ae')).toBe(
+      'vobthYg1e9tPKhmF96rpkv3akCj7vhvgPpsP4qwZqDw3'
+    )
+    expect(utils.binToHex(utils.contractIdFromAddress('vobthYg1e9tPKhmF96rpkv3akCj7vhvgPpsP4qwZqDw3'))).toBe(
+      '1f6b937b935d7fac894fb22ffe2b974cae9c8c166501372f1b9155144e0ff4ae'
+    )
+  })
+
+  it('should compute id of the sub contract', () => {
+    expect(
+      utils.subContractId(
+        '0a38bc48fbb4300f1e305b201cd6129372d867122efb814d871d18c0bfe43b56',
+        '4f51cd1f0af97cf5ec9c7a3397eaeea549d55a93c216e54f2ab4a8cf29f6f865'
+      )
+    ).toBe('293c948c81c5a9495178fff8b8c9f29f4f3e09e1728c40e9253c87adf5e18770')
+  })
+
+  it('should convert from string to hex', () => {
+    expect(utils.stringToHex('Hello Alephium!')).toBe('48656c6c6f20416c65706869756d21')
+  })
+})

package/src/utils/utils.ts

@@ -0,0 +1,209 @@
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with the library. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import { ec as EC, SignatureInput } from 'elliptic'
+import BN from 'bn.js'
+import blake from 'blakejs'
+import bs58 from './bs58'
+import { Buffer } from 'buffer/'
+
+import { TOTAL_NUMBER_OF_GROUPS } from '../constants'
+import djb2 from './djb2'
+import * as node from '../api/api-alephium'
+import * as explorer from '../api/api-explorer'
+
+const ec = new EC('secp256k1')
+
+export function convertHttpResponse<T>(
+  response: node.HttpResponse<T, { detail: string }> | explorer.HttpResponse<T, { detail: string }>
+): T {
+  if (response.error) {
+    throw new Error(response.error.detail)
+  } else {
+    return response.data
+  }
+}
+
+export function signatureEncode(signature: EC.Signature): string {
+  let sNormalized = signature.s
+  if (ec.n && signature.s.cmp(ec.nh) === 1) {
+    sNormalized = ec.n.sub(signature.s)
+  }
+
+  const r = signature.r.toString('hex', 66).slice(2)
+  const s = sNormalized.toString('hex', 66).slice(2)
+  return r + s
+}
+
+// the signature should be in hex string format for 64 bytes
+export const signatureDecode = (ec: EC, signature: string): SignatureInput => {
+  if (signature.length !== 128) {
+    throw new Error('Invalid signature length')
+  }
+
+  const sHex = signature.slice(64, 128)
+  const s = new BN(sHex, 'hex')
+  if (ec.n && s.cmp(ec.nh) < 1) {
+    const decoded = { r: signature.slice(0, 64), s: sHex }
+    return decoded
+  } else {
+    throw new Error('The signature is not normalized')
+  }
+}
+
+const xorByte = (intValue: number) => {
+  const byte0 = (intValue >> 24) & 0xff
+  const byte1 = (intValue >> 16) & 0xff
+  const byte2 = (intValue >> 8) & 0xff
+  const byte3 = intValue & 0xff
+  return (byte0 ^ byte1 ^ byte2 ^ byte3) & 0xff
+}
+
+export function isHexString(input: string): boolean {
+  return input.length % 2 === 0 && /[0-9a-f]*$/.test(input)
+}
+
+enum AddressType {
+  P2PKH = 0x00,
+  P2MPKH = 0x01,
+  P2SH = 0x02,
+  P2C = 0x03
+}
+
+export const groupOfAddress = (address: string): number => {
+  const decoded = bs58.decode(address)
+
+  if (decoded.length == 0) throw new Error('Address string is empty')
+  const addressType = decoded[0]
+  const addressBody = decoded.slice(1)
+
+  if (addressType == AddressType.P2PKH) {
+    return groupOfP2pkhAddress(addressBody)
+  } else if (addressType == AddressType.P2MPKH) {
+    return groupOfP2mpkhAddress(addressBody)
+  } else if (addressType == AddressType.P2SH) {
+    return groupOfP2shAddress(addressBody)
+  } else {
+    throw new Error(`Invalid asset address type: ${addressType}`)
+  }
+}
+
+const groupOfAddressBytes = (bytes: Uint8Array): number => {
+  const hint = djb2(bytes) | 1
+  const hash = xorByte(hint)
+  const group = hash % TOTAL_NUMBER_OF_GROUPS
+  return group
+}
+
+// Pay to public key hash address
+const groupOfP2pkhAddress = (address: Uint8Array): number => {
+  if (address.length != 32) {
+    throw new Error(`Invalid p2pkh address length: ${address.length}`)
+  }
+
+  return groupOfAddressBytes(address)
+}
+
+// Pay to multiple public key hash address
+const groupOfP2mpkhAddress = (address: Uint8Array): number => {
+  if ((address.length - 2) % 32 != 0) {
+    throw new Error(`Invalid p2mpkh address length: ${address.length}`)
+  }
+
+  return groupOfAddressBytes(address.slice(1, 33))
+}
+
+// Pay to script hash address
+const groupOfP2shAddress = (address: Uint8Array): number => {
+  return groupOfAddressBytes(address)
+}
+
+export function contractIdFromAddress(address: string): Uint8Array {
+  return idFromAddress(address)
+}
+
+export function tokenIdFromAddress(address: string): Uint8Array {
+  return idFromAddress(address)
+}
+
+function idFromAddress(address: string): Uint8Array {
+  const decoded = bs58.decode(address)
+
+  if (decoded.length == 0) throw new Error('Address string is empty')
+  const addressType = decoded[0]
+  const addressBody = decoded.slice(1)
+
+  if (addressType == AddressType.P2C) {
+    return addressBody
+  } else {
+    throw new Error(`Invalid contract address type: ${addressType}`)
+  }
+}
+
+export function hexToBinUnsafe(hex: string): Uint8Array {
+  return Buffer.from(hex, 'hex')
+}
+
+export function binToHex(bin: Uint8Array): string {
+  return Buffer.from(bin).toString('hex')
+}
+
+export function publicKeyFromPrivateKey(privateKey: string): string {
+  const key = ec.keyFromPrivate(privateKey)
+  return key.getPublic(true, 'hex')
+}
+
+export function addressFromPublicKey(publicKey: string): string {
+  const addressType = Buffer.from([AddressType.P2PKH])
+  const hash = Buffer.from(blake.blake2b(Buffer.from(publicKey, 'hex'), undefined, 32))
+  const bytes = Buffer.concat([addressType, hash])
+  return bs58.encode(bytes)
+}
+
+export function addressFromContractId(contractId: string): string {
+  const addressType = Buffer.from([AddressType.P2C])
+  const hash = Buffer.from(hexToBinUnsafe(contractId))
+  const bytes = Buffer.concat([addressType, hash])
+  return bs58.encode(bytes)
+}
+
+export function contractIdFromTx(txId: string, outputIndex: number): string {
+  const txIdBin = hexToBinUnsafe(txId)
+  const data = Buffer.concat([txIdBin, Buffer.from([outputIndex])])
+  const hash = blake.blake2b(data, undefined, 32)
+  return binToHex(hash)
+}
+
+export function subContractId(parentContractId: string, pathInHex: string): string {
+  const data = Buffer.concat([hexToBinUnsafe(pathInHex), hexToBinUnsafe(parentContractId)])
+
+  return binToHex(blake.blake2b(blake.blake2b(data, undefined, 32), undefined, 32))
+}
+
+export function stringToHex(str: string): string {
+  let hex = ''
+  for (let i = 0; i < str.length; i++) {
+    hex += '' + str.charCodeAt(i).toString(16)
+  }
+  return hex
+}
+
+type _Eq<X, Y> = (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2 ? true : false
+export type Eq<X, Y> = _Eq<{ [P in keyof X]: X[P] }, { [P in keyof Y]: Y[P] }>
+// eslint-disable-next-line @typescript-eslint/no-empty-function, @typescript-eslint/no-unused-vars
+export function assertType<T extends true>(): void {}

package/templates/{README.md → base/README.md}

@@ -11,20 +11,20 @@ npm install
 Compile the TypeScript files into JavaScript:
 
 ```
-npm run compile
+npm run build
 ```
 
 ## Start a devnet
 
 ```
-npm run devnet:start // this will start a devnet for smart contract tests
+npm run start-devnet // this will start a devnet for smart contract tests
 ```
 
 ## Stop/restart devnet
 
 ```
-npm run devnet:stop
-npm run devnet:restart
+npm run stop-devnet
+npm run restart-devnet
 ```
 
 ## Testing

package/templates/base/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "my-dapp-template",
+  "version": "0.1.0",
+  "license": "GPL",
+  "config": {
+    "alephium_version": "1.4.0-rc2"
+  },
+  "scripts": {
+    "build": "rm -rf dist && npx tsc --build .",
+    "start-devnet": "node scripts/start-devnet.js ${npm_package_config_alephium_version}",
+    "restart-devnet": "npm run start-devnet",
+    "stop-devnet": "node scripts/stop-devnet.js"
+  },
+  "dependencies": {
+    "@alephium/web3": "0.1.0-rc.2"
+  },
+  "devDependencies": {
+    "@types/elliptic": "^6.4.13",
+    "@types/node": "^16.7.8",
+    "typescript": "^4.4.2"
+  },
+  "engines": {
+    "node": ">=14.0.0",
+    "npm": ">=7.0.0"
+  },
+  "prettier": {
+    "printWidth": 120,
+    "tabWidth": 2,
+    "useTabs": false,
+    "semi": false,
+    "singleQuote": true,
+    "bracketSameLine": false,
+    "trailingComma": "none"
+  }
+}

package/templates/base/src/greeter.ts

@@ -0,0 +1,41 @@
+/*
+ * greeter.ts
+ */
+
+import { NodeProvider, Contract, Script, TestContractParams } from '@alephium/web3'
+import { testWallet } from '@alephium/web3/test'
+
+async function greet() {
+  const provider = new NodeProvider('http://127.0.0.1:22973')
+
+  const greeter = await Contract.fromSource(provider, 'greeter.ral')
+
+  const testParams: TestContractParams = {
+    initialFields: { btcPrice: 1 }
+  }
+  const testResult = await greeter.testPublicMethod(provider, 'greet', testParams)
+  console.log(testResult)
+
+  const signer = await testWallet(provider)
+
+  const deployTx = await greeter.transactionForDeployment(signer, { initialFields: testParams.initialFields })
+  const greeterContractId = deployTx.contractId
+  console.log(deployTx.fromGroup)
+  console.log(deployTx.toGroup)
+
+  const submitResult = await signer.submitTransaction(deployTx.unsignedTx, deployTx.txId)
+  console.log(submitResult)
+
+  const main = await Script.fromSource(provider, 'greeter_main.ral')
+
+  const mainScriptTx = await main.transactionForDeployment(signer, {
+    initialFields: { greeterContractId: greeterContractId }
+  })
+  console.log(mainScriptTx.fromGroup)
+  console.log(mainScriptTx.toGroup)
+
+  const mainSubmitResult = await signer.submitTransaction(mainScriptTx.unsignedTx, mainScriptTx.txId)
+  console.log(mainSubmitResult)
+}
+
+greet()

package/templates/base/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "outDir": "dist/",
+    "baseUrl": ".",
+    "module": "commonjs",
+    "target": "ES2015",
+    "lib": ["dom", "es2016"],
+    "declaration": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "inlineSourceMap": true,
+    "inlineSources": true,
+    "declarationMap": true,
+    "noFallthroughCasesInSwitch": true,
+    "strictFunctionTypes": true,
+    "esModuleInterop": true
+  },
+  "exclude": ["node_modules", "templates"]
+}