@alephium/web3 1.11.7 → 1.12.0-danube.0

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

@@ -4,11 +4,17 @@ export declare enum AddressType {
     P2PKH = 0,
     P2MPKH = 1,
     P2SH = 2,
-    P2C = 3
+    P2C = 3,
+    P2PK = 4
 }
 export declare function validateAddress(address: string): void;
 export declare function isValidAddress(address: string): boolean;
+export declare function addressToBytes(address: string): Uint8Array;
 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 isContractAddress(address: string): boolean;
 export declare function groupOfAddress(address: string): number;
 export declare function contractIdFromAddress(address: string): Uint8Array;
@@ -22,3 +28,8 @@ export declare function addressFromTokenId(tokenId: string): string;
 export declare function contractIdFromTx(txId: string, outputIndex: number): string;
 export declare function subContractId(parentContractId: string, pathInHex: string, group: number): string;
 export declare function groupOfLockupScript(lockupScript: LockupScript): number;
+export declare function groupFromBytes(bytes: Uint8Array): number;
+export declare function groupFromHint(hint: number): number;
+export declare function hasExplicitGroupIndex(address: string): boolean;
+export declare function addressWithoutExplicitGroupIndex(address: string): string;
+export declare function addressFromLockupScript(lockupScript: LockupScript): string;

package/dist/src/address/address.js

@@ -43,7 +43,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.groupOfLockupScript = exports.subContractId = exports.contractIdFromTx = exports.addressFromTokenId = exports.addressFromContractId = exports.addressFromScript = exports.addressFromPublicKey = exports.publicKeyFromPrivateKey = exports.groupOfPrivateKey = exports.tokenIdFromAddress = exports.contractIdFromAddress = exports.groupOfAddress = exports.isContractAddress = exports.isAssetAddress = exports.isValidAddress = exports.validateAddress = exports.AddressType = void 0;
+exports.addressFromLockupScript = exports.addressWithoutExplicitGroupIndex = exports.hasExplicitGroupIndex = exports.groupFromHint = exports.groupFromBytes = exports.groupOfLockupScript = exports.subContractId = exports.contractIdFromTx = exports.addressFromTokenId = exports.addressFromContractId = exports.addressFromScript = exports.addressFromPublicKey = exports.publicKeyFromPrivateKey = exports.groupOfPrivateKey = exports.tokenIdFromAddress = exports.contractIdFromAddress = exports.groupOfAddress = exports.isContractAddress = exports.defaultGroupOfGrouplessAddress = exports.isGrouplessAddressWithGroupIndex = exports.isGrouplessAddressWithoutGroupIndex = exports.isGrouplessAddress = exports.isAssetAddress = exports.addressToBytes = exports.isValidAddress = exports.validateAddress = exports.AddressType = void 0;
 const elliptic_1 = require("elliptic");
 const bn_js_1 = __importDefault(require("bn.js"));
 const constants_1 = require("../constants");
@@ -54,6 +54,7 @@ const lockup_script_codec_1 = require("../codec/lockup-script-codec");
 const codec_1 = require("../codec");
 const djb2_1 = __importDefault(require("../utils/djb2"));
 const error_1 = require("../error");
+const codec_2 = require("../codec/codec");
 const ec = new elliptic_1.ec('secp256k1');
 const PublicKeyHashSize = 32;
 var AddressType;
@@ -62,6 +63,7 @@ var AddressType;
     AddressType[AddressType["P2MPKH"] = 1] = "P2MPKH";
     AddressType[AddressType["P2SH"] = 2] = "P2SH";
     AddressType[AddressType["P2C"] = 3] = "P2C";
+    AddressType[AddressType["P2PK"] = 4] = "P2PK";
 })(AddressType = exports.AddressType || (exports.AddressType = {}));
 function validateAddress(address) {
     decodeAndValidateAddress(address);
@@ -78,7 +80,7 @@ function isValidAddress(address) {
 }
 exports.isValidAddress = isValidAddress;
 function decodeAndValidateAddress(address) {
-    const decoded = (0, bs58_1.base58ToBytes)(address);
+    const decoded = addressToBytes(address);
     if (decoded.length === 0)
         throw new Error('Address is empty');
     const addressType = decoded[0];
@@ -106,13 +108,68 @@ function decodeAndValidateAddress(address) {
         if (decoded.length === 33)
             return decoded;
     }
+    else if (addressType === AddressType.P2PK) {
+        if (decoded.length === 40) {
+            // [type, keyType, ...publicKey, ...checkSum, ...groupByte]
+            const publicKeyLikeBytes = decoded.slice(1, 35);
+            const checksum = (0, utils_1.binToHex)(decoded.slice(35, 39));
+            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(39, 40));
+            validateGroupIndex(group);
+            return decoded;
+        }
+    }
     throw new Error(`Invalid address: ${address}`);
 }
+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 (decoded[0] === 0x04 && decoded.length === 39) {
+            const groupByte = codec_2.byteCodec.encode(groupIndex);
+            return new Uint8Array([...decoded, ...groupByte]);
+        }
+        throw new Error(`Invalid groupless address: ${address}`);
+    }
+    else {
+        const decoded = (0, bs58_1.base58ToBytes)(address);
+        if (decoded[0] === 0x04 && decoded.length === 39) {
+            const group = defaultGroupOfGrouplessAddress(decoded.slice(2, 35));
+            const groupByte = codec_2.byteCodec.encode(group);
+            return new Uint8Array([...decoded, ...groupByte]);
+        }
+        return decoded;
+    }
+}
+exports.addressToBytes = addressToBytes;
 function isAssetAddress(address) {
     const addressType = decodeAndValidateAddress(address)[0];
-    return addressType === AddressType.P2PKH || addressType === AddressType.P2MPKH || addressType === AddressType.P2SH;
+    return (addressType === AddressType.P2PKH ||
+        addressType === AddressType.P2MPKH ||
+        addressType === AddressType.P2SH ||
+        addressType === AddressType.P2PK);
 }
 exports.isAssetAddress = isAssetAddress;
+function isGrouplessAddress(address) {
+    const addressType = decodeAndValidateAddress(address)[0];
+    return addressType === AddressType.P2PK;
+}
+exports.isGrouplessAddress = isGrouplessAddress;
+function isGrouplessAddressWithoutGroupIndex(address) {
+    return !hasExplicitGroupIndex(address) && isGrouplessAddress(address);
+}
+exports.isGrouplessAddressWithoutGroupIndex = isGrouplessAddressWithoutGroupIndex;
+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;
+}
+exports.defaultGroupOfGrouplessAddress = defaultGroupOfGrouplessAddress;
 function isContractAddress(address) {
     const addressType = decodeAndValidateAddress(address)[0];
     return addressType === AddressType.P2C;
@@ -131,6 +188,9 @@ function groupOfAddress(address) {
     else if (addressType == AddressType.P2SH) {
         return groupOfP2shAddress(addressBody);
     }
+    else if (addressType == AddressType.P2PK) {
+        return groupOfP2pkAddress(addressBody);
+    }
     else {
         // Contract Address
         const id = contractIdFromAddress(address);
@@ -140,15 +200,18 @@ function groupOfAddress(address) {
 exports.groupOfAddress = groupOfAddress;
 // Pay to public key hash address
 function groupOfP2pkhAddress(address) {
-    return groupFromBytesForAssetAddress(address);
+    return groupFromBytes(address);
 }
 // Pay to multiple public key hash address
 function groupOfP2mpkhAddress(address) {
-    return groupFromBytesForAssetAddress(address.slice(1, 33));
+    return groupFromBytes(address.slice(1, 33));
+}
+function groupOfP2pkAddress(address) {
+    return codec_2.byteCodec.decode(address.slice(38, 39)) % constants_1.TOTAL_NUMBER_OF_GROUPS;
 }
 // Pay to script hash address
 function groupOfP2shAddress(address) {
-    return groupFromBytesForAssetAddress(address);
+    return groupFromBytes(address);
 }
 function contractIdFromAddress(address) {
     return idFromAddress(address);
@@ -177,7 +240,7 @@ function groupOfPrivateKey(privateKey, keyType) {
 exports.groupOfPrivateKey = groupOfPrivateKey;
 function publicKeyFromPrivateKey(privateKey, _keyType) {
     const keyType = _keyType ?? 'default';
-    if (keyType === 'default') {
+    if (keyType === 'default' || keyType === 'gl-secp256k1') {
         const key = ec.keyFromPrivate(privateKey);
         return key.getPublic(true, 'hex');
     }
@@ -193,6 +256,12 @@ function addressFromPublicKey(publicKey, _keyType) {
         const bytes = new Uint8Array([AddressType.P2PKH, ...hash]);
         return bs58_1.default.encode(bytes);
     }
+    else if (keyType === 'gl-secp256k1') {
+        const publicKeyBytes = new Uint8Array([0x00, ...(0, utils_1.hexToBinUnsafe)(publicKey)]);
+        const hashBytes = codec_1.intAs4BytesCodec.encode((0, djb2_1.default)(publicKeyBytes));
+        const bytes = new Uint8Array([0x04, ...publicKeyBytes, ...hashBytes]);
+        return bs58_1.default.encode(bytes);
+    }
     else {
         const lockupScript = (0, utils_1.hexToBinUnsafe)(`0101000000000458144020${publicKey}8685`);
         return addressFromScript(lockupScript);
@@ -242,13 +311,16 @@ function subContractId(parentContractId, pathInHex, group) {
 exports.subContractId = subContractId;
 function groupOfLockupScript(lockupScript) {
     if (lockupScript.kind === 'P2PKH') {
-        return groupFromBytesForAssetAddress(lockupScript.value);
+        return groupFromBytes(lockupScript.value);
     }
     else if (lockupScript.kind === 'P2MPKH') {
-        return groupFromBytesForAssetAddress(lockupScript.value.publicKeyHashes[0]);
+        return groupFromBytes(lockupScript.value.publicKeyHashes[0]);
     }
     else if (lockupScript.kind === 'P2SH') {
-        return groupFromBytesForAssetAddress(lockupScript.value);
+        return groupFromBytes(lockupScript.value);
+    }
+    else if (lockupScript.kind === 'P2PK') {
+        return lockupScript.value.group % constants_1.TOTAL_NUMBER_OF_GROUPS;
     }
     else {
         // P2C
@@ -257,8 +329,44 @@ function groupOfLockupScript(lockupScript) {
     }
 }
 exports.groupOfLockupScript = groupOfLockupScript;
-function groupFromBytesForAssetAddress(bytes) {
+function groupFromBytes(bytes) {
     const hint = (0, djb2_1.default)(bytes) | 1;
+    return groupFromHint(hint);
+}
+exports.groupFromBytes = groupFromBytes;
+function groupFromHint(hint) {
     const hash = (0, utils_1.xorByte)(hint);
     return hash % constants_1.TOTAL_NUMBER_OF_GROUPS;
 }
+exports.groupFromHint = groupFromHint;
+function hasExplicitGroupIndex(address) {
+    return address.length > 2 && address[address.length - 2] === ':';
+}
+exports.hasExplicitGroupIndex = hasExplicitGroupIndex;
+function addressWithoutExplicitGroupIndex(address) {
+    if (hasExplicitGroupIndex(address)) {
+        return address.slice(0, address.length - 2);
+    }
+    return address;
+}
+exports.addressWithoutExplicitGroupIndex = addressWithoutExplicitGroupIndex;
+function addressFromLockupScript(lockupScript) {
+    if (lockupScript.kind === 'P2PK') {
+        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}`;
+    }
+    else {
+        return bs58_1.default.encode(lockup_script_codec_1.lockupScriptCodec.encode(lockupScript));
+    }
+}
+exports.addressFromLockupScript = addressFromLockupScript;
+function parseGroupIndex(groupIndexStr) {
+    return validateGroupIndex(parseInt(groupIndexStr), groupIndexStr);
+}
+function validateGroupIndex(groupIndex, groupIndexStr) {
+    if (isNaN(groupIndex) || groupIndex < 0 || groupIndex >= constants_1.TOTAL_NUMBER_OF_GROUPS) {
+        throw new Error(`Invalid group index: ${groupIndexStr ?? groupIndex}`);
+    }
+    return groupIndex;
+}

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

@@ -176,7 +176,7 @@ export interface BuildChainedDeployContractTx {
 }
 /** BuildChainedDeployContractTxResult */
 export interface BuildChainedDeployContractTxResult {
-    value: BuildDeployContractTxResult;
+    value: BuildSimpleDeployContractTxResult;
     type: string;
 }
 /** BuildChainedExecuteScriptTx */
@@ -186,7 +186,7 @@ export interface BuildChainedExecuteScriptTx {
 }
 /** BuildChainedExecuteScriptTxResult */
 export interface BuildChainedExecuteScriptTxResult {
-    value: BuildExecuteScriptTxResult;
+    value: BuildSimpleExecuteScriptTxResult;
     type: string;
 }
 /** BuildChainedTransferTx */
@@ -196,7 +196,7 @@ export interface BuildChainedTransferTx {
 }
 /** BuildChainedTransferTxResult */
 export interface BuildChainedTransferTxResult {
-    value: BuildTransferTxResult;
+    value: BuildSimpleTransferTxResult;
     type: string;
 }
 /** BuildChainedTx */
@@ -222,25 +222,13 @@ 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 {
     /** @format hex-string */
@@ -258,23 +246,30 @@ 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;
+export type BuildExecuteScriptTxResult = BuildGrouplessExecuteScriptTxResult | BuildSimpleExecuteScriptTxResult;
+/** BuildGrouplessDeployContractTxResult */
+export interface BuildGrouplessDeployContractTxResult {
+    transferTxs: BuildSimpleTransferTxResult[];
+    deployContractTx: BuildSimpleDeployContractTxResult;
+    type: string;
+}
+/** BuildGrouplessExecuteScriptTxResult */
+export interface BuildGrouplessExecuteScriptTxResult {
+    transferTxs: BuildSimpleTransferTxResult[];
+    executeScriptTx: BuildSimpleExecuteScriptTxResult;
+    type: string;
+}
+/** BuildGrouplessTransferTxResult */
+export interface BuildGrouplessTransferTxResult {
+    transferTxs: BuildSimpleTransferTxResult[];
+    transferTx: BuildSimpleTransferTxResult;
+    type: string;
 }
 /** BuildInfo */
 export interface BuildInfo {
@@ -311,6 +306,54 @@ export interface BuildMultisigAddressResult {
     /** @format address */
     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 */
@@ -370,23 +413,13 @@ 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 {
     /** @format int32 */
@@ -1082,6 +1115,7 @@ export interface TestContract {
     args?: Val[];
     existingContracts?: ContractState[];
     inputAssets?: TestInputAsset[];
+    dustAmount?: string;
 }
 /** TestContractResult */
 export interface TestContractResult {
@@ -1858,7 +1892,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @summary Build an unsigned transfer transaction to a number of recipients
          * @request POST:/transactions/build
          */
-        postTransactionsBuild: (data: BuildTransferTx, params?: RequestParams) => Promise<BuildTransferTxResult>;
+        postTransactionsBuild: (data: BuildTransferTx, params?: RequestParams) => Promise<BuildSimpleTransferTxResult | BuildGrouplessTransferTxResult>;
         /**
          * No description
          *
@@ -1867,7 +1901,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @summary Build unsigned transfer transactions from an address of one group to addresses of many groups. Each target group requires a dedicated transaction or more in case large number of outputs needed to be split.
          * @request POST:/transactions/build-transfer-from-one-to-many-groups
          */
-        postTransactionsBuildTransferFromOneToManyGroups: (data: BuildTransferTx, params?: RequestParams) => Promise<BuildTransferTxResult[]>;
+        postTransactionsBuildTransferFromOneToManyGroups: (data: BuildTransferTx, params?: RequestParams) => Promise<BuildSimpleTransferTxResult[]>;
         /**
          * No description
          *
@@ -1876,7 +1910,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @summary Build an unsigned transaction with multiple addresses to a number of recipients
          * @request POST:/transactions/build-multi-addresses
          */
-        postTransactionsBuildMultiAddresses: (data: BuildMultiAddressesTransaction, params?: RequestParams) => Promise<BuildTransferTxResult>;
+        postTransactionsBuildMultiAddresses: (data: BuildMultiAddressesTransaction, params?: RequestParams) => Promise<BuildSimpleTransferTxResult>;
         /**
          * No description
          *
@@ -2045,7 +2079,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @summary Build an unsigned script
          * @request POST:/contracts/unsigned-tx/execute-script
          */
-        postContractsUnsignedTxExecuteScript: (data: BuildExecuteScriptTx, params?: RequestParams) => Promise<BuildExecuteScriptTxResult>;
+        postContractsUnsignedTxExecuteScript: (data: BuildExecuteScriptTx, params?: RequestParams) => Promise<BuildSimpleExecuteScriptTxResult | BuildGrouplessExecuteScriptTxResult>;
         /**
          * No description
          *
@@ -2072,7 +2106,7 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          * @summary Build an unsigned contract
          * @request POST:/contracts/unsigned-tx/deploy-contract
          */
-        postContractsUnsignedTxDeployContract: (data: BuildDeployContractTx, params?: RequestParams) => Promise<BuildDeployContractTxResult>;
+        postContractsUnsignedTxDeployContract: (data: BuildDeployContractTx, params?: RequestParams) => Promise<BuildSimpleDeployContractTxResult | BuildGrouplessDeployContractTxResult>;
         /**
          * No description
          *
@@ -2178,7 +2212,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<BuildTransferTxResult>;
+        postMultisigBuild: (data: BuildMultisig, params?: RequestParams) => Promise<BuildSimpleTransferTxResult>;
         /**
          * No description
          *

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(v: Val): string;
+export declare function toApiAddress(v0: 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,6 +18,7 @@ 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");
@@ -91,15 +92,19 @@ function toApiByteVec(v) {
     throw new Error(`Invalid hex-string: ${v}`);
 }
 exports.toApiByteVec = toApiByteVec;
-function toApiAddress(v) {
-    if (typeof v === 'string') {
+function toApiAddress(v0) {
+    if (typeof v0 === 'string') {
+        let v = v0;
+        if ((0, address_1.hasExplicitGroupIndex)(v)) {
+            v = v.slice(0, -2);
+        }
         if ((0, utils_1.isBase58)(v)) {
-            return v;
+            return v0;
         }
-        throw new Error(`Invalid base58 string: ${v}`);
+        throw new Error(`Invalid base58 string: ${v0}`);
     }
     else {
-        throw new Error(`Invalid value: ${v}, expected a base58 string`);
+        throw new Error(`Invalid value: ${v0}, expected a base58 string`);
     }
 }
 exports.toApiAddress = toApiAddress;

package/dist/src/codec/lockup-script-codec.d.ts

@@ -1,13 +1,19 @@
-import { EnumCodec } from './codec';
+import { EnumCodec, FixedSizeCodec } from './codec';
 export type PublicKeyHash = Uint8Array;
 export type P2PKH = Uint8Array;
 export type P2SH = Uint8Array;
 export type P2C = Uint8Array;
-export declare const p2cCodec: import("./codec").FixedSizeCodec;
+export declare const p2cCodec: FixedSizeCodec;
 export interface P2MPKH {
     publicKeyHashes: PublicKeyHash[];
     m: number;
 }
+export interface P2PC {
+    type: number;
+    publicKey: Uint8Array;
+    checkSum: Uint8Array;
+    group: number;
+}
 export type LockupScript = {
     kind: 'P2PKH';
     value: P2PKH;
@@ -20,5 +26,8 @@ export type LockupScript = {
 } | {
     kind: 'P2C';
     value: P2C;
+} | {
+    kind: 'P2PK';
+    value: P2PC;
 };
 export declare const lockupScriptCodec: EnumCodec<LockupScript>;

package/dist/src/codec/lockup-script-codec.js

@@ -26,9 +26,16 @@ const p2mpkhCodec = new codec_1.ObjectCodec({
     publicKeyHashes: new array_codec_1.ArrayCodec(codec_1.byte32Codec),
     m: compact_int_codec_1.i32Codec
 });
+const p2pkCodec = new codec_1.ObjectCodec({
+    type: codec_1.byteCodec,
+    publicKey: new codec_1.FixedSizeCodec(33),
+    checkSum: new codec_1.FixedSizeCodec(4),
+    group: codec_1.byteCodec
+});
 exports.lockupScriptCodec = new codec_1.EnumCodec('lockup script', {
     P2PKH: codec_1.byte32Codec,
     P2MPKH: p2mpkhCodec,
     P2SH: codec_1.byte32Codec,
-    P2C: codec_1.byte32Codec
+    P2C: codec_1.byte32Codec,
+    P2PK: p2pkCodec
 });

package/dist/src/codec/unlock-script-codec.d.ts

@@ -1,9 +1,9 @@
 import { EnumCodec } from './codec';
 import { Script } from './script-codec';
 import { Val } from './val';
-export type P2PKH = Uint8Array;
+export type PublicKey = Uint8Array;
 export interface KeyWithIndex {
-    publicKey: P2PKH;
+    publicKey: PublicKey;
     index: number;
 }
 export type P2MPKH = KeyWithIndex[];
@@ -12,9 +12,11 @@ export interface P2SH {
     params: Val[];
 }
 export type SameAsPrevious = 'SameAsPrevious';
+export type P2PK = 'P2PK';
+export type KeyType = number;
 export type UnlockScript = {
     kind: 'P2PKH';
-    value: P2PKH;
+    value: PublicKey;
 } | {
     kind: 'P2MPKH';
     value: P2MPKH;
@@ -24,6 +26,12 @@ export type UnlockScript = {
 } | {
     kind: 'SameAsPrevious';
     value: SameAsPrevious;
+} | {
+    kind: 'PoLW';
+    value: PublicKey;
+} | {
+    kind: 'P2PK';
+    value: P2PK;
 };
 export declare const unlockScriptCodec: EnumCodec<UnlockScript>;
 export declare const encodedSameAsPrevious: Uint8Array;

package/dist/src/codec/unlock-script-codec.js

@@ -23,9 +23,9 @@ const compact_int_codec_1 = require("./compact-int-codec");
 const codec_1 = require("./codec");
 const script_codec_1 = require("./script-codec");
 const val_1 = require("./val");
-const p2pkhCodec = new codec_1.FixedSizeCodec(33);
+const publicKeyCodec = new codec_1.FixedSizeCodec(33);
 const keyWithIndexCodec = new codec_1.ObjectCodec({
-    publicKey: p2pkhCodec,
+    publicKey: publicKeyCodec,
     index: compact_int_codec_1.i32Codec
 });
 const p2mpkhCodec = new array_codec_1.ArrayCodec(keyWithIndexCodec);
@@ -41,10 +41,20 @@ const sameAsPreviousCodec = new (class extends codec_1.Codec {
         return 'SameAsPrevious';
     }
 })();
+const p2pkCodec = new (class extends codec_1.Codec {
+    encode() {
+        return new Uint8Array([]);
+    }
+    _decode() {
+        return 'P2PK';
+    }
+})();
 exports.unlockScriptCodec = new codec_1.EnumCodec('unlock script', {
-    P2PKH: p2pkhCodec,
+    P2PKH: publicKeyCodec,
     P2MPKH: p2mpkhCodec,
     P2SH: p2shCodec,
-    SameAsPrevious: sameAsPreviousCodec
+    SameAsPrevious: sameAsPreviousCodec,
+    PoLW: publicKeyCodec,
+    P2PK: p2pkCodec
 });
 exports.encodedSameAsPrevious = exports.unlockScriptCodec.encode({ kind: 'SameAsPrevious', value: 'SameAsPrevious' });