@alephium/web3 0.5.0-rc.1 → 0.5.0-rc.11

package/src/contract/contract.ts

@@ -848,38 +848,45 @@ export class Contract extends Artifact {
   }
 
   static ContractCreatedEventIndex = -1
-  static ContractCreatedEvent: EventSig = {
+  static ContractCreatedEvent: SystemEventSig = {
     name: 'ContractCreated',
     fieldNames: ['address'],
-    fieldTypes: ['Address']
+    fieldTypes: ['Address'],
+    optionalFieldNames: ['parentAddress'],
+    optionalFieldTypes: ['Address']
   }
 
   static ContractDestroyedEventIndex = -2
-  static ContractDestroyedEvent: EventSig = {
+  static ContractDestroyedEvent: SystemEventSig = {
     name: 'ContractDestroyed',
     fieldNames: ['address'],
     fieldTypes: ['Address']
   }
 
   static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined, txId: string): ContractEvent {
-    let eventSig: EventSig
+    let fields: Fields
+    let name: string
 
     if (event.eventIndex == Contract.ContractCreatedEventIndex) {
-      eventSig = this.ContractCreatedEvent
+      fields = fromApiSystemEventFields(event.fields, Contract.ContractCreatedEvent)
+      name = Contract.ContractCreatedEvent.name
     } else if (event.eventIndex == Contract.ContractDestroyedEventIndex) {
-      eventSig = this.ContractDestroyedEvent
+      fields = fromApiSystemEventFields(event.fields, Contract.ContractDestroyedEvent)
+      name = Contract.ContractDestroyedEvent.name
     } else {
       const contract = Project.currentProject.contractByCodeHash(codeHash!)
-      eventSig = contract.eventsSig[event.eventIndex]
+      const eventSig = contract.eventsSig[event.eventIndex]
+      fields = fromApiEventFields(event.fields, eventSig)
+      name = eventSig.name
     }
 
     return {
       txId: txId,
       blockHash: event.blockHash,
       contractAddress: event.contractAddress,
-      name: eventSig.name,
+      name: name,
       eventIndex: event.eventIndex,
-      fields: fromApiEventFields(event.fields, eventSig)
+      fields: fields
     }
   }
 
@@ -913,8 +920,10 @@ export class Contract extends Artifact {
     params: DeployContractParams<P>
   ): Promise<SignDeployContractTxParams> {
     const bytecode = this.buildByteCodeToDeploy(params.initialFields ?? {})
+    const selectedAccount = await signer.getSelectedAccount()
     const signerParams: SignDeployContractTxParams = {
-      signerAddress: await signer.getSelectedAddress(),
+      signerAddress: selectedAccount.address,
+      signerKeyType: selectedAccount.keyType,
       bytecode: bytecode,
       initialAttoAlphAmount: params?.initialAttoAlphAmount,
       issueTokenAmount: params?.issueTokenAmount,
@@ -1056,8 +1065,10 @@ export class Script extends Artifact {
     signer: SignerProvider,
     params: ExecuteScriptParams<P>
   ): Promise<SignExecuteScriptTxParams> {
+    const selectedAccount = await signer.getSelectedAccount()
     const signerParams: SignExecuteScriptTxParams = {
-      signerAddress: await signer.getSelectedAddress(),
+      signerAddress: selectedAccount.address,
+      signerKeyType: selectedAccount.keyType,
       bytecode: this.buildByteCodeToDeploy(params.initialFields ?? {}),
       attoAlphAmount: params.attoAlphAmount,
       tokens: params.tokens,
@@ -1095,6 +1106,16 @@ function fromApiEventFields(vals: node.Val[], eventSig: node.EventSig): Fields {
   return fromApiVals(vals, eventSig.fieldNames, eventSig.fieldTypes)
 }
 
+function fromApiSystemEventFields(vals: node.Val[], systemEventSig: SystemEventSig): Fields {
+  return fromApiVals(
+    vals,
+    systemEventSig.fieldNames,
+    systemEventSig.fieldTypes,
+    systemEventSig.optionalFieldNames ?? [],
+    systemEventSig.optionalFieldTypes ?? []
+  )
+}
+
 export interface Asset {
   alphAmount: Number256
   tokens?: Token[]
@@ -1272,7 +1293,7 @@ export interface DeployContractParams<P extends Fields = Fields> {
 assertType<
   Eq<
     Omit<DeployContractParams<undefined>, 'initialFields'>,
-    Omit<SignDeployContractTxParams, 'signerAddress' | 'bytecode'>
+    Omit<SignDeployContractTxParams, 'signerAddress' | 'signerKeyType' | 'bytecode'>
   >
 >
 export type DeployContractResult<T> = SignDeployContractTxResult & { instance: T }
@@ -1339,37 +1360,45 @@ export interface CallContractResult<R> {
   events: ContractEvent[]
 }
 
-export type ContractCreatedEvent = ContractEvent<{ address: HexString }>
-export type ContractDestroyedEvent = ContractEvent<{ address: HexString }>
+export interface SystemEventSig extends EventSig {
+  optionalFieldNames?: string[]
+  optionalFieldTypes?: string[]
+}
+
+export type ContractCreatedEvent = ContractEvent<{ address: Address; parentAddress?: Address }>
+export type ContractDestroyedEvent = ContractEvent<{ address: Address }>
 
-function decodeFields(event: node.ContractEvent, eventSig: EventSig, eventIndex: number): Fields {
+function decodeSystemEvent(event: node.ContractEvent, systemEventSig: SystemEventSig, eventIndex: number): Fields {
   if (event.eventIndex !== eventIndex) {
     throw new Error(`Invalid event index: ${event.eventIndex}, expected: ${eventIndex}`)
   }
-  return fromApiVals(event.fields, eventSig.fieldNames, eventSig.fieldTypes)
+  return fromApiSystemEventFields(event.fields, systemEventSig)
 }
 
 export function decodeContractCreatedEvent(event: node.ContractEvent): Omit<ContractCreatedEvent, 'contractAddress'> {
-  const fields = decodeFields(event, Contract.ContractCreatedEvent, Contract.ContractCreatedEventIndex)
+  const fields = decodeSystemEvent(event, Contract.ContractCreatedEvent, Contract.ContractCreatedEventIndex)
   return {
     blockHash: event.blockHash,
     txId: event.txId,
     eventIndex: event.eventIndex,
     name: Contract.ContractCreatedEvent.name,
-    fields: { address: fields['address'] as HexString }
+    fields: {
+      address: fields['address'] as Address,
+      parentAddress: fields['parentAddress'] === undefined ? undefined : (fields['parentAddress'] as Address)
+    }
   }
 }
 
 export function decodeContractDestroyedEvent(
   event: node.ContractEvent
 ): Omit<ContractDestroyedEvent, 'contractAddress'> {
-  const fields = decodeFields(event, Contract.ContractDestroyedEvent, Contract.ContractDestroyedEventIndex)
+  const fields = decodeSystemEvent(event, Contract.ContractDestroyedEvent, Contract.ContractDestroyedEventIndex)
   return {
     blockHash: event.blockHash,
     txId: event.txId,
     eventIndex: event.eventIndex,
     name: Contract.ContractDestroyedEvent.name,
-    fields: { address: fields['address'] as HexString }
+    fields: { address: fields['address'] as Address }
   }
 }
 

package/src/signer/signer.ts

@@ -16,7 +16,6 @@ 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 { ExplorerProvider, fromApiNumber256, fromApiTokens, NodeProvider, toApiNumber256, toApiTokens } from '../api'
 import { node } from '../api'
 import * as utils from '../utils'
@@ -39,57 +38,57 @@ import {
   SignUnsignedTxResult,
   SubmissionResult,
   SubmitTransactionParams,
-  ExtSignTransferTxParams,
-  ExtSignDeployContractTxParams,
-  ExtSignExecuteScriptTxParams,
-  ExtSignUnsignedTxParams,
-  ExtSignMessageParams
+  KeyType
 } from './types'
 import { TransactionBuilder } from './tx-builder'
+import { addressFromPublicKey, groupOfAddress } from '../utils'
 
-const ec = new EC('secp256k1')
+export abstract class SignerProvider {
+  abstract get nodeProvider(): NodeProvider | undefined
+  abstract get explorerProvider(): ExplorerProvider | undefined
 
-export interface SignerProvider {
-  get nodeProvider(): NodeProvider | undefined
-  get explorerProvider(): ExplorerProvider | undefined
+  protected abstract unsafeGetSelectedAccount(): Promise<Account>
+  async getSelectedAccount(): Promise<Account> {
+    const account = await this.unsafeGetSelectedAccount()
+    SignerProvider.validateAccount(account)
+    return account
+  }
 
-  getSelectedAddress(): Promise<Address>
+  static validateAccount(account: Account): void {
+    const derivedAddress = addressFromPublicKey(account.publicKey, account.keyType)
+    const derivedGroup = groupOfAddress(derivedAddress)
+    if (derivedAddress !== account.address || derivedGroup !== account.group) {
+      throw Error(`Invalid accounot data: ${JSON.stringify(account)}`)
+    }
+  }
 
-  signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>
-  signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>
-  signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>
-  signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
+  abstract signAndSubmitTransferTx(params: SignTransferTxParams): Promise<SignTransferTxResult>
+  abstract signAndSubmitDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult>
+  abstract signAndSubmitExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>
+  abstract signAndSubmitUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
 
-  signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
+  abstract signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult>
   // The message will be prefixed with 'Alephium Signed Message: ' before signing
   // so that the resulted signature cannot be reused for building transactions.
-  signMessage(params: SignMessageParams): Promise<SignMessageResult>
+  abstract signMessage(params: SignMessageParams): Promise<SignMessageResult>
 }
 
 // Abstraction for interactive signer (e.g. WalletConnect instance, Extension wallet object)
-export interface InteractiveSignerProvider<EnableOptions extends EnableOptionsBase = EnableOptionsBase>
-  extends SignerProvider {
-  enable(opt?: EnableOptions): Promise<Address>
-  disconnect(): Promise<void>
-
-  // Methods inherited from SignerProvider, but require networkId in the params
-  signAndSubmitTransferTx(params: ExtSignTransferTxParams): Promise<SignTransferTxResult>
-  signAndSubmitDeployContractTx(params: ExtSignDeployContractTxParams): Promise<SignDeployContractTxResult>
-  signAndSubmitExecuteScriptTx(params: ExtSignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult>
-  signAndSubmitUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>
-  signUnsignedTx(params: ExtSignUnsignedTxParams): Promise<SignUnsignedTxResult>
-  signMessage(params: ExtSignMessageParams): Promise<SignMessageResult>
-}
-
-export abstract class SignerProviderSimple extends TransactionBuilder implements SignerProvider {
-  abstract get explorerProvider(): ExplorerProvider | undefined
+export abstract class InteractiveSignerProvider<
+  EnableOptions extends EnableOptionsBase = EnableOptionsBase
+> extends SignerProvider {
+  protected abstract unsafeEnable(opt?: EnableOptions): Promise<Account>
+  async enable(opt?: EnableOptions): Promise<Account> {
+    const account = await this.unsafeEnable(opt)
+    SignerProvider.validateAccount(account)
+    return account
+  }
 
-  abstract getSelectedAccount(): Promise<Account>
+  abstract disconnect(): Promise<void>
+}
 
-  async getSelectedAddress(): Promise<Address> {
-    const account = await this.getSelectedAccount()
-    return account.address
-  }
+export abstract class SignerProviderSimple extends SignerProvider {
+  abstract override get nodeProvider(): NodeProvider
 
   async submitTransaction(params: SubmitTransactionParams): Promise<SubmissionResult> {
     const data: node.SubmitTransaction = { unsignedTx: params.unsignedTx, signature: params.signature }
@@ -133,8 +132,11 @@ export abstract class SignerProviderSimple extends TransactionBuilder implements
     return { signature, ...response }
   }
 
-  override async buildTransferTx(params: SignTransferTxParams): Promise<Omit<SignTransferTxResult, 'signature'>> {
-    return super.buildTransferTx(params, await this.getPublicKey(params.signerAddress))
+  async buildTransferTx(params: SignTransferTxParams): Promise<Omit<SignTransferTxResult, 'signature'>> {
+    return TransactionBuilder.from(this.nodeProvider).buildTransferTx(
+      params,
+      await this.getPublicKey(params.signerAddress)
+    )
   }
 
   async signDeployContractTx(params: SignDeployContractTxParams): Promise<SignDeployContractTxResult> {
@@ -143,10 +145,13 @@ export abstract class SignerProviderSimple extends TransactionBuilder implements
     return { signature, ...response }
   }
 
-  override async buildDeployContractTx(
+  async buildDeployContractTx(
     params: SignDeployContractTxParams
   ): Promise<Omit<SignDeployContractTxResult, 'signature'>> {
-    return super.buildDeployContractTx(params, await this.getPublicKey(params.signerAddress))
+    return TransactionBuilder.from(this.nodeProvider).buildDeployContractTx(
+      params,
+      await this.getPublicKey(params.signerAddress)
+    )
   }
 
   async signExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<SignExecuteScriptTxResult> {
@@ -155,16 +160,17 @@ export abstract class SignerProviderSimple extends TransactionBuilder implements
     return { signature, ...response }
   }
 
-  override async buildExecuteScriptTx(
-    params: SignExecuteScriptTxParams
-  ): Promise<Omit<SignExecuteScriptTxResult, 'signature'>> {
-    return super.buildExecuteScriptTx(params, await this.getPublicKey(params.signerAddress))
+  async buildExecuteScriptTx(params: SignExecuteScriptTxParams): Promise<Omit<SignExecuteScriptTxResult, 'signature'>> {
+    return TransactionBuilder.from(this.nodeProvider).buildExecuteScriptTx(
+      params,
+      await this.getPublicKey(params.signerAddress)
+    )
   }
 
   // in general, wallet should show the decoded information to user for confirmation
   // please overwrite this function for real wallet
   async signUnsignedTx(params: SignUnsignedTxParams): Promise<SignUnsignedTxResult> {
-    const response = await this.buildUnsignedTx(params)
+    const response = await TransactionBuilder.from(this.nodeProvider).buildUnsignedTx(params)
     const signature = await this.signRaw(params.signerAddress, response.txId)
     return { signature, ...response }
   }
@@ -180,7 +186,7 @@ export abstract class SignerProviderSimple extends TransactionBuilder implements
 }
 
 export abstract class SignerProviderWithMultipleAccounts extends SignerProviderSimple {
-  abstract setSelectedAddress(address: string): Promise<void>
+  abstract setSelectedAccount(address: string): Promise<void>
 
   abstract getAccounts(): Promise<Account[]>
 
@@ -204,7 +210,7 @@ export abstract class SignerProviderWithCachedAccounts<T extends Account> extend
   private _selectedAccount: T | undefined = undefined
   protected readonly _accounts = new Map<Address, T>()
 
-  getSelectedAccount(): Promise<T> {
+  protected unsafeGetSelectedAccount(): Promise<T> {
     if (this._selectedAccount === undefined) {
       throw Error('No account is selected yet')
     } else {
@@ -212,7 +218,7 @@ export abstract class SignerProviderWithCachedAccounts<T extends Account> extend
     }
   }
 
-  setSelectedAddress(address: string): Promise<void> {
+  setSelectedAccount(address: string): Promise<void> {
     const accountOpt = this._accounts.get(address)
     if (accountOpt === undefined) {
       throw Error('The address is not in the accounts')
@@ -236,23 +242,14 @@ export abstract class SignerProviderWithCachedAccounts<T extends Account> extend
   }
 }
 
-export function verifyHexString(hexString: string, publicKey: string, signature: string): boolean {
-  try {
-    const key = ec.keyFromPublic(publicKey, 'hex')
-    return key.verify(hexString, utils.signatureDecode(ec, signature))
-  } catch (error) {
-    return false
-  }
-}
-
 function extendMessage(message: string): string {
   return 'Alephium Signed Message: ' + message
 }
 
-export function verifySignedMessage(message: string, publicKey: string, signature: string): boolean {
+export function verifySignedMessage(message: string, publicKey: string, signature: string, keyType?: KeyType): boolean {
   const extendedMessage = extendMessage(message)
   const messageHash = blake.blake2b(extendedMessage, undefined, 32)
-  return verifyHexString(utils.binToHex(messageHash), publicKey, signature)
+  return utils.verifySignature(utils.binToHex(messageHash), publicKey, signature, keyType)
 }
 
 export function toApiDestination(data: Destination): node.Destination {

package/src/signer/tx-builder.ts

@@ -21,6 +21,7 @@ import { fromApiNumber256, node, NodeProvider, toApiNumber256Optional, toApiToke
 import { addressFromPublicKey } from '../utils'
 import { toApiDestinations } from './signer'
 import {
+  KeyType,
   SignDeployContractTxParams,
   SignDeployContractTxResult,
   SignerAddress,
@@ -35,8 +36,10 @@ import {
 export abstract class TransactionBuilder {
   abstract get nodeProvider(): NodeProvider
 
-  static create(baseUrl: string, apiKey?: string) {
-    const nodeProvider = new NodeProvider(baseUrl, apiKey)
+  static from(nodeProvider: NodeProvider): TransactionBuilder
+  static from(baseUrl: string, apiKey?: string): TransactionBuilder
+  static from(param0: string | NodeProvider, param1?: string): TransactionBuilder {
+    const nodeProvider = typeof param0 === 'string' ? new NodeProvider(param0, param1) : (param0 as NodeProvider)
     return new (class extends TransactionBuilder {
       get nodeProvider(): NodeProvider {
         return nodeProvider
@@ -44,8 +47,8 @@ export abstract class TransactionBuilder {
     })()
   }
 
-  private static validatePublicKey(params: SignerAddress, publicKey: string) {
-    const address = addressFromPublicKey(publicKey)
+  private static validatePublicKey(params: SignerAddress, publicKey: string, keyType?: KeyType) {
+    const address = addressFromPublicKey(publicKey, keyType)
     if (address !== params.signerAddress) {
       throw new Error('Unmatched public key')
     }
@@ -55,11 +58,12 @@ export abstract class TransactionBuilder {
     params: SignTransferTxParams,
     publicKey: string
   ): Promise<Omit<SignTransferTxResult, 'signature'>> {
-    TransactionBuilder.validatePublicKey(params, publicKey)
+    TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType)
 
     const { destinations, gasPrice, ...rest } = params
     const data: node.BuildTransaction = {
       fromPublicKey: publicKey,
+      fromPublicKeyType: params.signerKeyType,
       destinations: toApiDestinations(destinations),
       gasPrice: toApiNumber256Optional(gasPrice),
       ...rest
@@ -72,11 +76,12 @@ export abstract class TransactionBuilder {
     params: SignDeployContractTxParams,
     publicKey: string
   ): Promise<Omit<SignDeployContractTxResult, 'signature'>> {
-    TransactionBuilder.validatePublicKey(params, publicKey)
+    TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType)
 
     const { initialAttoAlphAmount, initialTokenAmounts, issueTokenAmount, gasPrice, ...rest } = params
     const data: node.BuildDeployContractTx = {
       fromPublicKey: publicKey,
+      fromPublicKeyType: params.signerKeyType,
       initialAttoAlphAmount: toApiNumber256Optional(initialAttoAlphAmount),
       initialTokenAmounts: toApiTokens(initialTokenAmounts),
       issueTokenAmount: toApiNumber256Optional(issueTokenAmount),
@@ -92,11 +97,12 @@ export abstract class TransactionBuilder {
     params: SignExecuteScriptTxParams,
     publicKey: string
   ): Promise<Omit<SignExecuteScriptTxResult, 'signature'>> {
-    TransactionBuilder.validatePublicKey(params, publicKey)
+    TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType)
 
     const { attoAlphAmount, tokens, gasPrice, ...rest } = params
     const data: node.BuildExecuteScriptTx = {
       fromPublicKey: publicKey,
+      fromPublicKeyType: params.signerKeyType,
       attoAlphAmount: toApiNumber256Optional(attoAlphAmount),
       tokens: toApiTokens(tokens),
       gasPrice: toApiNumber256Optional(gasPrice),

package/src/signer/types.ts

@@ -33,18 +33,22 @@ export interface Destination {
 }
 assertType<Eq<keyof Destination, keyof node.Destination>>
 
+export type KeyType = 'default' | 'bip340-schnorr'
+
 export interface Account {
+  keyType: KeyType
   address: string
   group: number
   publicKey: string
 }
 
-export type SignerAddress = { signerAddress: string }
-type TxBuildParams<T> = Omit<T, 'fromPublicKey' | 'targetBlockHash'> & SignerAddress
+export type SignerAddress = { signerAddress: string; signerKeyType?: KeyType }
+type TxBuildParams<T> = Omit<T, 'fromPublicKey' | 'fromPublicKeyType' | 'targetBlockHash'> & SignerAddress
 type SignResult<T> = Omit<T, 'gasPrice'> & { signature: string; gasPrice: Number256 }
 
 export interface SignTransferTxParams {
   signerAddress: string
+  signerKeyType?: KeyType
   destinations: Destination[]
   utxos?: OutputRef[]
   gasAmount?: number
@@ -64,6 +68,7 @@ assertType<Eq<SignTransferTxResult, SignResult<node.BuildTransactionResult>>>()
 
 export interface SignDeployContractTxParams {
   signerAddress: string
+  signerKeyType?: KeyType
   bytecode: string
   initialAttoAlphAmount?: Number256
   initialTokenAmounts?: Token[]
@@ -91,6 +96,7 @@ assertType<
 
 export interface SignExecuteScriptTxParams {
   signerAddress: string
+  signerKeyType?: KeyType
   bytecode: string
   attoAlphAmount?: Number256
   tokens?: Token[]
@@ -115,6 +121,7 @@ assertType<
 
 export interface SignUnsignedTxParams {
   signerAddress: string
+  signerKeyType?: KeyType
   unsignedTx: string
 }
 assertType<Eq<SignUnsignedTxParams, { unsignedTx: string } & SignerAddress>>()
@@ -131,6 +138,7 @@ assertType<Eq<SignUnsignedTxResult, SignTransferTxResult>>
 
 export interface SignMessageParams {
   signerAddress: string
+  signerKeyType?: KeyType
   message: string
 }
 assertType<Eq<SignMessageParams, { message: string } & SignerAddress>>()
@@ -154,10 +162,3 @@ export interface EnableOptionsBase {
   networkId: string
   onDisconnected: () => Promise<void>
 }
-
-// Transaction Params for InteractiveSignerProvider
-export type ExtSignTransferTxParams = SignTransferTxParams & { networkId: string }
-export type ExtSignDeployContractTxParams = SignDeployContractTxParams & { networkId: string }
-export type ExtSignExecuteScriptTxParams = SignExecuteScriptTxParams & { networkId: string }
-export type ExtSignUnsignedTxParams = SignUnsignedTxParams & { networkId: string }
-export type ExtSignMessageParams = SignMessageParams & { networkId: string }

package/src/transaction/sign-verify.ts

@@ -17,22 +17,17 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 
 import * as utils from '../utils'
-import { ec as EC } from 'elliptic'
+import { KeyType } from '../signer'
 
-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.encodeSignature(signature)
+export function transactionSign(txId: string, privateKey: string, keyType?: KeyType): string {
+  return utils.sign(txId, privateKey, keyType)
 }
 
-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
-  }
+export function transactionVerifySignature(
+  txId: string,
+  publicKey: string,
+  signature: string,
+  keyType?: KeyType
+): boolean {
+  return utils.verifySignature(txId, publicKey, signature, keyType)
 }

package/src/utils/index.ts

@@ -21,3 +21,4 @@ export * from './bs58'
 export * from './djb2'
 export * from './utils'
 export * from './subscription'
+export * from './sign'

package/src/utils/sign.ts

@@ -0,0 +1,66 @@
+/*
+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 { binToHex, encodeSignature, hexToBinUnsafe, signatureDecode } from '..'
+import { KeyType } from '../signer'
+import * as necc from '@noble/secp256k1'
+import { createHash, createHmac } from 'crypto'
+
+const ec = new EC('secp256k1')
+
+necc.utils.sha256Sync = (...messages: Uint8Array[]): Uint8Array => {
+  const sha256 = createHash('sha256')
+  for (const message of messages) sha256.update(message)
+  return sha256.digest()
+}
+
+necc.utils.hmacSha256Sync = (key: Uint8Array, ...messages: Uint8Array[]): Uint8Array => {
+  const hash = createHmac('sha256', Buffer.from(key))
+  messages.forEach((m) => hash.update(m))
+  return Uint8Array.from(hash.digest())
+}
+
+// hash has to be 32 bytes
+export function sign(hash: string, privateKey: string, _keyType?: KeyType): string {
+  const keyType = _keyType ?? 'default'
+
+  if (keyType === 'default') {
+    const key = ec.keyFromPrivate(privateKey)
+    const signature = key.sign(hash)
+    return encodeSignature(signature)
+  } else {
+    const signature = necc.schnorr.signSync(hexToBinUnsafe(hash), hexToBinUnsafe(privateKey))
+    return binToHex(signature)
+  }
+}
+
+export function verifySignature(hash: string, publicKey: string, signature: string, _keyType?: KeyType): boolean {
+  const keyType = _keyType ?? 'default'
+
+  try {
+    if (keyType === 'default') {
+      const key = ec.keyFromPublic(publicKey, 'hex')
+      return key.verify(hash, signatureDecode(ec, signature))
+    } else {
+      return necc.schnorr.verifySync(hexToBinUnsafe(signature), hexToBinUnsafe(hash), hexToBinUnsafe(publicKey))
+    }
+  } catch (error) {
+    return false
+  }
+}

package/src/utils/utils.ts

@@ -24,6 +24,7 @@ import { Buffer } from 'buffer/'
 
 import { TOTAL_NUMBER_OF_GROUPS } from '../constants'
 import djb2 from './djb2'
+import { KeyType } from '../signer'
 
 const ec = new EC('secp256k1')
 
@@ -157,20 +158,35 @@ export function binToHex(bin: Uint8Array): string {
   return Buffer.from(bin).toString('hex')
 }
 
-export function groupOfPrivateKey(privateKey: string): number {
-  return groupOfAddress(addressFromPublicKey(publicKeyFromPrivateKey(privateKey)))
+export function groupOfPrivateKey(privateKey: string, keyType?: KeyType): number {
+  return groupOfAddress(addressFromPublicKey(publicKeyFromPrivateKey(privateKey, keyType), keyType))
 }
 
-export function publicKeyFromPrivateKey(privateKey: string): string {
-  const key = ec.keyFromPrivate(privateKey)
-  return key.getPublic(true, 'hex')
+export function publicKeyFromPrivateKey(privateKey: string, _keyType?: KeyType): string {
+  const keyType = _keyType ?? 'default'
+
+  if (keyType === 'default') {
+    const key = ec.keyFromPrivate(privateKey)
+    return key.getPublic(true, 'hex')
+  } else {
+    return ec.g.mul(new BN(privateKey, 16)).encode('hex', true).slice(2)
+  }
 }
 
-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 addressFromPublicKey(publicKey: string, _keyType?: KeyType): string {
+  const keyType = _keyType ?? 'default'
+
+  if (keyType === 'default') {
+    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)
+  } else {
+    const lockupScript = Buffer.from(`0101000000000458144020${publicKey}8685`, 'hex')
+    const lockupScriptHash = blake.blake2b(lockupScript, undefined, 32)
+    const addressType = Buffer.from([AddressType.P2SH])
+    return bs58.encode(Buffer.concat([addressType, lockupScriptHash]))
+  }
 }
 
 export function addressFromContractId(contractId: string): string {