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

package/src/address/address.ts

@@ -77,45 +77,38 @@ function decodeAndValidateAddress(address: string): Uint8Array {
   } else if (addressType === AddressType.P2PKH || addressType === AddressType.P2SH || addressType === AddressType.P2C) {
     // [type, ...hash]
     if (decoded.length === 33) return decoded
-  } else if (isGrouplessAddressWithGroup(decoded)) {
-    // [type, keyType, ...publicKey, ...checkSum, ...groupByte]
-    const publicKeyToIndex = decoded.length - 1 - 4
-    const publicKeyLikeBytes = decoded.slice(1, publicKeyToIndex)
-    const checksum = binToHex(decoded.slice(publicKeyToIndex, publicKeyToIndex + 4))
-    const expectedChecksum = binToHex(intAs4BytesCodec.encode(djb2(publicKeyLikeBytes)))
-    if (checksum !== expectedChecksum) {
-      throw new Error(`Invalid checksum for P2PK address: ${address}`)
+  } else if (addressType === AddressType.P2PK) {
+    if (decoded.length === 40) {
+      // [type, keyType, ...publicKey, ...checkSum, ...groupByte]
+      const publicKeyLikeBytes = decoded.slice(1, 35)
+      const checksum = binToHex(decoded.slice(35, 39))
+      const expectedChecksum = binToHex(intAs4BytesCodec.encode(djb2(publicKeyLikeBytes)))
+      if (checksum !== expectedChecksum) {
+        throw new Error(`Invalid checksum for P2PK address: ${address}`)
+      }
+      const group = byteCodec.decode(decoded.slice(39, 40))
+      validateGroupIndex(group)
+
+      return decoded
     }
-    const group = byteCodec.decode(decoded.slice(decoded.length - 1, decoded.length))
-    validateGroupIndex(group)
-
-    return decoded
   }
 
   throw new Error(`Invalid address: ${address}`)
 }
 
-function isGrouplessAddressWithoutGroup(decoded: Uint8Array): boolean {
-  return decoded[0] === AddressType.P2PK && (decoded.length === 38 || decoded.length === 39)
-}
-
-function isGrouplessAddressWithGroup(decoded: Uint8Array): boolean {
-  return decoded[0] === AddressType.P2PK && (decoded.length === 39 || decoded.length === 40)
-}
-
 export function addressToBytes(address: string): Uint8Array {
   if (hasExplicitGroupIndex(address)) {
     const groupIndex = parseGroupIndex(address[address.length - 1])
     const decoded = base58ToBytes(address.slice(0, address.length - 2))
-    if (isGrouplessAddressWithoutGroup(decoded)) {
+    if (decoded[0] === 0x04 && decoded.length === 39) {
       const groupByte = byteCodec.encode(groupIndex)
       return new Uint8Array([...decoded, ...groupByte])
     }
     throw new Error(`Invalid groupless address: ${address}`)
   } else {
     const decoded = base58ToBytes(address)
-    if (isGrouplessAddressWithoutGroup(decoded)) {
-      const group = defaultGroupOfGrouplessAddress(decoded.slice(2, decoded.length - 4))
+    if (decoded[0] === 0x04 && decoded.length === 39) {
+      const group = defaultGroupOfGrouplessAddress(decoded.slice(2, 35))
       const groupByte = byteCodec.encode(group)
       return new Uint8Array([...decoded, ...groupByte])
     }
@@ -222,7 +215,7 @@ 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') {
+  if (keyType === 'default' || keyType === 'gl-secp256k1') {
     const key = ec.keyFromPrivate(privateKey)
     return key.getPublic(true, 'hex')
   } else {
@@ -237,7 +230,7 @@ export function addressFromPublicKey(publicKey: string, _keyType?: KeyType): str
     const hash = blake.blake2b(hexToBinUnsafe(publicKey), undefined, 32)
     const bytes = new Uint8Array([AddressType.P2PKH, ...hash])
     return bs58.encode(bytes)
-  } else if (keyType === 'groupless') {
+  } else if (keyType === 'gl-secp256k1') {
     const publicKeyBytes = new Uint8Array([0x00, ...hexToBinUnsafe(publicKey)])
     const hashBytes = intAs4BytesCodec.encode(djb2(publicKeyBytes))
     const bytes = new Uint8Array([0x04, ...publicKeyBytes, ...hashBytes])
@@ -319,6 +312,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)

package/src/api/api-alephium.ts

@@ -206,7 +206,7 @@ export interface BuildChainedDeployContractTx {
 
 /** BuildChainedDeployContractTxResult */
 export interface BuildChainedDeployContractTxResult {
-  value: BuildDeployContractTxResult
+  value: BuildSimpleDeployContractTxResult
   type: string
 }
 
@@ -218,7 +218,7 @@ export interface BuildChainedExecuteScriptTx {
 
 /** BuildChainedExecuteScriptTxResult */
 export interface BuildChainedExecuteScriptTxResult {
-  value: BuildExecuteScriptTxResult
+  value: BuildSimpleExecuteScriptTxResult
   type: string
 }
 
@@ -230,7 +230,7 @@ export interface BuildChainedTransferTx {
 
 /** BuildChainedTransferTxResult */
 export interface BuildChainedTransferTxResult {
-  value: BuildTransferTxResult
+  value: BuildSimpleTransferTxResult
   type: string
 }
 
@@ -262,26 +262,14 @@ export interface BuildDeployContractTx {
   gasAmount?: number
   /** @format uint256 */
   gasPrice?: string
+  /** @format group-index */
+  group?: number
   /** @format block-hash */
   targetBlockHash?: string
 }
 
 /** BuildDeployContractTxResult */
-export interface BuildDeployContractTxResult {
-  /** @format int32 */
-  fromGroup: number
-  /** @format int32 */
-  toGroup: number
-  unsignedTx: string
-  /** @format gas */
-  gasAmount: number
-  /** @format uint256 */
-  gasPrice: string
-  /** @format 32-byte-hash */
-  txId: string
-  /** @format address */
-  contractAddress: string
-}
+export type BuildDeployContractTxResult = BuildGrouplessDeployContractTxResult | BuildSimpleDeployContractTxResult
 
 /** BuildExecuteScriptTx */
 export interface BuildExecuteScriptTx {
@@ -300,80 +288,34 @@ export interface BuildExecuteScriptTx {
   gasPrice?: string
   /** @format block-hash */
   targetBlockHash?: string
+  /** @format group-index */
+  group?: number
   /** @format double */
   gasEstimationMultiplier?: number
 }
 
 /** BuildExecuteScriptTxResult */
-export interface BuildExecuteScriptTxResult {
-  /** @format int32 */
-  fromGroup: number
-  /** @format int32 */
-  toGroup: number
-  unsignedTx: string
-  /** @format gas */
-  gasAmount: number
-  /** @format uint256 */
-  gasPrice: string
-  /** @format 32-byte-hash */
-  txId: string
-  simulationResult: SimulationResult
-}
-
-/** BuildGrouplessDeployContractTx */
-export interface BuildGrouplessDeployContractTx {
-  fromAddress: string
-  /** @format hex-string */
-  bytecode: string
-  /** @format uint256 */
-  initialAttoAlphAmount?: string
-  initialTokenAmounts?: Token[]
-  /** @format uint256 */
-  issueTokenAmount?: string
-  /** @format address */
-  issueTokenTo?: string
-  /** @format uint256 */
-  gasPrice?: string
-  /** @format block-hash */
-  targetBlockHash?: string
-}
+export type BuildExecuteScriptTxResult = BuildGrouplessExecuteScriptTxResult | BuildSimpleExecuteScriptTxResult
 
 /** BuildGrouplessDeployContractTxResult */
 export interface BuildGrouplessDeployContractTxResult {
-  transferTxs: BuildTransferTxResult[]
-  deployContractTx: BuildDeployContractTxResult
-}
-
-/** BuildGrouplessExecuteScriptTx */
-export interface BuildGrouplessExecuteScriptTx {
-  fromAddress: string
-  /** @format hex-string */
-  bytecode: string
-  /** @format uint256 */
-  attoAlphAmount?: string
-  tokens?: Token[]
-  /** @format uint256 */
-  gasPrice?: string
-  /** @format block-hash */
-  targetBlockHash?: string
-  /** @format double */
-  gasEstimationMultiplier?: number
+  transferTxs: BuildSimpleTransferTxResult[]
+  deployContractTx: BuildSimpleDeployContractTxResult
+  type: string
 }
 
 /** BuildGrouplessExecuteScriptTxResult */
 export interface BuildGrouplessExecuteScriptTxResult {
-  transferTxs: BuildTransferTxResult[]
-  executeScriptTx: BuildExecuteScriptTxResult
+  transferTxs: BuildSimpleTransferTxResult[]
+  executeScriptTx: BuildSimpleExecuteScriptTxResult
+  type: string
 }
 
-/** BuildGrouplessTransferTx */
-export interface BuildGrouplessTransferTx {
-  fromAddress: string
-  destinations: Destination[]
-  /** @format uint256 */
-  gasPrice?: string
-  /** @format block-hash */
-  targetBlockHash?: string
+/** BuildGrouplessTransferTxResult */
+export interface BuildGrouplessTransferTxResult {
+  transferTxs: BuildSimpleTransferTxResult[]
+  transferTx: BuildSimpleTransferTxResult
+  type: string
 }
 
 /** BuildInfo */
@@ -416,6 +358,57 @@ export interface BuildMultisigAddressResult {
   address: string
 }
 
+/** BuildSimpleDeployContractTxResult */
+export interface BuildSimpleDeployContractTxResult {
+  /** @format int32 */
+  fromGroup: number
+  /** @format int32 */
+  toGroup: number
+  unsignedTx: string
+  /** @format gas */
+  gasAmount: number
+  /** @format uint256 */
+  gasPrice: string
+  /** @format 32-byte-hash */
+  txId: string
+  /** @format address */
+  contractAddress: string
+  type: string
+}
+
+/** BuildSimpleExecuteScriptTxResult */
+export interface BuildSimpleExecuteScriptTxResult {
+  /** @format int32 */
+  fromGroup: number
+  /** @format int32 */
+  toGroup: number
+  unsignedTx: string
+  /** @format gas */
+  gasAmount: number
+  /** @format uint256 */
+  gasPrice: string
+  /** @format 32-byte-hash */
+  txId: string
+  simulationResult: SimulationResult
+  type: string
+}
+
+/** BuildSimpleTransferTxResult */
+export interface BuildSimpleTransferTxResult {
+  unsignedTx: string
+  /** @format gas */
+  gasAmount: number
+  /** @format uint256 */
+  gasPrice: string
+  /** @format 32-byte-hash */
+  txId: string
+  /** @format int32 */
+  fromGroup: number
+  /** @format int32 */
+  toGroup: number
+  type: string
+}
+
 /** BuildSweepAddressTransactions */
 export interface BuildSweepAddressTransactions {
   /** @format public-key */
@@ -478,24 +471,14 @@ export interface BuildTransferTx {
   gasAmount?: number
   /** @format uint256 */
   gasPrice?: string
+  /** @format group-index */
+  group?: number
   /** @format block-hash */
   targetBlockHash?: string
 }
 
 /** BuildTransferTxResult */
-export interface BuildTransferTxResult {
-  unsignedTx: string
-  /** @format gas */
-  gasAmount: number
-  /** @format uint256 */
-  gasPrice: string
-  /** @format 32-byte-hash */
-  txId: string
-  /** @format int32 */
-  fromGroup: number
-  /** @format int32 */
-  toGroup: number
-}
+export type BuildTransferTxResult = BuildGrouplessTransferTxResult | BuildSimpleTransferTxResult
 
 /** CallContract */
 export interface CallContract {
@@ -1281,6 +1264,7 @@ export interface TestContract {
   args?: Val[]
   existingContracts?: ContractState[]
   inputAssets?: TestInputAsset[]
+  dustAmount?: string
 }
 
 /** TestContractResult */
@@ -1620,8 +1604,8 @@ export class HttpClient<SecurityDataType = unknown> {
           property instanceof Blob
             ? property
             : typeof property === 'object' && property !== null
-              ? JSON.stringify(property)
-              : `${property}`
+            ? JSON.stringify(property)
+            : `${property}`
         )
         return formData
       }, new FormData()),
@@ -1701,18 +1685,18 @@ export class HttpClient<SecurityDataType = unknown> {
       const data = !responseFormat
         ? r
         : await response[responseFormat]()
-          .then((data) => {
-            if (r.ok) {
-              r.data = data
-            } else {
-              r.error = data
-            }
-            return r
-          })
-          .catch((e) => {
-            r.error = e
-            return r
-          })
+            .then((data) => {
+              if (r.ok) {
+                r.data = data
+              } else {
+                r.error = data
+              }
+              return r
+            })
+            .catch((e) => {
+              r.error = e
+              return r
+            })
 
       if (cancelToken) {
         this.abortControllers.delete(cancelToken)
@@ -2797,7 +2781,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      */
     postTransactionsBuildTransferFromOneToManyGroups: (data: BuildTransferTx, params: RequestParams = {}) =>
       this.request<
-        BuildTransferTxResult[],
+        BuildSimpleTransferTxResult[],
         BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable | GatewayTimeout
       >({
         path: `/transactions/build-transfer-from-one-to-many-groups`,
@@ -2818,7 +2802,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      */
     postTransactionsBuildMultiAddresses: (data: BuildMultiAddressesTransaction, params: RequestParams = {}) =>
       this.request<
-        BuildTransferTxResult,
+        BuildSimpleTransferTxResult,
         BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable | GatewayTimeout
       >({
         path: `/transactions/build-multi-addresses`,
@@ -3466,7 +3450,7 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
      */
     postMultisigBuild: (data: BuildMultisig, params: RequestParams = {}) =>
       this.request<
-        BuildTransferTxResult,
+        BuildSimpleTransferTxResult,
         BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable | GatewayTimeout
       >({
         path: `/multisig/build`,
@@ -3778,68 +3762,4 @@ export class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDa
         ...params
       }).then(convertHttpResponse)
   }
-  groupless = {
-    /**
-     * No description
-     *
-     * @tags Groupless
-     * @name PostGrouplessTransfer
-     * @summary Build unsigned transfer transactions from a groupless address
-     * @request POST:/groupless/transfer
-     */
-    postGrouplessTransfer: (data: BuildGrouplessTransferTx, params: RequestParams = {}) =>
-      this.request<
-        BuildTransferTxResult[],
-        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable | GatewayTimeout
-      >({
-        path: `/groupless/transfer`,
-        method: 'POST',
-        body: data,
-        type: ContentType.Json,
-        format: 'json',
-        ...params
-      }).then(convertHttpResponse),
-
-    /**
-     * No description
-     *
-     * @tags Groupless
-     * @name PostGrouplessExecuteScript
-     * @summary Build an unsigned execute script transaction from a groupless address
-     * @request POST:/groupless/execute-script
-     */
-    postGrouplessExecuteScript: (data: BuildGrouplessExecuteScriptTx, params: RequestParams = {}) =>
-      this.request<
-        BuildGrouplessExecuteScriptTxResult,
-        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable | GatewayTimeout
-      >({
-        path: `/groupless/execute-script`,
-        method: 'POST',
-        body: data,
-        type: ContentType.Json,
-        format: 'json',
-        ...params
-      }).then(convertHttpResponse),
-
-    /**
-     * No description
-     *
-     * @tags Groupless
-     * @name PostGrouplessDeployContract
-     * @summary Build an unsigned deploy contract transaction from a groupless address
-     * @request POST:/groupless/deploy-contract
-     */
-    postGrouplessDeployContract: (data: BuildGrouplessDeployContractTx, params: RequestParams = {}) =>
-      this.request<
-        BuildGrouplessDeployContractTxResult,
-        BadRequest | Unauthorized | NotFound | InternalServerError | ServiceUnavailable | GatewayTimeout
-      >({
-        path: `/groupless/deploy-contract`,
-        method: 'POST',
-        body: data,
-        type: ContentType.Json,
-        format: 'json',
-        ...params
-      }).then(convertHttpResponse)
-  }
 }

package/src/api/node-provider.ts

@@ -55,7 +55,6 @@ interface NodeProviderApis {
   utils: NodeApi<string>['utils']
   miners: NodeApi<string>['miners']
   events: NodeApi<string>['events']
-  groupless: NodeApi<string>['groupless']
 }
 
 export class NodeProvider implements NodeProviderApis {
@@ -70,7 +69,6 @@ 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)
@@ -97,7 +95,6 @@ export class NodeProvider implements NodeProviderApis {
     this.utils = { ...nodeApi.utils }
     this.miners = { ...nodeApi.miners }
     this.events = { ...nodeApi.events }
-    this.groupless = { ...nodeApi.groupless }
     requestWithLog(this)
   }