@alephium/web3 1.12.0-beta.0 → 1.12.0-danube.1

package/dist/src/signer/tx-builder.js

@@ -109,42 +109,6 @@ class TransactionBuilder {
         });
         return results;
     }
-    async buildGrouplessTransferTx(params) {
-        const data = this.buildGrouplessTransferTxParams(params);
-        const response = await this.nodeProvider.groupless.postGrouplessTransfer(data);
-        return response.map((result) => {
-            return {
-                ...this.convertTransferTxResult(result),
-                type: 'Transfer'
-            };
-        });
-    }
-    async buildGrouplessDeployContractTx(params) {
-        const data = this.buildGrouplessDeployContractTxParams(params);
-        const response = await this.nodeProvider.groupless.postGrouplessDeployContract(data);
-        const transferTxs = response.transferTxs.map((result) => ({
-            ...this.convertTransferTxResult(result),
-            type: 'Transfer'
-        }));
-        const deployContractTx = {
-            ...this.convertDeployContractTxResult(response.deployContractTx),
-            type: 'DeployContract'
-        };
-        return [...transferTxs, deployContractTx];
-    }
-    async buildGrouplessExecuteScriptTx(params) {
-        const data = this.buildGrouplessExecuteScriptTxParams(params);
-        const response = await this.nodeProvider.groupless.postGrouplessExecuteScript(data);
-        const transferTxs = response.transferTxs.map((result) => ({
-            ...this.convertTransferTxResult(result),
-            type: 'Transfer'
-        }));
-        const executeScriptTx = {
-            ...this.convertExecuteScriptTxResult(response.executeScriptTx),
-            type: 'ExecuteScript'
-        };
-        return [...transferTxs, executeScriptTx];
-    }
     static buildUnsignedTx(params) {
         const unsignedTxBin = (0, utils_1.hexToBinUnsafe)(params.unsignedTx);
         const decoded = codec_1.unsignedTxCodec.decode(unsignedTxBin);
@@ -170,37 +134,6 @@ class TransactionBuilder {
             ...rest
         };
     }
-    buildGrouplessTransferTxParams(params) {
-        return {
-            fromAddress: params.fromAddress,
-            destinations: (0, signer_1.toApiDestinations)(params.destinations),
-            gasPrice: (0, api_1.toApiNumber256Optional)(params.gasPrice),
-            targetBlockHash: params.targetBlockHash
-        };
-    }
-    buildGrouplessDeployContractTxParams(params) {
-        return {
-            fromAddress: params.fromAddress,
-            bytecode: params.bytecode,
-            initialAttoAlphAmount: (0, api_1.toApiNumber256Optional)(params.initialAttoAlphAmount),
-            initialTokenAmounts: (0, api_1.toApiTokens)(params.initialTokenAmounts),
-            issueTokenAmount: (0, api_1.toApiNumber256Optional)(params.issueTokenAmount),
-            issueTokenTo: params.issueTokenTo,
-            gasPrice: (0, api_1.toApiNumber256Optional)(params.gasPrice),
-            targetBlockHash: params.targetBlockHash
-        };
-    }
-    buildGrouplessExecuteScriptTxParams(params) {
-        return {
-            fromAddress: params.fromAddress,
-            bytecode: params.bytecode,
-            attoAlphAmount: (0, api_1.toApiNumber256Optional)(params.attoAlphAmount),
-            tokens: (0, api_1.toApiTokens)(params.tokens),
-            gasPrice: (0, api_1.toApiNumber256Optional)(params.gasPrice),
-            targetBlockHash: params.targetBlockHash,
-            gasEstimationMultiplier: params.gasEstimationMultiplier
-        };
-    }
     buildDeployContractTxParams(params, publicKey) {
         TransactionBuilder.validatePublicKey(params, publicKey, params.signerKeyType);
         const { initialAttoAlphAmount, initialTokenAmounts, issueTokenAmount, gasPrice, ...rest } = params;
@@ -227,12 +160,40 @@ class TransactionBuilder {
         };
     }
     convertTransferTxResult(result) {
+        // BuildGrouplessTransferTxResult
+        if ('transferTxs' in result) {
+            return {
+                transferTxs: result.transferTxs.map((r) => ({
+                    ...r,
+                    gasPrice: (0, api_1.fromApiNumber256)(r.gasPrice)
+                })),
+                tx: {
+                    ...result.transferTx,
+                    gasPrice: (0, api_1.fromApiNumber256)(result.transferTx.gasPrice)
+                }
+            };
+        }
         return {
             ...result,
             gasPrice: (0, api_1.fromApiNumber256)(result.gasPrice)
         };
     }
     convertDeployContractTxResult(result) {
+        if ('transferTxs' in result) {
+            const contractId = (0, utils_1.binToHex)((0, address_1.contractIdFromAddress)(result.deployContractTx.contractAddress));
+            return {
+                transferTxs: result.transferTxs.map((r) => ({
+                    ...r,
+                    gasPrice: (0, api_1.fromApiNumber256)(r.gasPrice)
+                })),
+                tx: {
+                    ...result.deployContractTx,
+                    groupIndex: result.deployContractTx.fromGroup,
+                    contractId,
+                    gasPrice: (0, api_1.fromApiNumber256)(result.deployContractTx.gasPrice)
+                }
+            };
+        }
         const contractId = (0, utils_1.binToHex)((0, address_1.contractIdFromAddress)(result.contractAddress));
         return {
             ...result,
@@ -242,6 +203,19 @@ class TransactionBuilder {
         };
     }
     convertExecuteScriptTxResult(result) {
+        if ('transferTxs' in result) {
+            return {
+                transferTxs: result.transferTxs.map((r) => ({
+                    ...r,
+                    gasPrice: (0, api_1.fromApiNumber256)(r.gasPrice)
+                })),
+                tx: {
+                    ...result.executeScriptTx,
+                    groupIndex: result.executeScriptTx.fromGroup,
+                    gasPrice: (0, api_1.fromApiNumber256)(result.executeScriptTx.gasPrice)
+                }
+            };
+        }
         return {
             ...result,
             groupIndex: result.fromGroup,

package/dist/src/signer/types.d.ts

@@ -11,7 +11,7 @@ export interface Destination {
     lockTime?: number;
     message?: string;
 }
-export type KeyType = 'default' | 'bip340-schnorr' | 'groupless';
+export type KeyType = 'default' | 'bip340-schnorr' | 'gl-secp256k1' | 'gl-secp256r1' | 'gl-ed25519' | 'gl-webauthn';
 export interface Account {
     keyType: KeyType;
     address: string;
@@ -29,6 +29,7 @@ export interface SignTransferTxParams {
     utxos?: OutputRef[];
     gasAmount?: number;
     gasPrice?: Number256;
+    group?: number;
 }
 export interface SignTransferTxResult {
     fromGroup: number;
@@ -49,6 +50,7 @@ export interface SignDeployContractTxParams {
     issueTokenTo?: string;
     gasAmount?: number;
     gasPrice?: Number256;
+    group?: number;
 }
 export interface SignDeployContractTxResult {
     groupIndex: number;
@@ -69,6 +71,7 @@ export interface SignExecuteScriptTxParams {
     gasAmount?: number;
     gasPrice?: Number256;
     gasEstimationMultiplier?: number;
+    group?: number;
 }
 export interface SignExecuteScriptTxResult {
     groupIndex: number;
@@ -79,6 +82,16 @@ export interface SignExecuteScriptTxResult {
     gasPrice: Number256;
     simulationResult: SimulationResult;
 }
+export interface GrouplessBuildTxResult<T extends SignExecuteScriptTxResult | SignDeployContractTxResult | SignTransferTxResult> {
+    transferTxs: Omit<SignTransferTxResult, 'signature'>[];
+    tx: Omit<T, 'signature'>;
+}
+export type BuildTxResult<T extends SignExecuteScriptTxResult | SignDeployContractTxResult | SignTransferTxResult> = GrouplessBuildTxResult<T> | Omit<T, 'signature'>;
+export interface GrouplessSignTxResult<T extends SignExecuteScriptTxResult | SignDeployContractTxResult | SignTransferTxResult> {
+    transferTxs: SignTransferTxResult[];
+    tx: T;
+}
+export type SignTxResult<T extends SignExecuteScriptTxResult | SignDeployContractTxResult | SignTransferTxResult> = GrouplessSignTxResult<T> | T;
 export interface SignUnsignedTxParams {
     signerAddress: string;
     signerKeyType?: KeyType;
@@ -113,32 +126,6 @@ export type SignExecuteScriptChainedTxResult = SignExecuteScriptTxResult & {
     type: 'ExecuteScript';
 };
 export type SignChainedTxResult = SignTransferChainedTxResult | SignDeployContractChainedTxResult | SignExecuteScriptChainedTxResult;
-export interface SignGrouplessTransferTxParams {
-    fromAddress: string;
-    destinations: Destination[];
-    gasPrice?: Number256;
-    targetBlockHash?: string;
-}
-export interface SignGrouplessDeployContractTxParams {
-    fromAddress: string;
-    bytecode: string;
-    initialAttoAlphAmount?: Number256;
-    initialTokenAmounts?: Token[];
-    issueTokenAmount?: Number256;
-    issueTokenTo?: string;
-    gasPrice?: Number256;
-    targetBlockHash?: string;
-}
-export interface SignGrouplessExecuteScriptTxParams {
-    fromAddress: string;
-    bytecode: string;
-    attoAlphAmount?: Number256;
-    tokens?: Token[];
-    gasPrice?: Number256;
-    targetBlockHash?: string;
-    gasEstimationMultiplier?: number;
-}
-export type SignGrouplessTxParams = SignGrouplessTransferTxParams | SignGrouplessDeployContractTxParams | SignGrouplessExecuteScriptTxParams;
 export type MessageHasher = 'alephium' | 'sha256' | 'blake2b' | 'identity';
 export interface SignMessageParams {
     signerAddress: string;

package/dist/src/signer/types.js

@@ -28,6 +28,3 @@ utils_1.assertType;
 (0, utils_1.assertType)();
 utils_1.assertType;
 (0, utils_1.assertType)();
-(0, utils_1.assertType)();
-(0, utils_1.assertType)();
-(0, utils_1.assertType)();

package/dist/src/utils/sign.js

@@ -60,7 +60,7 @@ necc.utils.hmacSha256Sync = (key, ...messages) => {
 // hash has to be 32 bytes
 function sign(hash, privateKey, _keyType) {
     const keyType = _keyType ?? 'default';
-    if (keyType === 'default' || keyType === 'groupless') {
+    if (keyType === 'default' || keyType === 'gl-secp256k1') {
         const key = ec.keyFromPrivate(privateKey);
         const signature = key.sign(hash);
         return (0, utils_1.encodeSignature)(signature);
@@ -74,7 +74,7 @@ exports.sign = sign;
 function verifySignature(hash, publicKey, signature, _keyType) {
     const keyType = _keyType ?? 'default';
     try {
-        if (keyType === 'default' || keyType === 'groupless') {
+        if (keyType === 'default' || keyType === 'gl-secp256k1') {
             const key = ec.keyFromPublic(publicKey, 'hex');
             return key.verify(hash, (0, utils_1.signatureDecode)(ec, signature));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "1.12.0-beta.0",
+  "version": "1.12.0-danube.1",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",

package/src/address/address.ts

@@ -16,7 +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 { ec as EC } from 'elliptic'
+import { ec as EC, eddsa as EdDSA } from 'elliptic'
 import BN from 'bn.js'
 import { TOTAL_NUMBER_OF_GROUPS } from '../constants'
 import blake from 'blakejs'
@@ -30,7 +30,9 @@ import djb2 from '../utils/djb2'
 import { TraceableError } from '../error'
 import { byteCodec } from '../codec/codec'
 
-const ec = new EC('secp256k1')
+const secp256k1 = new EC('secp256k1')
+const secp256r1 = new EC('p256')
+const ed25519 = new EdDSA('ed25519')
 const PublicKeyHashSize = 32
 
 export enum AddressType {
@@ -96,10 +98,14 @@ function decodeAndValidateAddress(address: string): Uint8Array {
 }
 
 function isGrouplessAddressWithoutGroup(decoded: Uint8Array): boolean {
+  // An ED25519 public key is 32 bytes; other public keys are 33 bytes.
+  // Format: AddressType(1 byte) + KeyType(1 byte) + PublicKey(32/33 bytes) + Checksum(4 bytes)
   return decoded[0] === AddressType.P2PK && (decoded.length === 38 || decoded.length === 39)
 }
 
 function isGrouplessAddressWithGroup(decoded: Uint8Array): boolean {
+  // An ED25519 public key is 32 bytes; other public keys are 33 bytes.
+  // Format: AddressType(1 byte) + KeyType(1 byte) + PublicKey(32/33 bytes) + Checksum(4 bytes) + GroupIndex(1 byte)
   return decoded[0] === AddressType.P2PK && (decoded.length === 39 || decoded.length === 40)
 }
 
@@ -222,29 +228,47 @@ export function groupOfPrivateKey(privateKey: string, keyType?: KeyType): number
 export function publicKeyFromPrivateKey(privateKey: string, _keyType?: KeyType): string {
   const keyType = _keyType ?? 'default'
 
-  if (keyType === 'default' || keyType === 'groupless') {
-    const key = ec.keyFromPrivate(privateKey)
-    return key.getPublic(true, 'hex')
-  } else {
-    return ec.g.mul(new BN(privateKey, 16)).encode('hex', true).slice(2)
+  switch (keyType) {
+    case 'default':
+    case 'gl-secp256k1':
+      return secp256k1.keyFromPrivate(privateKey).getPublic(true, 'hex')
+    case 'gl-secp256r1':
+    case 'gl-webauthn':
+      return secp256r1.keyFromPrivate(privateKey).getPublic(true, 'hex')
+    case 'gl-ed25519':
+      return ed25519.keyFromSecret(privateKey).getPublic('hex')
+    case 'bip340-schnorr':
+      return secp256k1.g.mul(new BN(privateKey, 16)).encode('hex', true).slice(2)
   }
 }
 
+function p2pkAddressFromPublicKey(
+  publicKey: string,
+  keyType: 'gl-secp256k1' | 'gl-secp256r1' | 'gl-ed25519' | 'gl-webauthn'
+): string {
+  const keyTypeByte =
+    keyType === 'gl-secp256k1' ? 0x00 : keyType === 'gl-secp256r1' ? 0x01 : keyType === 'gl-ed25519' ? 0x02 : 0x03
+  const publicKeyBytes = new Uint8Array([keyTypeByte, ...hexToBinUnsafe(publicKey)])
+  const checksum = intAs4BytesCodec.encode(djb2(publicKeyBytes))
+  const bytes = new Uint8Array([AddressType.P2PK, ...publicKeyBytes, ...checksum])
+  return bs58.encode(bytes)
+}
+
 export function addressFromPublicKey(publicKey: string, _keyType?: KeyType): string {
   const keyType = _keyType ?? 'default'
 
-  if (keyType === 'default') {
-    const hash = blake.blake2b(hexToBinUnsafe(publicKey), undefined, 32)
-    const bytes = new Uint8Array([AddressType.P2PKH, ...hash])
-    return bs58.encode(bytes)
-  } else if (keyType === 'groupless') {
-    const publicKeyBytes = new Uint8Array([0x00, ...hexToBinUnsafe(publicKey)])
-    const hashBytes = intAs4BytesCodec.encode(djb2(publicKeyBytes))
-    const bytes = new Uint8Array([0x04, ...publicKeyBytes, ...hashBytes])
-    return bs58.encode(bytes)
-  } else {
-    const lockupScript = hexToBinUnsafe(`0101000000000458144020${publicKey}8685`)
-    return addressFromScript(lockupScript)
+  switch (keyType) {
+    case 'default': {
+      const hash = blake.blake2b(hexToBinUnsafe(publicKey), undefined, 32)
+      const bytes = new Uint8Array([AddressType.P2PKH, ...hash])
+      return bs58.encode(bytes)
+    }
+    case 'bip340-schnorr': {
+      const lockupScript = hexToBinUnsafe(`0101000000000458144020${publicKey}8685`)
+      return addressFromScript(lockupScript)
+    }
+    default:
+      return p2pkAddressFromPublicKey(publicKey, keyType)
   }
 }
 
@@ -319,6 +343,13 @@ export function hasExplicitGroupIndex(address: string): boolean {
   return address.length > 2 && address[address.length - 2] === ':'
 }
 
+export function addressWithoutExplicitGroupIndex(address: string): string {
+  if (hasExplicitGroupIndex(address)) {
+    return address.slice(0, address.length - 2)
+  }
+  return address
+}
+
 export function addressFromLockupScript(lockupScript: LockupScript): string {
   if (lockupScript.kind === 'P2PK') {
     const groupByte = lockupScriptCodec.encode(lockupScript).slice(-1)