@alephium/web3 2.0.0-rc.2 → 2.0.0

package/src/contract/ralph.ts

@@ -16,7 +16,16 @@ 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 { Val, decodeArrayType, toApiAddress, toApiBoolean, toApiByteVec, toApiNumber256, PrimitiveTypes } from '../api'
+import {
+  Val,
+  decodeArrayType,
+  toApiAddress,
+  toApiBoolean,
+  toApiByteVec,
+  toApiNumber256,
+  PrimitiveTypes,
+  decodeTupleType
+} from '../api'
 import { HexString, binToHex, bs58, hexToBinUnsafe, isHexString } from '../utils'
 import { Fields, FieldsSig, Struct } from './contract'
 import {
@@ -208,6 +217,19 @@ export function calcFieldSize(
     const base = calcFieldSize(baseType, isMutable, structs)
     return { immFields: base.immFields * size, mutFields: base.mutFields * size }
   }
+  if (type.startsWith('(')) {
+    const tuple = decodeTupleType(type)
+    return tuple.reduce(
+      (acc, fieldType) => {
+        const subFieldSize = calcFieldSize(fieldType, isMutable, structs)
+        return {
+          immFields: acc.immFields + subFieldSize.immFields,
+          mutFields: acc.mutFields + subFieldSize.mutFields
+        }
+      },
+      { immFields: 0, mutFields: 0 }
+    )
+  }
   return isMutable ? { immFields: 0, mutFields: 1 } : { immFields: 1, mutFields: 0 }
 }
 
@@ -284,6 +306,11 @@ export function typeLength(typ: string, structs: Struct[]): number {
     return size * typeLength(baseType, structs)
   }
 
+  if (typ.startsWith('(')) {
+    const tuple = decodeTupleType(typ)
+    return tuple.reduce((acc, fieldType) => acc + typeLength(fieldType, structs), 0)
+  }
+
   const struct = structs.find((s) => s.name === typ)
   if (struct !== undefined) {
     return struct.fieldTypes.reduce((acc, fieldType) => acc + typeLength(fieldType, structs), 0)
@@ -323,6 +350,15 @@ function flattenField(
       return flattenField(isMutable, `${name}[${index}]`, baseType, item, structs)
     })
   }
+  if (Array.isArray(value) && type.startsWith('(')) {
+    const tuple = decodeTupleType(type)
+    if (value.length !== tuple.length) {
+      throw Error(`Invalid tuple length, expected ${tuple.length}, got ${value.length}`)
+    }
+    return tuple.flatMap((fieldType, index) => {
+      return flattenField(isMutable, `${name}._${index}`, fieldType, value[`${index}`], structs)
+    })
+  }
   const struct = structs.find((s) => s.name === type)
   if (struct !== undefined) {
     if (typeof value !== 'object') {

package/src/signer/tx-builder.ts

@@ -207,13 +207,14 @@ export abstract class TransactionBuilder {
   private buildExecuteScriptTxParams(params: SignExecuteScriptTxParams, publicKey: string): node.BuildExecuteScriptTx {
     TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType)
 
-    const { attoAlphAmount, tokens, gasPrice, ...rest } = params
+    const { attoAlphAmount, tokens, gasPrice, dustAmount, ...rest } = params
     return {
       fromPublicKey: publicKey,
       fromPublicKeyType: params.signerKeyType,
       attoAlphAmount: toApiNumber256Optional(attoAlphAmount),
       tokens: toApiTokens(tokens),
       gasPrice: toApiNumber256Optional(gasPrice),
+      dustAmount: toApiNumber256Optional(dustAmount),
       ...rest
     }
   }

package/src/signer/types.ts

@@ -34,8 +34,12 @@ export interface Destination {
 }
 assertType<Eq<keyof Destination, keyof node.Destination>>
 
-export type GroupedKeyType = 'default' | 'bip340-schnorr'
-export type GrouplessKeyType = 'gl-secp256k1' | 'gl-secp256r1' | 'gl-ed25519' | 'gl-webauthn'
+export const groupedKeyTypes = ['default', 'bip340-schnorr'] as const
+export const grouplessKeyTypes = ['gl-secp256k1', 'gl-secp256r1', 'gl-ed25519', 'gl-webauthn'] as const
+export const keyTypes = [...groupedKeyTypes, ...grouplessKeyTypes] as const
+
+export type GroupedKeyType = (typeof groupedKeyTypes)[number]
+export type GrouplessKeyType = (typeof grouplessKeyTypes)[number]
 
 export type KeyType = GroupedKeyType | GrouplessKeyType
 
@@ -54,12 +58,20 @@ export interface GrouplessAccount {
 
 export type Account = GroupedAccount | GrouplessAccount
 
+export function isGroupedKeyType(keyType: KeyType): keyType is GroupedKeyType {
+  return keyType === 'default' || keyType === 'bip340-schnorr'
+}
+
+export function isGrouplessKeyType(keyType: KeyType): keyType is GrouplessKeyType {
+  return keyType !== 'default' && keyType !== 'bip340-schnorr'
+}
+
 export function isGroupedAccount(account: Account): account is GroupedAccount {
-  return account.keyType === 'default' || account.keyType === 'bip340-schnorr'
+  return isGroupedKeyType(account.keyType)
 }
 
 export function isGrouplessAccount(account: Account): account is GrouplessAccount {
-  return account.keyType !== 'default' && account.keyType !== 'bip340-schnorr'
+  return isGrouplessKeyType(account.keyType)
 }
 
 export type SignerAddress = { signerAddress: string; signerKeyType?: KeyType }
@@ -127,6 +139,7 @@ export interface SignExecuteScriptTxParams {
   gasPrice?: Number256
   gasEstimationMultiplier?: number
   group?: number
+  dustAmount?: Number256
 }
 assertType<Eq<keyof SignExecuteScriptTxParams, keyof TxBuildParams<node.BuildExecuteScriptTx>>>()
 export interface SignExecuteScriptTxResult {

package/src/utils/sign.ts

@@ -38,7 +38,7 @@ necc.utils.hmacSha256Sync = (key: Uint8Array, ...messages: Uint8Array[]): Uint8A
 
 function checkKeyType(keyType: KeyType) {
   if (keyType !== 'default' && keyType !== 'bip340-schnorr' && keyType !== 'gl-secp256k1') {
-    throw new Error(`Invalid key type ${keyType}`)
+    throw new Error(`Invalid key type ${keyType}, only supports secp256k1 and schnorr for now`)
   }
 }