@alephium/web3 1.12.0-danube.1 → 1.12.0

package/dist/src/address/address.d.ts

@@ -5,7 +5,8 @@ export declare enum AddressType {
     P2MPKH = 1,
     P2SH = 2,
     P2C = 3,
-    P2PK = 4
+    P2PK = 4,
+    P2HMPK = 5
 }
 export declare function validateAddress(address: string): void;
 export declare function isValidAddress(address: string): boolean;
@@ -14,7 +15,7 @@ export declare function isAssetAddress(address: string): boolean;
 export declare function isGrouplessAddress(address: string): boolean;
 export declare function isGrouplessAddressWithoutGroupIndex(address: string): boolean;
 export declare function isGrouplessAddressWithGroupIndex(address: string): boolean;
-export declare function defaultGroupOfGrouplessAddress(pubKey: Uint8Array): number;
+export declare function defaultGroupOfGrouplessAddress(bytes: Uint8Array): number;
 export declare function isContractAddress(address: string): boolean;
 export declare function groupOfAddress(address: string): number;
 export declare function contractIdFromAddress(address: string): Uint8Array;

package/dist/src/address/address.js

@@ -55,6 +55,7 @@ const codec_1 = require("../codec");
 const djb2_1 = __importDefault(require("../utils/djb2"));
 const error_1 = require("../error");
 const codec_2 = require("../codec/codec");
+const public_key_like_codec_1 = require("../codec/public-key-like-codec");
 const secp256k1 = new elliptic_1.ec('secp256k1');
 const secp256r1 = new elliptic_1.ec('p256');
 const ed25519 = new elliptic_1.eddsa('ed25519');
@@ -66,6 +67,7 @@ var AddressType;
     AddressType[AddressType["P2SH"] = 2] = "P2SH";
     AddressType[AddressType["P2C"] = 3] = "P2C";
     AddressType[AddressType["P2PK"] = 4] = "P2PK";
+    AddressType[AddressType["P2HMPK"] = 5] = "P2HMPK";
 })(AddressType = exports.AddressType || (exports.AddressType = {}));
 function validateAddress(address) {
     decodeAndValidateAddress(address);
@@ -110,36 +112,23 @@ function decodeAndValidateAddress(address) {
         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 = (0, utils_1.binToHex)(decoded.slice(publicKeyToIndex, publicKeyToIndex + 4));
-        const expectedChecksum = (0, utils_1.binToHex)(codec_1.intAs4BytesCodec.encode((0, djb2_1.default)(publicKeyLikeBytes)));
-        if (checksum !== expectedChecksum) {
-            throw new Error(`Invalid checksum for P2PK address: ${address}`);
-        }
-        const group = codec_2.byteCodec.decode(decoded.slice(decoded.length - 1, decoded.length));
-        validateGroupIndex(group);
+    else if (addressType === AddressType.P2PK) {
+        const p2pk = lockup_script_codec_1.lockupScriptCodec.decode(decoded).value;
+        validateGroupIndex(p2pk.group);
+        return decoded;
+    }
+    else if (addressType === AddressType.P2HMPK) {
+        const p2hmpk = lockup_script_codec_1.lockupScriptCodec.decode(decoded).value;
+        validateGroupIndex(p2hmpk.group);
         return decoded;
     }
     throw new Error(`Invalid address: ${address}`);
 }
-function isGrouplessAddressWithoutGroup(decoded) {
-    // 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) {
-    // 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);
-}
 function addressToBytes(address) {
     if (hasExplicitGroupIndex(address)) {
         const groupIndex = parseGroupIndex(address[address.length - 1]);
         const decoded = (0, bs58_1.base58ToBytes)(address.slice(0, address.length - 2));
-        if (isGrouplessAddressWithoutGroup(decoded)) {
+        if (decoded.length > 0 && isGrouplessType(decoded[0])) {
             const groupByte = codec_2.byteCodec.encode(groupIndex);
             return new Uint8Array([...decoded, ...groupByte]);
         }
@@ -147,7 +136,7 @@ function addressToBytes(address) {
     }
     else {
         const decoded = (0, bs58_1.base58ToBytes)(address);
-        if (isGrouplessAddressWithoutGroup(decoded)) {
+        if (decoded.length > 0 && isGrouplessType(decoded[0])) {
             const group = defaultGroupOfGrouplessAddress(decoded.slice(2, decoded.length - 4));
             const groupByte = codec_2.byteCodec.encode(group);
             return new Uint8Array([...decoded, ...groupByte]);
@@ -161,12 +150,15 @@ function isAssetAddress(address) {
     return (addressType === AddressType.P2PKH ||
         addressType === AddressType.P2MPKH ||
         addressType === AddressType.P2SH ||
-        addressType === AddressType.P2PK);
+        addressType === AddressType.P2PK ||
+        addressType === AddressType.P2HMPK);
 }
 exports.isAssetAddress = isAssetAddress;
+function isGrouplessType(type) {
+    return type === AddressType.P2PK || type === AddressType.P2HMPK;
+}
 function isGrouplessAddress(address) {
-    const addressType = decodeAndValidateAddress(address)[0];
-    return addressType === AddressType.P2PK;
+    return isGrouplessType(decodeAndValidateAddress(address)[0]);
 }
 exports.isGrouplessAddress = isGrouplessAddress;
 function isGrouplessAddressWithoutGroupIndex(address) {
@@ -177,8 +169,8 @@ function isGrouplessAddressWithGroupIndex(address) {
     return hasExplicitGroupIndex(address) && isGrouplessAddress(address);
 }
 exports.isGrouplessAddressWithGroupIndex = isGrouplessAddressWithGroupIndex;
-function defaultGroupOfGrouplessAddress(pubKey) {
-    return pubKey[pubKey.length - 1] & 0xff % constants_1.TOTAL_NUMBER_OF_GROUPS;
+function defaultGroupOfGrouplessAddress(bytes) {
+    return (bytes[bytes.length - 1] & 0xff) % constants_1.TOTAL_NUMBER_OF_GROUPS;
 }
 exports.defaultGroupOfGrouplessAddress = defaultGroupOfGrouplessAddress;
 function isContractAddress(address) {
@@ -190,17 +182,17 @@ function groupOfAddress(address) {
     const decoded = decodeAndValidateAddress(address);
     const addressType = decoded[0];
     const addressBody = decoded.slice(1);
-    if (addressType == AddressType.P2PKH) {
+    if (addressType === AddressType.P2PKH) {
         return groupOfP2pkhAddress(addressBody);
     }
-    else if (addressType == AddressType.P2MPKH) {
+    else if (addressType === AddressType.P2MPKH) {
         return groupOfP2mpkhAddress(addressBody);
     }
-    else if (addressType == AddressType.P2SH) {
+    else if (addressType === AddressType.P2SH) {
         return groupOfP2shAddress(addressBody);
     }
-    else if (addressType == AddressType.P2PK) {
-        return groupOfP2pkAddress(addressBody);
+    else if (isGrouplessType(addressType)) {
+        return groupOfGrouplessAddress(addressBody);
     }
     else {
         // Contract Address
@@ -217,8 +209,8 @@ function groupOfP2pkhAddress(address) {
 function groupOfP2mpkhAddress(address) {
     return groupFromBytes(address.slice(1, 33));
 }
-function groupOfP2pkAddress(address) {
-    return codec_2.byteCodec.decode(address.slice(38, 39)) % constants_1.TOTAL_NUMBER_OF_GROUPS;
+function groupOfGrouplessAddress(address) {
+    return address[address.length - 1] % constants_1.TOTAL_NUMBER_OF_GROUPS;
 }
 // Pay to script hash address
 function groupOfP2shAddress(address) {
@@ -266,10 +258,16 @@ function publicKeyFromPrivateKey(privateKey, _keyType) {
 }
 exports.publicKeyFromPrivateKey = publicKeyFromPrivateKey;
 function p2pkAddressFromPublicKey(publicKey, keyType) {
-    const keyTypeByte = keyType === 'gl-secp256k1' ? 0x00 : keyType === 'gl-secp256r1' ? 0x01 : keyType === 'gl-ed25519' ? 0x02 : 0x03;
-    const publicKeyBytes = new Uint8Array([keyTypeByte, ...(0, utils_1.hexToBinUnsafe)(publicKey)]);
-    const checksum = codec_1.intAs4BytesCodec.encode((0, djb2_1.default)(publicKeyBytes));
-    const bytes = new Uint8Array([AddressType.P2PK, ...publicKeyBytes, ...checksum]);
+    const rawBytes = (0, utils_1.hexToBinUnsafe)(publicKey);
+    const publicKeyLike = keyType === 'gl-secp256k1'
+        ? { kind: 'SecP256K1', value: rawBytes }
+        : keyType === 'gl-secp256r1'
+            ? { kind: 'SecP256R1', value: rawBytes }
+            : keyType === 'gl-ed25519'
+                ? { kind: 'ED25519', value: rawBytes }
+                : { kind: 'WebAuthn', value: rawBytes };
+    const publicKeyBytes = public_key_like_codec_1.safePublicKeyLikeCodec.encode(publicKeyLike);
+    const bytes = new Uint8Array([AddressType.P2PK, ...publicKeyBytes]);
     return bs58_1.default.encode(bytes);
 }
 function addressFromPublicKey(publicKey, _keyType) {
@@ -340,7 +338,7 @@ function groupOfLockupScript(lockupScript) {
     else if (lockupScript.kind === 'P2SH') {
         return groupFromBytes(lockupScript.value);
     }
-    else if (lockupScript.kind === 'P2PK') {
+    else if (lockupScript.kind === 'P2PK' || lockupScript.kind === 'P2HMPK') {
         return lockupScript.value.group % constants_1.TOTAL_NUMBER_OF_GROUPS;
     }
     else {
@@ -372,7 +370,7 @@ function addressWithoutExplicitGroupIndex(address) {
 }
 exports.addressWithoutExplicitGroupIndex = addressWithoutExplicitGroupIndex;
 function addressFromLockupScript(lockupScript) {
-    if (lockupScript.kind === 'P2PK') {
+    if (lockupScript.kind === 'P2PK' || lockupScript.kind === 'P2HMPK') {
         const groupByte = lockup_script_codec_1.lockupScriptCodec.encode(lockupScript).slice(-1);
         const address = bs58_1.default.encode(lockup_script_codec_1.lockupScriptCodec.encode(lockupScript).slice(0, -1));
         return `${address}:${groupByte}`;

package/dist/src/api/api-alephium.d.ts

@@ -250,26 +250,58 @@ export interface BuildExecuteScriptTx {
     group?: number;
     /** @format double */
     gasEstimationMultiplier?: number;
+    /** @format uint256 */
+    dustAmount?: string;
 }
 /** BuildExecuteScriptTxResult */
 export type BuildExecuteScriptTxResult = BuildGrouplessExecuteScriptTxResult | BuildSimpleExecuteScriptTxResult;
 /** BuildGrouplessDeployContractTxResult */
 export interface BuildGrouplessDeployContractTxResult {
-    transferTxs: BuildSimpleTransferTxResult[];
-    deployContractTx: BuildSimpleDeployContractTxResult;
-    type: string;
+    /** @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;
+    fundingTxs?: BuildSimpleTransferTxResult[];
 }
 /** BuildGrouplessExecuteScriptTxResult */
 export interface BuildGrouplessExecuteScriptTxResult {
-    transferTxs: BuildSimpleTransferTxResult[];
-    executeScriptTx: BuildSimpleExecuteScriptTxResult;
-    type: string;
+    /** @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;
+    fundingTxs?: BuildSimpleTransferTxResult[];
 }
 /** BuildGrouplessTransferTxResult */
 export interface BuildGrouplessTransferTxResult {
-    transferTxs: BuildSimpleTransferTxResult[];
-    transferTx: BuildSimpleTransferTxResult;
-    type: string;
+    unsignedTx: string;
+    /** @format gas */
+    gasAmount: number;
+    /** @format uint256 */
+    gasPrice: string;
+    /** @format 32-byte-hash */
+    txId: string;
+    /** @format int32 */
+    fromGroup: number;
+    /** @format int32 */
+    toGroup: number;
+    fundingTxs?: BuildSimpleTransferTxResult[];
 }
 /** BuildInfo */
 export interface BuildInfo {
@@ -289,17 +321,24 @@ export interface BuildMultisig {
     /** @format address */
     fromAddress: string;
     fromPublicKeys: string[];
+    fromPublicKeyTypes?: string[];
+    fromPublicKeyIndexes?: number[];
     destinations: Destination[];
     /** @format gas */
     gas?: number;
     /** @format uint256 */
     gasPrice?: string;
+    /** @format group-index */
+    group?: number;
+    multiSigType?: 'P2HMPK' | 'P2MPKH';
 }
 /** BuildMultisigAddress */
 export interface BuildMultisigAddress {
     keys: string[];
+    keyTypes?: string[];
     /** @format int32 */
     mrequired: number;
+    multiSigType?: 'P2HMPK' | 'P2MPKH';
 }
 /** BuildMultisigAddressResult */
 export interface BuildMultisigAddressResult {
@@ -321,7 +360,6 @@ export interface BuildSimpleDeployContractTxResult {
     txId: string;
     /** @format address */
     contractAddress: string;
-    type: string;
 }
 /** BuildSimpleExecuteScriptTxResult */
 export interface BuildSimpleExecuteScriptTxResult {
@@ -337,7 +375,6 @@ export interface BuildSimpleExecuteScriptTxResult {
     /** @format 32-byte-hash */
     txId: string;
     simulationResult: SimulationResult;
-    type: string;
 }
 /** BuildSimpleTransferTxResult */
 export interface BuildSimpleTransferTxResult {
@@ -352,12 +389,13 @@ export interface BuildSimpleTransferTxResult {
     fromGroup: number;
     /** @format int32 */
     toGroup: number;
-    type: string;
 }
 /** BuildSweepAddressTransactions */
 export interface BuildSweepAddressTransactions {
-    /** @format public-key */
+    /** @format hex-string */
     fromPublicKey: string;
+    /** @format hex-string */
+    fromPublicKeyType?: string;
     /** @format address */
     toAddress: string;
     /** @format uint256 */
@@ -372,6 +410,8 @@ export interface BuildSweepAddressTransactions {
     targetBlockHash?: string;
     /** @format int32 */
     utxosLimit?: number;
+    /** @format group-index */
+    group?: number;
 }
 /** BuildSweepAddressTransactionsResult */
 export interface BuildSweepAddressTransactionsResult {
@@ -386,6 +426,8 @@ export interface BuildSweepMultisig {
     /** @format address */
     fromAddress: string;
     fromPublicKeys: string[];
+    fromPublicKeyTypes?: string[];
+    fromPublicKeyIndexes?: number[];
     /** @format address */
     toAddress: string;
     /** @format uint256 */
@@ -400,6 +442,9 @@ export interface BuildSweepMultisig {
     utxosLimit?: number;
     /** @format block-hash */
     targetBlockHash?: string;
+    /** @format group-index */
+    group?: number;
+    multiSigType?: 'P2HMPK' | 'P2MPKH';
 }
 /** BuildTransferTx */
 export interface BuildTransferTx {
@@ -551,6 +596,7 @@ export interface CompilerOptions {
     ignoreCheckExternalCallerWarnings?: boolean;
     ignoreUnusedFunctionReturnWarnings?: boolean;
     skipAbstractContractCheck?: boolean;
+    skipTests?: boolean;
 }
 /** Confirmed */
 export interface Confirmed {
@@ -914,6 +960,8 @@ export interface RichAssetInput {
     /** @format address */
     address: string;
     tokens: Token[];
+    /** @format 32-byte-hash */
+    outputRefTxId: string;
 }
 /** RichBlockAndEvents */
 export interface RichBlockAndEvents {
@@ -960,6 +1008,8 @@ export interface RichContractInput {
     /** @format address */
     address: string;
     tokens: Token[];
+    /** @format 32-byte-hash */
+    outputRefTxId: string;
 }
 /** RichTransaction */
 export interface RichTransaction {
@@ -1115,6 +1165,7 @@ export interface TestContract {
     args?: Val[];
     existingContracts?: ContractState[];
     inputAssets?: TestInputAsset[];
+    /** @format uint256 */
     dustAmount?: string;
 }
 /** TestContractResult */
@@ -1376,7 +1427,7 @@ export declare class HttpClient<SecurityDataType = unknown> {
 }
 /**
  * @title Alephium API
- * @version 3.12.2
+ * @version 4.0.0
  * @baseUrl ../
  */
 export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
@@ -2212,7 +2263,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @summary Build a multisig unsigned transaction
          * @request POST:/multisig/build
          */
-        postMultisigBuild: (data: BuildMultisig, params?: RequestParams) => Promise<BuildSimpleTransferTxResult>;
+        postMultisigBuild: (data: BuildMultisig, params?: RequestParams) => Promise<BuildSimpleTransferTxResult | BuildGrouplessTransferTxResult>;
         /**
          * No description
          *

package/dist/src/api/api-alephium.js

@@ -151,7 +151,7 @@ class HttpClient {
 exports.HttpClient = HttpClient;
 /**
  * @title Alephium API
- * @version 3.12.2
+ * @version 4.0.0
  * @baseUrl ../
  */
 class Api extends HttpClient {

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

@@ -18,7 +18,7 @@ export declare function toApiNumber256(v: Val): string;
 export declare function toApiNumber256Optional(v?: Val): string | undefined;
 export declare function fromApiNumber256(n: string): bigint;
 export declare function toApiByteVec(v: Val): string;
-export declare function toApiAddress(v0: Val): string;
+export declare function toApiAddress(v: Val): string;
 export declare function toApiArray(tpe: string, v: Val): node.Val;
 export declare function toApiVal(v: Val, tpe: string): node.Val;
 export declare function fromApiPrimitiveVal(value: node.Val, tpe: string, systemEvent?: boolean): Val;

package/dist/src/api/types.js

@@ -18,7 +18,6 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StdInterfaceIds = exports.request = exports.requestWithLog = exports.forwardRequests = exports.getDefaultPrimitiveValue = exports.decodeArrayType = exports.fromApiPrimitiveVal = exports.toApiVal = exports.toApiArray = exports.toApiAddress = exports.toApiByteVec = exports.fromApiNumber256 = exports.toApiNumber256Optional = exports.toApiNumber256 = exports.toApiBoolean = exports.fromApiTokens = exports.fromApiToken = exports.toApiTokens = exports.toApiToken = exports.PrimitiveTypes = void 0;
-const address_1 = require("../address");
 const constants_1 = require("../constants");
 const debug_1 = require("../debug");
 const error_1 = require("../error");
@@ -92,19 +91,15 @@ function toApiByteVec(v) {
     throw new Error(`Invalid hex-string: ${v}`);
 }
 exports.toApiByteVec = toApiByteVec;
-function toApiAddress(v0) {
-    if (typeof v0 === 'string') {
-        let v = v0;
-        if ((0, address_1.hasExplicitGroupIndex)(v)) {
-            v = v.slice(0, -2);
-        }
+function toApiAddress(v) {
+    if (typeof v === 'string') {
         if ((0, utils_1.isBase58)(v)) {
-            return v0;
+            return v;
         }
-        throw new Error(`Invalid base58 string: ${v0}`);
+        throw new Error(`Invalid base58 string: ${v}`);
     }
     else {
-        throw new Error(`Invalid value: ${v0}, expected a base58 string`);
+        throw new Error(`Invalid value: ${v}, expected a base58 string`);
     }
 }
 exports.toApiAddress = toApiAddress;

package/dist/src/codec/checksum-codec.d.ts

@@ -0,0 +1,8 @@
+import { Reader } from './reader';
+import { Codec } from './codec';
+export declare class Checksum<T> extends Codec<T> {
+    private rawCodec;
+    constructor(rawCodec: Codec<T>);
+    encode(value: T): Uint8Array;
+    _decode(input: Reader): T;
+}

package/dist/src/codec/checksum-codec.js

@@ -0,0 +1,50 @@
+"use strict";
+/*
+Copyright 2018 - 2022 The Alephium Authors
+This file is part of the alephium project.
+
+The library is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+The library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Lesser General Public License for more details.
+
+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/>.
+*/
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Checksum = void 0;
+const utils_1 = require("../utils");
+const djb2_1 = __importDefault(require("../utils/djb2"));
+const int_as_4bytes_codec_1 = require("./int-as-4bytes-codec");
+const codec_1 = require("./codec");
+class Checksum extends codec_1.Codec {
+    constructor(rawCodec) {
+        super();
+        this.rawCodec = rawCodec;
+    }
+    encode(value) {
+        const rawEncoded = this.rawCodec.encode(value);
+        const checksum = int_as_4bytes_codec_1.intAs4BytesCodec.encode((0, djb2_1.default)(rawEncoded));
+        return (0, utils_1.concatBytes)([rawEncoded, checksum]);
+    }
+    _decode(input) {
+        const fromIndex = input.getIndex();
+        const rawDecoded = this.rawCodec._decode(input);
+        const toIndex = input.getIndex();
+        const checksum = int_as_4bytes_codec_1.intAs4BytesCodec._decode(input);
+        const expected = (0, djb2_1.default)(input.getBytes(fromIndex, toIndex));
+        if (expected != checksum) {
+            throw new Error(`Invalid checksum: expected ${expected}, but got ${checksum}`);
+        }
+        return rawDecoded;
+    }
+}
+exports.Checksum = Checksum;

package/dist/src/codec/instr-codec.d.ts

@@ -180,19 +180,19 @@ export type Instr = {
     name: 'U256ModMul';
     code: 0x37;
 } | {
-    name: 'NumericBitAnd';
+    name: 'U256BitAnd';
     code: 0x38;
 } | {
-    name: 'NumericBitOr';
+    name: 'U256BitOr';
     code: 0x39;
 } | {
-    name: 'NumericXor';
+    name: 'U256Xor';
     code: 0x3a;
 } | {
-    name: 'NumericSHL';
+    name: 'U256SHL';
     code: 0x3b;
 } | {
-    name: 'NumericSHR';
+    name: 'U256SHR';
     code: 0x3c;
 } | {
     name: 'I256ToU256';
@@ -438,12 +438,6 @@ export type Instr = {
 } | {
     name: 'GroupOfAddress';
     code: 0x8c;
-} | {
-    name: 'VerifySignature';
-    code: 0x8d;
-} | {
-    name: 'GetSegregatedWebAuthnSignature';
-    code: 0x8e;
 } | {
     name: 'LoadMutField';
     code: 0xa0;
@@ -610,12 +604,6 @@ export type Instr = {
     name: 'CallExternalBySelector';
     code: 0xd4;
     selector: number;
-} | {
-    name: 'ExternalCallerContractId';
-    code: 0xd5;
-} | {
-    name: 'ExternalCallerAddress';
-    code: 0xd6;
 };
 export declare const CallLocalCode = 0;
 export declare const CallExternalCode = 1;
@@ -691,11 +679,11 @@ export declare const U256Ge: Instr;
 export declare const U256ModAdd: Instr;
 export declare const U256ModSub: Instr;
 export declare const U256ModMul: Instr;
-export declare const NumericBitAnd: Instr;
-export declare const NumericBitOr: Instr;
-export declare const NumericXor: Instr;
-export declare const NumericSHL: Instr;
-export declare const NumericSHR: Instr;
+export declare const U256BitAnd: Instr;
+export declare const U256BitOr: Instr;
+export declare const U256Xor: Instr;
+export declare const U256SHL: Instr;
+export declare const U256SHR: Instr;
 export declare const I256ToU256: Instr;
 export declare const I256ToByteVec: Instr;
 export declare const U256ToI256: Instr;
@@ -776,8 +764,6 @@ export declare const U256ToString: Instr;
 export declare const I256ToString: Instr;
 export declare const BoolToString: Instr;
 export declare const GroupOfAddress: Instr;
-export declare const VerifySignature: Instr;
-export declare const GetSegregatedWebAuthnSignature: Instr;
 export declare const LoadMutField: (index: number) => Instr;
 export declare const StoreMutField: (index: number) => Instr;
 export declare const ApproveAlph: Instr;
@@ -831,8 +817,6 @@ export declare const MinimalContractDeposit: Instr;
 export declare const CreateMapEntry: (immFieldsNum: number, mutFieldsNum: number) => Instr;
 export declare const MethodSelector: (selector: number) => Instr;
 export declare const CallExternalBySelector: (selector: number) => Instr;
-export declare const ExternalCallerContractId: Instr;
-export declare const ExternalCallerAddress: Instr;
 export declare class InstrCodec extends Codec<Instr> {
     encode(instr: Instr): Uint8Array;
     _decode(input: Reader): Instr;