@alephium/web3 1.12.0-beta.0 → 1.12.0-danube.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)
   }
 

package/src/codec/instr-codec.ts

@@ -20,7 +20,7 @@ import { ArrayCodec } from './array-codec'
 import { i256Codec, u256Codec, i32Codec } from './compact-int-codec'
 import { ByteString, byteStringCodec, byteStringsCodec } from './bytestring-codec'
 import { LockupScript, lockupScriptCodec } from './lockup-script-codec'
-import { assert, byteCodec, Codec } from './codec'
+import { byteCodec, Codec } from './codec'
 import { intAs4BytesCodec } from './int-as-4bytes-codec'
 import { Reader } from './reader'
 export type Instr =
@@ -80,11 +80,11 @@ export type Instr =
   | { name: 'U256ModAdd'; code: 0x35 }
   | { name: 'U256ModSub'; code: 0x36 }
   | { name: 'U256ModMul'; code: 0x37 }
-  | { name: 'U256BitAnd'; code: 0x38 }
-  | { name: 'U256BitOr'; code: 0x39 }
-  | { name: 'U256Xor'; code: 0x3a }
-  | { name: 'U256SHL'; code: 0x3b }
-  | { name: 'U256SHR'; code: 0x3c }
+  | { name: 'NumericBitAnd'; code: 0x38 }
+  | { name: 'NumericBitOr'; code: 0x39 }
+  | { name: 'NumericXor'; code: 0x3a }
+  | { name: 'NumericSHL'; code: 0x3b }
+  | { name: 'NumericSHR'; code: 0x3c }
   | { name: 'I256ToU256'; code: 0x3d }
   | { name: 'I256ToByteVec'; code: 0x3e }
   | { name: 'U256ToI256'; code: 0x3f }
@@ -165,6 +165,8 @@ export type Instr =
   | { name: 'I256ToString'; code: 0x8a }
   | { name: 'BoolToString'; code: 0x8b }
   | { name: 'GroupOfAddress'; code: 0x8c }
+  | { name: 'VerifySignature'; code: 0x8d }
+  | { name: 'GetSegregatedWebAuthnSignature'; code: 0x8e }
   | { name: 'LoadMutField'; code: 0xa0; index: number }
   | { name: 'StoreMutField'; code: 0xa1; index: number }
   | { name: 'ApproveAlph'; code: 0xa2 }
@@ -218,6 +220,8 @@ export type Instr =
   | { name: 'CreateMapEntry'; code: 0xd2; immFieldsNum: number; mutFieldsNum: number }
   | { name: 'MethodSelector'; code: 0xd3; selector: number }
   | { name: 'CallExternalBySelector'; code: 0xd4; selector: number }
+  | { name: 'ExternalCallerContractId'; code: 0xd5 }
+  | { name: 'ExternalCallerAddress'; code: 0xd6 }
 export const CallLocalCode = 0x00
 export const CallExternalCode = 0x01
 export const I256ConstCode = 0x12
@@ -308,11 +312,11 @@ export const U256Ge: Instr = { name: 'U256Ge', code: 0x34 }
 export const U256ModAdd: Instr = { name: 'U256ModAdd', code: 0x35 }
 export const U256ModSub: Instr = { name: 'U256ModSub', code: 0x36 }
 export const U256ModMul: Instr = { name: 'U256ModMul', code: 0x37 }
-export const U256BitAnd: Instr = { name: 'U256BitAnd', code: 0x38 }
-export const U256BitOr: Instr = { name: 'U256BitOr', code: 0x39 }
-export const U256Xor: Instr = { name: 'U256Xor', code: 0x3a }
-export const U256SHL: Instr = { name: 'U256SHL', code: 0x3b }
-export const U256SHR: Instr = { name: 'U256SHR', code: 0x3c }
+export const NumericBitAnd: Instr = { name: 'NumericBitAnd', code: 0x38 }
+export const NumericBitOr: Instr = { name: 'NumericBitOr', code: 0x39 }
+export const NumericXor: Instr = { name: 'NumericXor', code: 0x3a }
+export const NumericSHL: Instr = { name: 'NumericSHL', code: 0x3b }
+export const NumericSHR: Instr = { name: 'NumericSHR', code: 0x3c }
 export const I256ToU256: Instr = { name: 'I256ToU256', code: 0x3d }
 export const I256ToByteVec: Instr = { name: 'I256ToByteVec', code: 0x3e }
 export const U256ToI256: Instr = { name: 'U256ToI256', code: 0x3f }
@@ -401,6 +405,8 @@ export const U256ToString: Instr = { name: 'U256ToString', code: 0x89 }
 export const I256ToString: Instr = { name: 'I256ToString', code: 0x8a }
 export const BoolToString: Instr = { name: 'BoolToString', code: 0x8b }
 export const GroupOfAddress: Instr = { name: 'GroupOfAddress', code: 0x8c }
+export const VerifySignature: Instr = { name: 'VerifySignature', code: 0x8d }
+export const GetSegregatedWebAuthnSignature: Instr = { name: 'GetSegregatedWebAuthnSignature', code: 0x8e }
 export const LoadMutField: (index: number) => Instr = (index: number) => {
   return { name: 'LoadMutField', code: 0xa0, index }
 }
@@ -472,6 +478,8 @@ export const MethodSelector: (selector: number) => Instr = (selector: number) =>
 export const CallExternalBySelector: (selector: number) => Instr = (selector: number) => {
   return { name: 'CallExternalBySelector', code: 0xd4, selector }
 }
+export const ExternalCallerContractId: Instr = { name: 'ExternalCallerContractId', code: 0xd5 }
+export const ExternalCallerAddress: Instr = { name: 'ExternalCallerAddress', code: 0xd6 }
 export class InstrCodec extends Codec<Instr> {
   encode(instr: Instr): Uint8Array {
     switch (instr.name) {
@@ -587,15 +595,15 @@ export class InstrCodec extends Codec<Instr> {
         return new Uint8Array([0x36])
       case 'U256ModMul':
         return new Uint8Array([0x37])
-      case 'U256BitAnd':
+      case 'NumericBitAnd':
         return new Uint8Array([0x38])
-      case 'U256BitOr':
+      case 'NumericBitOr':
         return new Uint8Array([0x39])
-      case 'U256Xor':
+      case 'NumericXor':
         return new Uint8Array([0x3a])
-      case 'U256SHL':
+      case 'NumericSHL':
         return new Uint8Array([0x3b])
-      case 'U256SHR':
+      case 'NumericSHR':
         return new Uint8Array([0x3c])
       case 'I256ToU256':
         return new Uint8Array([0x3d])
@@ -757,6 +765,10 @@ export class InstrCodec extends Codec<Instr> {
         return new Uint8Array([0x8b])
       case 'GroupOfAddress':
         return new Uint8Array([0x8c])
+      case 'VerifySignature':
+        return new Uint8Array([0x8d])
+      case 'GetSegregatedWebAuthnSignature':
+        return new Uint8Array([0x8e])
       case 'LoadMutField':
         return new Uint8Array([0xa0, ...byteCodec.encode(instr.index)])
       case 'StoreMutField':
@@ -863,6 +875,10 @@ export class InstrCodec extends Codec<Instr> {
         return new Uint8Array([0xd3, ...intAs4BytesCodec.encode(instr.selector)])
       case 'CallExternalBySelector':
         return new Uint8Array([0xd4, ...intAs4BytesCodec.encode(instr.selector)])
+      case 'ExternalCallerContractId':
+        return new Uint8Array([0xd5])
+      case 'ExternalCallerAddress':
+        return new Uint8Array([0xd6])
     }
   }
   _decode(input: Reader): Instr {
@@ -981,15 +997,15 @@ export class InstrCodec extends Codec<Instr> {
       case 0x37:
         return U256ModMul
       case 0x38:
-        return U256BitAnd
+        return NumericBitAnd
       case 0x39:
-        return U256BitOr
+        return NumericBitOr
       case 0x3a:
-        return U256Xor
+        return NumericXor
       case 0x3b:
-        return U256SHL
+        return NumericSHL
       case 0x3c:
-        return U256SHR
+        return NumericSHR
       case 0x3d:
         return I256ToU256
       case 0x3e:
@@ -1150,6 +1166,10 @@ export class InstrCodec extends Codec<Instr> {
         return BoolToString
       case 0x8c:
         return GroupOfAddress
+      case 0x8d:
+        return VerifySignature
+      case 0x8e:
+        return GetSegregatedWebAuthnSignature
       case 0xa0:
         return LoadMutField(byteCodec._decode(input))
       case 0xa1:
@@ -1256,6 +1276,10 @@ export class InstrCodec extends Codec<Instr> {
         return MethodSelector(intAs4BytesCodec._decode(input))
       case 0xd4:
         return CallExternalBySelector(intAs4BytesCodec._decode(input))
+      case 0xd5:
+        return ExternalCallerContractId
+      case 0xd6:
+        return ExternalCallerAddress
       default:
         throw new Error(`Unknown instr code: ${code}`)
     }