@alephium/web3 2.0.2 → 2.0.4

package/src/contract/contract.ts

@@ -42,9 +42,7 @@ import {
   SignExecuteScriptTxParams,
   SignerProvider,
   Address,
-  SignExecuteScriptTxResult,
-  Account,
-  isGroupedAccount
+  SignExecuteScriptTxResult
 } from '../signer'
 import * as ralph from './ralph'
 import {
@@ -61,13 +59,7 @@ import {
   isHexString,
   hexToString
 } from '../utils'
-import {
-  contractIdFromAddress,
-  groupOfAddress,
-  addressFromContractId,
-  subContractId,
-  isGrouplessAddressWithoutGroupIndex
-} from '../address'
+import { contractIdFromAddress, groupOfAddress, addressFromContractId, subContractId } from '../address'
 import { getCurrentNodeProvider } from '../global'
 import { EventSubscribeOptions, EventSubscription, subscribeToEvents } from './events'
 import { MINIMAL_CONTRACT_DEPOSIT, ONE_ALPH, TOTAL_NUMBER_OF_GROUPS } from '../constants'
@@ -100,7 +92,6 @@ import {
 } from '../codec'
 import { TraceableError } from '../error'
 import { SimulationResult } from '../api/api-alephium'
-import { scriptCodec } from '../codec/script-codec'
 
 const crypto = new WebCrypto()
 
@@ -796,26 +787,9 @@ export class Script extends Artifact {
     return JSON.stringify(object, null, 2)
   }
 
-  getBytecodeAndGroup<P extends Fields>(account: Account, fields: P): [string, number] {
-    const bytecode = this.buildByteCodeToDeploy(fields)
-    if (isGroupedAccount(account)) {
-      return [bytecode, account.group]
-    }
-
-    const group = getGroupFromTxScript(bytecode)
-    const defaultGroup = groupOfAddress(account.address)
-    if (group === undefined || group === defaultGroup) {
-      return [bytecode, defaultGroup]
-    }
-
-    const newFields = ralph.updateFieldsWithGroup(fields, group) as P
-    const newBytecode = this.buildByteCodeToDeploy(newFields)
-    return [newBytecode, group]
-  }
-
   async txParamsForExecution<P extends Fields>(params: ExecuteScriptParams<P>): Promise<SignExecuteScriptTxParams> {
     const selectedAccount = await params.signer.getSelectedAccount()
-    const [bytecode, group] = this.getBytecodeAndGroup(selectedAccount, params.initialFields ?? {})
+    const bytecode = this.buildByteCodeToDeploy(params.initialFields ?? {})
     const signerParams: SignExecuteScriptTxParams = {
       signerAddress: selectedAccount.address,
       signerKeyType: selectedAccount.keyType,
@@ -824,7 +798,6 @@ export class Script extends Artifact {
       tokens: params.tokens,
       gasAmount: params.gasAmount,
       gasPrice: params.gasPrice,
-      group,
       dustAmount: params.dustAmount
     }
     return signerParams
@@ -839,34 +812,6 @@ export class Script extends Artifact {
   }
 }
 
-function getGroupFromTxScript(bytecode: string): number | undefined {
-  const script = scriptCodec.decode(hexToBinUnsafe(bytecode))
-  const instrs = script.methods.flatMap((method) => method.instrs)
-  for (let index = 0; index < instrs.length - 1; index += 1) {
-    const instr = instrs[`${index}`]
-    const nextInstr = instrs[index + 1]
-    if (
-      instr.name === 'BytesConst' &&
-      instr.value.length === 32 &&
-      (nextInstr.name === 'CallExternal' || nextInstr.name === 'CallExternalBySelector')
-    ) {
-      const groupIndex = instr.value[instr.value.length - 1]
-      if (groupIndex >= 0 && groupIndex < TOTAL_NUMBER_OF_GROUPS) {
-        return groupIndex
-      }
-    }
-  }
-  for (const instr of instrs) {
-    if (instr.name === 'BytesConst' && instr.value.length === 32) {
-      const groupIndex = instr.value[instr.value.length - 1]
-      if (groupIndex >= 0 && groupIndex < TOTAL_NUMBER_OF_GROUPS) {
-        return groupIndex
-      }
-    }
-  }
-  return undefined
-}
-
 export function fromApiFields(
   immFields: node.Val[],
   mutFields: node.Val[],

package/src/contract/ralph.ts

@@ -399,32 +399,6 @@ function checkPrimitiveValue(name: string, ralphType: string, value: Val): strin
   throw Error(`Invalid value ${value} for ${name}, expected a value of type ${ralphType}`)
 }
 
-export function updateFieldsWithGroup(fields: Fields, group: number): Fields {
-  const newFields: Fields = {}
-  for (const key in fields) {
-    const value = fields[`${key}`]
-    newFields[`${key}`] = updateValWithGroup(value, group)
-  }
-  return newFields
-}
-
-function updateValWithGroup(value: Val, group: number): Val {
-  if (typeof value === 'string') {
-    if (!isValidAddress(value)) return value
-    if (isGrouplessAddressWithoutGroupIndex(value)) return `${value}:${group}`
-    return value
-  }
-
-  if (Array.isArray(value)) {
-    return value.map((v) => updateValWithGroup(v, group))
-  }
-
-  if (typeof value === 'object') {
-    return updateFieldsWithGroup(value as Fields, group)
-  }
-  return value
-}
-
 const scriptFieldRegex = /\{([0-9]*)\}/g
 
 export function buildScriptByteCode(

package/src/signer/tx-builder.ts

@@ -18,7 +18,7 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 
 import { binToHex, hexToBinUnsafe } from '../utils'
 import { fromApiNumber256, node, NodeProvider, toApiNumber256Optional, toApiTokens } from '../api'
-import { addressFromPublicKey, contractIdFromAddress } from '../address'
+import { addressFromPublicKey, contractIdFromAddress, groupOfAddress, isGrouplessAddress } from '../address'
 import { toApiDestinations } from './signer'
 import {
   SignChainedTxParams,
@@ -36,7 +36,7 @@ import {
   SignUnsignedTxParams,
   SignUnsignedTxResult,
   BuildTxResult,
-  GrouplessBuildTxResult
+  isGroupedKeyType
 } from './types'
 import { unsignedTxCodec } from '../codec'
 import { groupIndexOfTransaction } from '../transaction'
@@ -47,6 +47,9 @@ import {
   BuildExecuteScriptTxResult,
   BuildTransferTxResult
 } from '../api/api-alephium'
+import { TOTAL_NUMBER_OF_GROUPS } from '../constants'
+import { scriptCodec } from '../codec/script-codec'
+import { LockupScript } from '../codec/lockup-script-codec'
 
 export abstract class TransactionBuilder {
   abstract get nodeProvider(): NodeProvider
@@ -204,13 +207,34 @@ export abstract class TransactionBuilder {
     }
   }
 
+  private static checkAndGetParams(params: SignExecuteScriptTxParams): SignExecuteScriptTxParams {
+    if (isGroupedKeyType(params.signerKeyType ?? 'default')) {
+      return params
+    }
+
+    if (!isGrouplessAddress(params.signerAddress)) {
+      throw new Error('Invalid signer key type for groupless address')
+    }
+
+    const group = params.group ?? getGroupFromTxScript(params.bytecode)
+    const defaultGroup = groupOfAddress(params.signerAddress)
+    if (group === undefined || group === defaultGroup) {
+      return { ...params, group: defaultGroup }
+    }
+
+    const newBytecode = updateBytecodeWithGroup(params.bytecode, group)
+    const newParams = { ...params, bytecode: newBytecode }
+    return { ...newParams, group }
+  }
+
   private buildExecuteScriptTxParams(params: SignExecuteScriptTxParams, publicKey: string): node.BuildExecuteScriptTx {
     TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType)
 
-    const { attoAlphAmount, tokens, gasPrice, dustAmount, ...rest } = params
+    const newParams = TransactionBuilder.checkAndGetParams(params)
+    const { signerKeyType, attoAlphAmount, tokens, gasPrice, dustAmount, ...rest } = newParams
     return {
       fromPublicKey: publicKey,
-      fromPublicKeyType: params.signerKeyType,
+      fromPublicKeyType: signerKeyType,
       attoAlphAmount: toApiNumber256Optional(attoAlphAmount),
       tokens: toApiTokens(tokens),
       gasPrice: toApiNumber256Optional(gasPrice),
@@ -296,3 +320,47 @@ export abstract class TransactionBuilder {
     }
   }
 }
+
+export function getGroupFromTxScript(bytecode: string): number | undefined {
+  const script = scriptCodec.decode(hexToBinUnsafe(bytecode))
+  const instrs = script.methods.flatMap((method) => method.instrs)
+  for (let index = 0; index < instrs.length - 1; index += 1) {
+    const instr = instrs[`${index}`]
+    const nextInstr = instrs[index + 1]
+    if (
+      instr.name === 'BytesConst' &&
+      instr.value.length === 32 &&
+      (nextInstr.name === 'CallExternal' || nextInstr.name === 'CallExternalBySelector')
+    ) {
+      const groupIndex = instr.value[instr.value.length - 1]
+      if (groupIndex >= 0 && groupIndex < TOTAL_NUMBER_OF_GROUPS) {
+        return groupIndex
+      }
+    }
+  }
+  for (const instr of instrs) {
+    if (instr.name === 'BytesConst' && instr.value.length === 32) {
+      const groupIndex = instr.value[instr.value.length - 1]
+      if (groupIndex >= 0 && groupIndex < TOTAL_NUMBER_OF_GROUPS) {
+        return groupIndex
+      }
+    }
+  }
+  return undefined
+}
+
+export function updateBytecodeWithGroup(bytecode: string, group: number): string {
+  const script = scriptCodec.decode(hexToBinUnsafe(bytecode))
+  const newMethods = script.methods.map((method) => {
+    const newInstrs = method.instrs.map((instr) => {
+      if (instr.name === 'AddressConst' && instr.value.kind === 'P2PK') {
+        const newLockupScript: LockupScript = { ...instr.value, value: { ...instr.value.value, group } }
+        return { ...instr, value: newLockupScript }
+      }
+      return instr
+    })
+    return { ...method, instrs: newInstrs }
+  })
+  const bytes = scriptCodec.encode({ methods: newMethods })
+  return binToHex(bytes)
+}