@alephium/web3 1.11.6 → 1.12.0-beta.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,7 @@ 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 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.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,73 @@ 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);
+        return decoded;
+    }
     throw new Error(`Invalid address: ${address}`);
 }
+function isGrouplessAddressWithoutGroup(decoded) {
+    return decoded[0] === AddressType.P2PK && (decoded.length === 38 || decoded.length === 39);
+}
+function isGrouplessAddressWithGroup(decoded) {
+    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)) {
+            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 (isGrouplessAddressWithoutGroup(decoded)) {
+            const group = defaultGroupOfGrouplessAddress(decoded.slice(2, decoded.length - 4));
+            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 +193,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 +205,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 +245,7 @@ function groupOfPrivateKey(privateKey, keyType) {
 exports.groupOfPrivateKey = groupOfPrivateKey;
 function publicKeyFromPrivateKey(privateKey, _keyType) {
     const keyType = _keyType ?? 'default';
-    if (keyType === 'default') {
+    if (keyType === 'default' || keyType === 'groupless') {
         const key = ec.keyFromPrivate(privateKey);
         return key.getPublic(true, 'hex');
     }
@@ -193,6 +261,12 @@ function addressFromPublicKey(publicKey, _keyType) {
         const bytes = new Uint8Array([AddressType.P2PKH, ...hash]);
         return bs58_1.default.encode(bytes);
     }
+    else if (keyType === 'groupless') {
+        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 +316,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 +334,37 @@ 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 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

@@ -276,6 +276,57 @@ export interface BuildExecuteScriptTxResult {
     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;
+}
+/** 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;
+}
+/** BuildGrouplessExecuteScriptTxResult */
+export interface BuildGrouplessExecuteScriptTxResult {
+    transferTxs: BuildTransferTxResult[];
+    executeScriptTx: BuildExecuteScriptTxResult;
+}
+/** BuildGrouplessTransferTx */
+export interface BuildGrouplessTransferTx {
+    fromAddress: string;
+    destinations: Destination[];
+    /** @format uint256 */
+    gasPrice?: string;
+    /** @format block-hash */
+    targetBlockHash?: string;
+}
 /** BuildInfo */
 export interface BuildInfo {
     releaseVersion: string;
@@ -2323,5 +2374,34 @@ export declare class Api<SecurityDataType extends unknown> extends HttpClient<Se
          */
         putUtilsCheckHashIndexing: (params?: RequestParams) => Promise<void>;
     };
+    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) => Promise<BuildTransferTxResult[]>;
+        /**
+         * 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) => Promise<BuildGrouplessExecuteScriptTxResult>;
+        /**
+         * 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) => Promise<BuildGrouplessDeployContractTxResult>;
+    };
 }
 export {};

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

@@ -1547,6 +1547,56 @@ class Api extends HttpClient {
                 ...params
             }).then(utils_1.convertHttpResponse)
         };
+        this.groupless = {
+            /**
+             * No description
+             *
+             * @tags Groupless
+             * @name PostGrouplessTransfer
+             * @summary Build unsigned transfer transactions from a groupless address
+             * @request POST:/groupless/transfer
+             */
+            postGrouplessTransfer: (data, params = {}) => this.request({
+                path: `/groupless/transfer`,
+                method: 'POST',
+                body: data,
+                type: ContentType.Json,
+                format: 'json',
+                ...params
+            }).then(utils_1.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, params = {}) => this.request({
+                path: `/groupless/execute-script`,
+                method: 'POST',
+                body: data,
+                type: ContentType.Json,
+                format: 'json',
+                ...params
+            }).then(utils_1.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, params = {}) => this.request({
+                path: `/groupless/deploy-contract`,
+                method: 'POST',
+                body: data,
+                type: ContentType.Json,
+                format: 'json',
+                ...params
+            }).then(utils_1.convertHttpResponse)
+        };
     }
 }
 exports.Api = Api;

package/dist/src/api/node-provider.d.ts

@@ -14,6 +14,7 @@ interface NodeProviderApis {
     utils: NodeApi<string>['utils'];
     miners: NodeApi<string>['miners'];
     events: NodeApi<string>['events'];
+    groupless: NodeApi<string>['groupless'];
 }
 export declare class NodeProvider implements NodeProviderApis {
     readonly wallets: NodeApi<string>['wallets'];
@@ -27,6 +28,7 @@ export declare 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);
     constructor(handler: ApiRequestHandler);

package/dist/src/api/node-provider.js

@@ -185,6 +185,7 @@ class NodeProvider {
         this.utils = { ...nodeApi.utils };
         this.miners = { ...nodeApi.miners };
         this.events = { ...nodeApi.events };
+        this.groupless = { ...nodeApi.groupless };
         (0, types_1.requestWithLog)(this);
     }
     // This can prevent the proxied node provider from being modified

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' });

package/dist/src/contract/contract.d.ts

@@ -84,7 +84,7 @@ export declare class Contract extends Artifact {
     static DebugEventIndex: number;
     static fromApiEvent(event: node.ContractEventByTxId, codeHash: string | undefined, txId: string, getContractByCodeHash: (codeHash: string) => Contract): ContractEvent;
     fromApiTestContractResult(methodName: string, result: node.TestContractResult, txId: string, getContractByCodeHash: (codeHash: string) => Contract): TestContractResult<unknown>;
-    txParamsForDeployment<P extends Fields>(signer: SignerProvider, params: DeployContractParams<P>): Promise<SignDeployContractTxParams>;
+    txParamsForDeployment<P extends Fields>(signer: SignerProvider, params: DeployContractParams<P>, group?: number): Promise<SignDeployContractTxParams>;
     buildByteCodeToDeploy(initialFields: Fields, isDevnet: boolean, exposePrivateFunctions?: boolean): string;
     static fromApiEvents(events: node.ContractEventByTxId[], addressToCodeHash: Map<string, string>, txId: string, getContractByCodeHash: (codeHash: string) => Contract): ContractEvent[];
     toApiCallContract<T extends Arguments>(params: CallContractParams<T>, groupIndex: number, contractAddress: string, methodIndex: number): node.CallContract;
@@ -132,7 +132,7 @@ export type TestContractParamsWithoutMaps<F extends Fields = Fields, A extends A
 export interface TestContractParams<F extends Fields = Fields, A extends Arguments = Arguments, M extends Record<string, Map<Val, Val>> = Record<string, Map<Val, Val>>> {
     group?: number;
     address?: string;
-    callerAddress?: string;
+    callerContractAddress?: string;
     blockHash?: string;
     blockTimeStamp?: number;
     txId?: string;
@@ -195,7 +195,7 @@ export declare abstract class ContractFactory<I extends ContractInstance, F exte
     readonly contract: Contract;
     constructor(contract: Contract);
     abstract at(address: string): I;
-    deploy(signer: SignerProvider, deployParams: DeployContractParams<F>): Promise<DeployContractResult<I>>;
+    deploy(signer: SignerProvider, deployParams: DeployContractParams<F>, group?: number): Promise<DeployContractResult<I>>;
     deployTemplate(signer: SignerProvider): Promise<DeployContractResult<I>>;
     protected stateForTest_(initFields: F, asset?: Asset, address?: string, maps?: Record<string, Map<Val, Val>>): ContractState<F> | ContractStateWithMaps<F>;
 }

package/dist/src/contract/contract.js

@@ -310,7 +310,7 @@ class Contract extends Artifact {
             blockTimeStamp: params.blockTimeStamp,
             txId: params.txId,
             address: params.address,
-            callerContractAddress: params.callerAddress,
+            callerContractAddress: params.callerContractAddress,
             bytecode: this.isInlineFunc(methodIndex) ? this.getByteCodeForTesting() : this.bytecodeDebug,
             initialImmFields: immFields,
             initialMutFields: mutFields,
@@ -382,13 +382,20 @@ class Contract extends Artifact {
             debugMessages: result.debugMessages
         };
     }
-    async txParamsForDeployment(signer, params) {
+    async txParamsForDeployment(signer, params, group) {
         const isDevnet = await this.isDevnet(signer);
         const initialFields = params.initialFields ?? {};
         const bytecode = this.buildByteCodeToDeploy(addStdIdToFields(this, initialFields), isDevnet, params.exposePrivateFunctions ?? false);
         const selectedAccount = await signer.getSelectedAccount();
+        let signerAddress = selectedAccount.address;
+        if ((0, address_1.isGrouplessAddressWithoutGroupIndex)(selectedAccount.address)) {
+            if (group === undefined) {
+                throw new Error('Groupless address requires explicit group number for contract deployment');
+            }
+            signerAddress = `${selectedAccount.address}:${group}`;
+        }
         const signerParams = {
-            signerAddress: selectedAccount.address,
+            signerAddress,
             signerKeyType: selectedAccount.keyType,
             bytecode: bytecode,
             initialAttoAlphAmount: params?.initialAttoAlphAmount,
@@ -678,11 +685,11 @@ class ContractFactory {
     constructor(contract) {
         this.contract = contract;
     }
-    async deploy(signer, deployParams) {
+    async deploy(signer, deployParams, group) {
         const signerParams = await this.contract.txParamsForDeployment(signer, {
             ...deployParams,
             initialFields: addStdIdToFields(this.contract, deployParams.initialFields)
-        });
+        }, group);
         const result = await signer.signAndSubmitDeployContractTx(signerParams);
         return {
             ...result,