@alephium/web3 1.11.5 → 1.12.0-beta.0

package/src/api/node-provider.ts

@@ -55,6 +55,7 @@ interface NodeProviderApis {
   utils: NodeApi<string>['utils']
   miners: NodeApi<string>['miners']
   events: NodeApi<string>['events']
+  groupless: NodeApi<string>['groupless']
 }
 
 export class NodeProvider implements NodeProviderApis {
@@ -69,6 +70,7 @@ export class NodeProvider implements NodeProviderApis {
   readonly utils: NodeApi<string>['utils']
   readonly miners: NodeApi<string>['miners']
   readonly events: NodeApi<string>['events']
+  readonly groupless: NodeApi<string>['groupless']
 
   constructor(baseUrl: string, apiKey?: string, customFetch?: typeof fetch)
   constructor(provider: NodeProvider)
@@ -95,6 +97,7 @@ export class NodeProvider implements NodeProviderApis {
     this.utils = { ...nodeApi.utils }
     this.miners = { ...nodeApi.miners }
     this.events = { ...nodeApi.events }
+    this.groupless = { ...nodeApi.groupless }
     requestWithLog(this)
   }
 

package/src/api/types.ts

@@ -16,6 +16,7 @@ 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 { hasExplicitGroupIndex } from '../address'
 import { ZERO_ADDRESS } from '../constants'
 import { isDebugModeEnabled } from '../debug'
 import { TraceableError } from '../error'
@@ -99,14 +100,18 @@ export function toApiByteVec(v: Val): string {
   throw new Error(`Invalid hex-string: ${v}`)
 }
 
-export function toApiAddress(v: Val): string {
-  if (typeof v === 'string') {
+export function toApiAddress(v0: Val): string {
+  if (typeof v0 === 'string') {
+    let v = v0
+    if (hasExplicitGroupIndex(v)) {
+      v = v.slice(0, -2)
+    }
     if (isBase58(v)) {
-      return v
+      return v0
     }
-    throw new Error(`Invalid base58 string: ${v}`)
+    throw new Error(`Invalid base58 string: ${v0}`)
   } else {
-    throw new Error(`Invalid value: ${v}, expected a base58 string`)
+    throw new Error(`Invalid value: ${v0}, expected a base58 string`)
   }
 }
 

package/src/codec/lockup-script-codec.ts

@@ -16,8 +16,9 @@ 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 { i32Codec } from './compact-int-codec'
-import { byte32Codec, EnumCodec, ObjectCodec } from './codec'
+import { byte32Codec, byteCodec, EnumCodec, FixedSizeCodec, ObjectCodec } from './codec'
 import { ArrayCodec } from './array-codec'
+import { intAs4BytesCodec } from './int-as-4bytes-codec'
 
 export type PublicKeyHash = Uint8Array
 export type P2PKH = Uint8Array
@@ -31,20 +32,36 @@ export interface P2MPKH {
   m: number
 }
 
+export interface P2PC {
+  type: number
+  publicKey: Uint8Array
+  checkSum: Uint8Array
+  group: number
+}
+
 const p2mpkhCodec = new ObjectCodec<P2MPKH>({
   publicKeyHashes: new ArrayCodec(byte32Codec),
   m: i32Codec
 })
 
+const p2pkCodec = new ObjectCodec<P2PC>({
+  type: byteCodec,
+  publicKey: new FixedSizeCodec(33),
+  checkSum: new FixedSizeCodec(4),
+  group: byteCodec
+})
+
 export type LockupScript =
   | { kind: 'P2PKH'; value: P2PKH }
   | { kind: 'P2MPKH'; value: P2MPKH }
   | { kind: 'P2SH'; value: P2SH }
   | { kind: 'P2C'; value: P2C }
+  | { kind: 'P2PK'; value: P2PC }
 
 export const lockupScriptCodec = new EnumCodec<LockupScript>('lockup script', {
   P2PKH: byte32Codec,
   P2MPKH: p2mpkhCodec,
   P2SH: byte32Codec,
-  P2C: byte32Codec
+  P2C: byte32Codec,
+  P2PK: p2pkCodec
 })

package/src/codec/unlock-script-codec.ts

@@ -17,13 +17,13 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 import { ArrayCodec } from './array-codec'
 import { i32Codec } from './compact-int-codec'
-import { Codec, EnumCodec, FixedSizeCodec, ObjectCodec } from './codec'
+import { byteCodec, Codec, EnumCodec, FixedSizeCodec, ObjectCodec } from './codec'
 import { Script, scriptCodec } from './script-codec'
 import { Val, valsCodec } from './val'
 
-export type P2PKH = Uint8Array
+export type PublicKey = Uint8Array
 export interface KeyWithIndex {
-  publicKey: P2PKH
+  publicKey: PublicKey
   index: number
 }
 export type P2MPKH = KeyWithIndex[]
@@ -32,16 +32,21 @@ export interface P2SH {
   params: Val[]
 }
 export type SameAsPrevious = 'SameAsPrevious'
+export type P2PK = 'P2PK'
+
+export type KeyType = number
 
 export type UnlockScript =
-  | { kind: 'P2PKH'; value: P2PKH }
+  | { kind: 'P2PKH'; value: PublicKey }
   | { kind: 'P2MPKH'; value: P2MPKH }
   | { kind: 'P2SH'; value: P2SH }
   | { kind: 'SameAsPrevious'; value: SameAsPrevious }
+  | { kind: 'PoLW'; value: PublicKey }
+  | { kind: 'P2PK'; value: P2PK }
 
-const p2pkhCodec = new FixedSizeCodec(33)
+const publicKeyCodec = new FixedSizeCodec(33)
 const keyWithIndexCodec = new ObjectCodec<KeyWithIndex>({
-  publicKey: p2pkhCodec,
+  publicKey: publicKeyCodec,
   index: i32Codec
 })
 const p2mpkhCodec: Codec<P2MPKH> = new ArrayCodec(keyWithIndexCodec)
@@ -57,12 +62,22 @@ const sameAsPreviousCodec = new (class extends Codec<SameAsPrevious> {
     return 'SameAsPrevious'
   }
 })()
+const p2pkCodec = new (class extends Codec<P2PK> {
+  encode(): Uint8Array {
+    return new Uint8Array([])
+  }
+  _decode(): P2PK {
+    return 'P2PK'
+  }
+})()
 
 export const unlockScriptCodec = new EnumCodec<UnlockScript>('unlock script', {
-  P2PKH: p2pkhCodec,
+  P2PKH: publicKeyCodec,
   P2MPKH: p2mpkhCodec,
   P2SH: p2shCodec,
-  SameAsPrevious: sameAsPreviousCodec
+  SameAsPrevious: sameAsPreviousCodec,
+  PoLW: publicKeyCodec,
+  P2PK: p2pkCodec
 })
 
 export const encodedSameAsPrevious = unlockScriptCodec.encode({ kind: 'SameAsPrevious', value: 'SameAsPrevious' })

package/src/contract/contract.ts

@@ -58,7 +58,13 @@ import {
   isHexString,
   hexToString
 } from '../utils'
-import { contractIdFromAddress, groupOfAddress, addressFromContractId, subContractId } from '../address'
+import {
+  contractIdFromAddress,
+  groupOfAddress,
+  addressFromContractId,
+  subContractId,
+  isGrouplessAddressWithoutGroupIndex,
+} from '../address'
 import { getCurrentNodeProvider } from '../global'
 import { EventSubscribeOptions, EventSubscription, subscribeToEvents } from './events'
 import { MINIMAL_CONTRACT_DEPOSIT, ONE_ALPH, TOTAL_NUMBER_OF_GROUPS } from '../constants'
@@ -482,7 +488,7 @@ export class Contract extends Artifact {
       blockTimeStamp: params.blockTimeStamp,
       txId: params.txId,
       address: params.address,
-      callerAddress: params.callerAddress,
+      callerContractAddress: params.callerContractAddress,
       bytecode: this.isInlineFunc(methodIndex) ? this.getByteCodeForTesting() : this.bytecodeDebug,
       initialImmFields: immFields,
       initialMutFields: mutFields,
@@ -590,7 +596,8 @@ export class Contract extends Artifact {
 
   async txParamsForDeployment<P extends Fields>(
     signer: SignerProvider,
-    params: DeployContractParams<P>
+    params: DeployContractParams<P>,
+    group?: number
   ): Promise<SignDeployContractTxParams> {
     const isDevnet = await this.isDevnet(signer)
     const initialFields: Fields = params.initialFields ?? {}
@@ -600,8 +607,16 @@ export class Contract extends Artifact {
       params.exposePrivateFunctions ?? false
     )
     const selectedAccount = await signer.getSelectedAccount()
+    let signerAddress = selectedAccount.address
+    if (isGrouplessAddressWithoutGroupIndex(selectedAccount.address)) {
+      if (group === undefined) {
+        throw new Error('Groupless address requires explicit group number for contract deployment')
+      }
+      signerAddress = `${selectedAccount.address}:${group}`
+    }
+
     const signerParams: SignDeployContractTxParams = {
-      signerAddress: selectedAccount.address,
+      signerAddress,
       signerKeyType: selectedAccount.keyType,
       bytecode: bytecode,
       initialAttoAlphAmount: params?.initialAttoAlphAmount,
@@ -967,7 +982,7 @@ export interface TestContractParams<
 > {
   group?: number // default 0
   address?: string
-  callerAddress?: string
+  callerContractAddress?: string
   blockHash?: string
   blockTimeStamp?: number
   txId?: string
@@ -1079,11 +1094,19 @@ export abstract class ContractFactory<I extends ContractInstance, F extends Fiel
 
   abstract at(address: string): I
 
-  async deploy(signer: SignerProvider, deployParams: DeployContractParams<F>): Promise<DeployContractResult<I>> {
-    const signerParams = await this.contract.txParamsForDeployment(signer, {
-      ...deployParams,
-      initialFields: addStdIdToFields(this.contract, deployParams.initialFields)
-    })
+  async deploy(
+    signer: SignerProvider,
+    deployParams: DeployContractParams<F>,
+    group?: number
+  ): Promise<DeployContractResult<I>> {
+    const signerParams = await this.contract.txParamsForDeployment(
+      signer,
+      {
+        ...deployParams,
+        initialFields: addStdIdToFields(this.contract, deployParams.initialFields)
+      },
+      group
+    )
     const result = await signer.signAndSubmitDeployContractTx(signerParams)
     return {
       ...result,

package/src/contract/ralph.ts

@@ -30,10 +30,13 @@ import {
   instrCodec,
   u256Codec,
   toU256,
-  toI256
+  toI256,
+  intAs4BytesCodec
 } from '../codec'
 import { boolCodec } from '../codec/codec'
 import { TraceableError } from '../error'
+import djb2 from '../utils/djb2'
+import { addressToBytes, groupFromHint } from '../address'
 
 export function encodeByteVec(hex: string): Uint8Array {
   if (!isHexString(hex)) {
@@ -45,7 +48,7 @@ export function encodeByteVec(hex: string): Uint8Array {
 }
 
 export function encodeAddress(address: string): Uint8Array {
-  return bs58.decode(address)
+  return addressToBytes(address)
 }
 
 export enum VmValType {

package/src/signer/signer.ts

@@ -298,5 +298,5 @@ export function toApiDestinations(data: Destination[]): node.Destination[] {
 }
 
 export function fromApiDestination(data: node.Destination): Destination {
-  return { ...data, attoAlphAmount: fromApiNumber256(data.attoAlphAmount), tokens: fromApiTokens(data.tokens) }
+  return { ...data, attoAlphAmount: fromApiNumber256(data.attoAlphAmount ?? '0'), tokens: fromApiTokens(data.tokens) }
 }

package/src/signer/tx-builder.ts

@@ -34,7 +34,11 @@ import {
   SignTransferTxParams,
   SignTransferTxResult,
   SignUnsignedTxParams,
-  SignUnsignedTxResult
+  SignUnsignedTxResult,
+  SignGrouplessTransferTxParams,
+  SignGrouplessDeployContractTxParams,
+  SignTransferChainedTxResult,
+  SignGrouplessExecuteScriptTxParams
 } from './types'
 import { unsignedTxCodec } from '../codec'
 import { groupIndexOfTransaction } from '../transaction'
@@ -154,6 +158,51 @@ export abstract class TransactionBuilder {
     return results
   }
 
+  async buildGrouplessTransferTx(
+    params: SignGrouplessTransferTxParams
+  ): Promise<Omit<SignChainedTxResult, 'signature'>[]> {
+    const data = this.buildGrouplessTransferTxParams(params)
+    const response = await this.nodeProvider.groupless.postGrouplessTransfer(data)
+    return response.map((result) => {
+      return {
+        ...this.convertTransferTxResult(result),
+        type: 'Transfer' as const
+      }
+    })
+  }
+
+  async buildGrouplessDeployContractTx(
+    params: SignGrouplessDeployContractTxParams
+  ): Promise<Omit<SignChainedTxResult, 'signature'>[]> {
+    const data = this.buildGrouplessDeployContractTxParams(params)
+    const response = await this.nodeProvider.groupless.postGrouplessDeployContract(data)
+    const transferTxs = response.transferTxs.map((result) => ({
+      ...this.convertTransferTxResult(result),
+      type: 'Transfer' as const
+    }))
+    const deployContractTx = {
+      ...this.convertDeployContractTxResult(response.deployContractTx),
+      type: 'DeployContract' as const
+    }
+    return [...transferTxs, deployContractTx]
+  }
+
+  async buildGrouplessExecuteScriptTx(
+    params: SignGrouplessExecuteScriptTxParams
+  ): Promise<Omit<SignChainedTxResult, 'signature'>[]> {
+    const data = this.buildGrouplessExecuteScriptTxParams(params)
+    const response = await this.nodeProvider.groupless.postGrouplessExecuteScript(data)
+    const transferTxs = response.transferTxs.map((result) => ({
+      ...this.convertTransferTxResult(result),
+      type: 'Transfer' as const
+    }))
+    const executeScriptTx = {
+      ...this.convertExecuteScriptTxResult(response.executeScriptTx),
+      type: 'ExecuteScript' as const
+    }
+    return [...transferTxs, executeScriptTx]
+  }
+
   static buildUnsignedTx(params: SignUnsignedTxParams): Omit<SignUnsignedTxResult, 'signature'> {
     const unsignedTxBin = hexToBinUnsafe(params.unsignedTx)
     const decoded = unsignedTxCodec.decode(unsignedTxBin)
@@ -182,6 +231,44 @@ export abstract class TransactionBuilder {
     }
   }
 
+  private buildGrouplessTransferTxParams(params: SignGrouplessTransferTxParams): node.BuildGrouplessTransferTx {
+    return {
+      fromAddress: params.fromAddress,
+      destinations: toApiDestinations(params.destinations),
+      gasPrice: toApiNumber256Optional(params.gasPrice),
+      targetBlockHash: params.targetBlockHash
+    }
+  }
+
+  private buildGrouplessDeployContractTxParams(
+    params: SignGrouplessDeployContractTxParams
+  ): node.BuildGrouplessDeployContractTx {
+    return {
+      fromAddress: params.fromAddress,
+      bytecode: params.bytecode,
+      initialAttoAlphAmount: toApiNumber256Optional(params.initialAttoAlphAmount),
+      initialTokenAmounts: toApiTokens(params.initialTokenAmounts),
+      issueTokenAmount: toApiNumber256Optional(params.issueTokenAmount),
+      issueTokenTo: params.issueTokenTo,
+      gasPrice: toApiNumber256Optional(params.gasPrice),
+      targetBlockHash: params.targetBlockHash
+    }
+  }
+
+  private buildGrouplessExecuteScriptTxParams(
+    params: SignGrouplessExecuteScriptTxParams
+  ): node.BuildGrouplessExecuteScriptTx {
+    return {
+      fromAddress: params.fromAddress,
+      bytecode: params.bytecode,
+      attoAlphAmount: toApiNumber256Optional(params.attoAlphAmount),
+      tokens: toApiTokens(params.tokens),
+      gasPrice: toApiNumber256Optional(params.gasPrice),
+      targetBlockHash: params.targetBlockHash,
+      gasEstimationMultiplier: params.gasEstimationMultiplier
+    }
+  }
+
   private buildDeployContractTxParams(
     params: SignDeployContractTxParams,
     publicKey: string

package/src/signer/types.ts

@@ -18,6 +18,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 
 import { Number256, Token } from '../api'
 import { node } from '../api'
+import { SimulationResult } from '../api/api-alephium'
 import { Eq, assertType, NetworkId } from '../utils'
 
 export type Address = string
@@ -33,7 +34,7 @@ export interface Destination {
 }
 assertType<Eq<keyof Destination, keyof node.Destination>>
 
-export type KeyType = 'default' | 'bip340-schnorr'
+export type KeyType = 'default' | 'bip340-schnorr' | 'groupless'
 
 export interface Account {
   keyType: KeyType
@@ -113,7 +114,7 @@ export interface SignExecuteScriptTxResult {
   signature: string
   gasAmount: number
   gasPrice: Number256
-  simulatedOutputs: node.Output[]
+  simulationResult: SimulationResult
 }
 assertType<
   Eq<
@@ -159,6 +160,39 @@ export type SignChainedTxResult =
   | SignDeployContractChainedTxResult
   | SignExecuteScriptChainedTxResult
 
+export interface SignGrouplessTransferTxParams {
+  fromAddress: string
+  destinations: Destination[]
+  gasPrice?: Number256
+  targetBlockHash?: string
+}
+assertType<Eq<keyof SignGrouplessTransferTxParams, keyof node.BuildGrouplessTransferTx>>()
+export interface SignGrouplessDeployContractTxParams {
+  fromAddress: string
+  bytecode: string
+  initialAttoAlphAmount?: Number256
+  initialTokenAmounts?: Token[]
+  issueTokenAmount?: Number256
+  issueTokenTo?: string
+  gasPrice?: Number256
+  targetBlockHash?: string
+}
+assertType<Eq<keyof SignGrouplessDeployContractTxParams, keyof node.BuildGrouplessDeployContractTx>>()
+export interface SignGrouplessExecuteScriptTxParams {
+  fromAddress: string
+  bytecode: string
+  attoAlphAmount?: Number256
+  tokens?: Token[]
+  gasPrice?: Number256
+  targetBlockHash?: string
+  gasEstimationMultiplier?: number
+}
+assertType<Eq<keyof SignGrouplessExecuteScriptTxParams, keyof node.BuildGrouplessExecuteScriptTx>>()
+export type SignGrouplessTxParams =
+  | SignGrouplessTransferTxParams
+  | SignGrouplessDeployContractTxParams
+  | SignGrouplessExecuteScriptTxParams
+
 export type MessageHasher =
   | 'alephium' // Message is prefixed with 'Alephium signed message: ' before hashed with blake2b
   | 'sha256'

package/src/utils/sign.ts

@@ -40,7 +40,7 @@ necc.utils.hmacSha256Sync = (key: Uint8Array, ...messages: Uint8Array[]): Uint8A
 export function sign(hash: string, privateKey: string, _keyType?: KeyType): string {
   const keyType = _keyType ?? 'default'
 
-  if (keyType === 'default') {
+  if (keyType === 'default' || keyType === 'groupless') {
     const key = ec.keyFromPrivate(privateKey)
     const signature = key.sign(hash)
     return encodeSignature(signature)
@@ -54,7 +54,7 @@ export function verifySignature(hash: string, publicKey: string, signature: stri
   const keyType = _keyType ?? 'default'
 
   try {
-    if (keyType === 'default') {
+    if (keyType === 'default' || keyType === 'groupless') {
       const key = ec.keyFromPublic(publicKey, 'hex')
       return key.verify(hash, signatureDecode(ec, signature))
     } else {