cashscript 0.13.0-next.2 → 0.13.0-next.4

package/dist/Contract.d.ts

@@ -1,30 +1,38 @@
-import { Artifact, Script } from '@cashscript/utils';
+import { Artifact } from '@cashscript/utils';
 import { ConstructorArgument } from './Argument.js';
-import { Unlocker, ContractOptions, Utxo, AddressType } from './interfaces.js';
+import { Unlocker, ContractOptions, Utxo, ContractType } from './interfaces.js';
 import NetworkProvider from './network/NetworkProvider.js';
 import { ParamsToTuple, AbiToFunctionMap } from './types/type-inference.js';
-export declare class Contract<TArtifact extends Artifact = Artifact, TResolved extends {
+type ResolvedConstraint = {
     constructorInputs: ConstructorArgument[];
     unlock: Record<string, any>;
-} = {
+};
+type DefaultResolved<TArtifact extends Artifact> = {
     constructorInputs: ParamsToTuple<TArtifact['constructorInputs']>;
     unlock: AbiToFunctionMap<TArtifact['abi'], Unlocker>;
-}> {
+};
+declare class ContractInternal<TArtifact extends Artifact, TResolved extends ResolvedConstraint, TContractType extends ContractType> {
     artifact: TArtifact;
     private options;
     name: string;
     address: string;
     tokenAddress: string;
+    lockingBytecode: string;
     bytecode: string;
     bytesize: number;
     opcount: number;
     unlock: TResolved['unlock'];
-    redeemScript: Script;
     provider: NetworkProvider;
-    addressType: AddressType;
+    contractType: TContractType;
     encodedConstructorArgs: Uint8Array[];
-    constructor(artifact: TArtifact, constructorArgs: TResolved['constructorInputs'], options: ContractOptions);
+    constructor(artifact: TArtifact, constructorArgs: TResolved['constructorInputs'], options: ContractOptions<TContractType>);
     getBalance(): Promise<bigint>;
     getUtxos(): Promise<Utxo[]>;
     private createUnlocker;
 }
+export type Contract<TArtifact extends Artifact = Artifact, TResolved extends ResolvedConstraint = DefaultResolved<TArtifact>, TContractType extends ContractType = ContractType> = [TContractType] extends ['p2s'] ? Omit<ContractInternal<TArtifact, TResolved, TContractType>, 'address' | 'tokenAddress'> : ContractInternal<TArtifact, TResolved, TContractType>;
+interface ContractConstructor {
+    new <TArtifact extends Artifact = Artifact, TResolved extends ResolvedConstraint = DefaultResolved<TArtifact>, TContractType extends ContractType = 'p2sh32'>(artifact: TArtifact, constructorArgs: TResolved['constructorInputs'], options: ContractOptions<TContractType>): Contract<TArtifact, TResolved, TContractType>;
+}
+export declare const Contract: ContractConstructor;
+export {};

package/dist/Contract.js

@@ -1,15 +1,18 @@
-import { binToHex } from '@bitauth/libauth';
-import { asmToScript, calculateBytesize, countOpcodes, generateRedeemScript, hash256, scriptToBytecode, } from '@cashscript/utils';
+import { binToHex, hexToBin } from '@bitauth/libauth';
+import { asmToScript, calculateBytesize, countOpcodes, generateContractBytecodeScript, hash256, scriptToBytecode, } from '@cashscript/utils';
 import { encodeFunctionArgument, encodeConstructorArguments, } from './Argument.js';
-import { addressToLockScript, createInputScript, createSighashPreimage, scriptToAddress, } from './utils.js';
+import { addressToLockScript, createUnlockingBytecode, createSighashPreimage, scriptToAddress, } from './utils.js';
 import SignatureTemplate from './SignatureTemplate.js';
 import semver from 'semver';
-export class Contract {
+class ContractInternal {
     constructor(artifact, constructorArgs, options) {
         this.artifact = artifact;
         this.options = options;
         this.provider = this.options.provider;
-        this.addressType = this.options.addressType ?? 'p2sh32';
+        // Note: technically, it is possible to instantiate a Contract like this, which breaks the type safety,
+        // but it seems unreasonable for anyone to do this
+        // new Contract<any, any, 'p2s'>(artifact), [], { provider })
+        this.contractType = this.options.contractType ?? 'p2sh32';
         const expectedProperties = ['abi', 'bytecode', 'constructorInputs', 'contractName', 'compiler'];
         if (!expectedProperties.every((property) => property in artifact)) {
             throw new Error('Invalid or incomplete artifact provided');
@@ -22,7 +25,6 @@ export class Contract {
         }
         // Encode arguments (this also performs type checking)
         this.encodedConstructorArgs = encodeConstructorArguments(artifact, constructorArgs);
-        this.redeemScript = generateRedeemScript(asmToScript(this.artifact.bytecode), this.encodedConstructorArgs);
         // Populate the 'unlock' object with the contract's functions
         // (with a special case for single function, which has no "function selector")
         this.unlock = {};
@@ -37,18 +39,25 @@ export class Contract {
                 this.unlock[f.name] = this.createUnlocker(f, i);
             });
         }
+        const contractBytecodeScript = generateContractBytecodeScript(asmToScript(this.artifact.bytecode), this.encodedConstructorArgs);
+        if (this.contractType !== 'p2s') {
+            this.address = scriptToAddress(contractBytecodeScript, this.provider.network, this.contractType, false);
+            this.tokenAddress = scriptToAddress(contractBytecodeScript, this.provider.network, this.contractType, true);
+        }
         this.name = artifact.contractName;
-        this.address = scriptToAddress(this.redeemScript, this.provider.network, this.addressType, false);
-        this.tokenAddress = scriptToAddress(this.redeemScript, this.provider.network, this.addressType, true);
-        this.bytecode = binToHex(scriptToBytecode(this.redeemScript));
-        this.bytesize = calculateBytesize(this.redeemScript);
-        this.opcount = countOpcodes(this.redeemScript);
+        this.bytecode = binToHex(scriptToBytecode(contractBytecodeScript));
+        this.lockingBytecode = this.contractType === 'p2s' ? this.bytecode : binToHex(addressToLockScript(this.address));
+        this.bytesize = calculateBytesize(contractBytecodeScript);
+        this.opcount = countOpcodes(contractBytecodeScript);
     }
     async getBalance() {
         const utxos = await this.getUtxos();
         return utxos.reduce((acc, utxo) => acc + utxo.satoshis, 0n);
     }
     async getUtxos() {
+        if (this.contractType === 'p2s') {
+            return this.provider.getUtxosForLockingBytecode(this.bytecode);
+        }
         return this.provider.getUtxos(this.address);
     }
     createUnlocker(abiFunction, selector) {
@@ -56,7 +65,7 @@ export class Contract {
             if (abiFunction.inputs.length !== args.length) {
                 throw new Error(`Incorrect number of arguments passed to function ${abiFunction.name}. Expected ${abiFunction.inputs.length} arguments (${abiFunction.inputs.map((input) => input.type)}) but got ${args.length}`);
             }
-            const bytecode = scriptToBytecode(this.redeemScript);
+            const bytecode = hexToBin(this.bytecode);
             const encodedArgs = args
                 .map((arg, i) => encodeFunctionArgument(arg, abiFunction.inputs[i].type));
             const generateUnlockingBytecode = ({ transaction, sourceOutputs, inputIndex }) => {
@@ -68,7 +77,7 @@ export class Contract {
                     const sighash = hash256(preimage);
                     return arg.generateSignature(sighash);
                 });
-                const unlockingBytecode = createInputScript(this.redeemScript, completeArgs, selector);
+                const unlockingBytecode = createUnlockingBytecode(this.contractType, hexToBin(this.bytecode), completeArgs, selector);
                 return unlockingBytecode;
             };
             const generateLockingBytecode = () => addressToLockScript(this.address);
@@ -76,4 +85,5 @@ export class Contract {
         };
     }
 }
+export const Contract = ContractInternal;
 //# sourceMappingURL=Contract.js.map

package/dist/interfaces.d.ts

@@ -43,6 +43,7 @@ export type StandardUnlocker = ContractUnlocker | P2PKHUnlocker;
 export type PlaceholderP2PKHUnlocker = Unlocker & {
     placeholder: true;
 };
+export type ContractFunctionUnlocker = (...args: FunctionArgument[]) => ContractUnlocker;
 export declare function isContractUnlocker(unlocker: Unlocker): unlocker is ContractUnlocker;
 export declare function isP2PKHUnlocker(unlocker: Unlocker): unlocker is P2PKHUnlocker;
 export declare function isStandardUnlocker(unlocker: Unlocker): unlocker is StandardUnlocker;
@@ -114,9 +115,10 @@ export interface TransactionDetails extends Transaction {
     txid: string;
     hex: string;
 }
-export interface ContractOptions {
+export interface ContractOptions<TContractType extends ContractType = ContractType> {
     provider: NetworkProvider;
-    addressType?: AddressType;
+    contractType?: TContractType;
 }
+export type ContractType = 'p2sh20' | 'p2sh32' | 'p2s';
 export type AddressType = 'p2sh20' | 'p2sh32';
 export type VmResourceUsage = AuthenticationProgramStateResourceLimits['metrics'];

package/dist/libauth-template/LibauthTemplate.js

@@ -180,7 +180,7 @@ const generateTemplateScriptsP2SH = (contract, abiFunction, encodedFunctionArgs,
 };
 const generateTemplateLockScript = (contract, constructorArguments) => {
     return {
-        lockingType: contract.addressType,
+        lockingType: contract.contractType === 'p2s' ? 'standard' : contract.contractType,
         name: contract.artifact.contractName,
         script: [
             `// "${contract.artifact.contractName}" contract constructor parameters`,

package/dist/network/BitcoinRpcNetworkProvider.d.ts

@@ -9,6 +9,7 @@ export default class BitcoinRpcNetworkProvider implements NetworkProvider {
         rpcPassword: string;
     });
     getUtxos(address: string): Promise<Utxo[]>;
+    getUtxosForLockingBytecode(_lockingBytecode: Uint8Array | string): Promise<Utxo[]>;
     getBlockHeight(): Promise<number>;
     getRawTransaction(txid: string): Promise<string>;
     sendRawTransaction(txHex: string): Promise<string>;

package/dist/network/BitcoinRpcNetworkProvider.js

@@ -13,6 +13,9 @@ export default class BitcoinRpcNetworkProvider {
         }));
         return utxos;
     }
+    async getUtxosForLockingBytecode(_lockingBytecode) {
+        throw new Error('BitcoinRpcNetworkProvider does not support getUtxosForLockingBytecode');
+    }
     async getBlockHeight() {
         return this.rpcClient.request('getblockcount');
     }

package/dist/network/ElectrumNetworkProvider.d.ts

@@ -20,6 +20,7 @@ export default class ElectrumNetworkProvider implements NetworkProvider {
     private instantiateElectrumClient;
     private getServerForNetwork;
     getUtxos(address: string): Promise<Utxo[]>;
+    getUtxosForLockingBytecode(lockingBytecode: Uint8Array | string): Promise<Utxo[]>;
     getBlockHeight(): Promise<number>;
     getRawTransaction(txid: string): Promise<string>;
     sendRawTransaction(txHex: string): Promise<string>;

package/dist/network/ElectrumNetworkProvider.js

@@ -1,4 +1,4 @@
-import { binToHex } from '@bitauth/libauth';
+import { binToHex, hexToBin, isHex } from '@bitauth/libauth';
 import { sha256 } from '@cashscript/utils';
 import { ElectrumClient, } from '@electrum-cash/network';
 import { Network } from '../interfaces.js';
@@ -32,9 +32,17 @@ export default class ElectrumNetworkProvider {
         }
     }
     async getUtxos(address) {
-        const scripthash = addressToElectrumScriptHash(address);
+        const lockingBytecode = addressToLockScript(address);
+        return this.getUtxosForLockingBytecode(lockingBytecode);
+    }
+    async getUtxosForLockingBytecode(lockingBytecode) {
+        if (typeof lockingBytecode === 'string' && !isHex(lockingBytecode)) {
+            throw new Error(`Invalid locking bytecode: ${lockingBytecode} is not a valid hex string`);
+        }
+        const lockingBytecodeBin = typeof lockingBytecode === 'string' ? hexToBin(lockingBytecode) : lockingBytecode;
+        const scriptHash = lockingBytecodeToElectrumScriptHash(lockingBytecodeBin);
         const filteringOption = 'include_tokens';
-        const result = await this.performRequest('blockchain.scripthash.listunspent', scripthash, filteringOption);
+        const result = await this.performRequest('blockchain.scripthash.listunspent', scriptHash, filteringOption);
         const utxos = result.map((utxo) => ({
             txid: utxo.tx_hash,
             vout: utxo.tx_pos,
@@ -105,23 +113,9 @@ export default class ElectrumNetworkProvider {
         return true;
     }
 }
-/**
- * Helper function to convert an address to an electrum-cash compatible scripthash.
- * This is necessary to support electrum versions lower than 1.4.3, which do not
- * support addresses, only script hashes.
- *
- * @param address Address to convert to an electrum scripthash
- *
- * @returns The corresponding script hash in an electrum-cash compatible format
- */
-function addressToElectrumScriptHash(address) {
-    // Retrieve locking script
-    const lockScript = addressToLockScript(address);
-    // Hash locking script
-    const scriptHash = sha256(lockScript);
-    // Reverse scripthash
+function lockingBytecodeToElectrumScriptHash(lockingBytecode) {
+    const scriptHash = sha256(lockingBytecode);
     scriptHash.reverse();
-    // Return scripthash as a hex string
     return binToHex(scriptHash);
 }
 //# sourceMappingURL=ElectrumNetworkProvider.js.map

package/dist/network/FullStackNetworkProvider.d.ts

@@ -13,6 +13,7 @@ export default class FullStackNetworkProvider implements NetworkProvider {
      */
     constructor(network: Network, bchjs: BCHJS);
     getUtxos(address: string): Promise<Utxo[]>;
+    getUtxosForLockingBytecode(_lockingBytecode: Uint8Array | string): Promise<Utxo[]>;
     getBlockHeight(): Promise<number>;
     getRawTransaction(txid: string): Promise<string>;
     sendRawTransaction(txHex: string): Promise<string>;

package/dist/network/FullStackNetworkProvider.js

@@ -20,6 +20,9 @@ export default class FullStackNetworkProvider {
         }));
         return utxos;
     }
+    async getUtxosForLockingBytecode(_lockingBytecode) {
+        throw new Error('FullStackNetworkProvider does not support getUtxosForLockingBytecode');
+    }
     async getBlockHeight() {
         return this.bchjs.Blockchain.getBlockCount();
     }

package/dist/network/MockNetworkProvider.d.ts

@@ -13,6 +13,7 @@ export default class MockNetworkProvider implements NetworkProvider {
     vmTarget: VmTarget;
     constructor(options?: Partial<MockNetworkProviderOptions>);
     getUtxos(address: string): Promise<Utxo[]>;
+    getUtxosForLockingBytecode(lockingBytecode: Uint8Array | string): Promise<Utxo[]>;
     setBlockHeight(newBlockHeight: number): void;
     getBlockHeight(): Promise<number>;
     getRawTransaction(txid: string): Promise<string>;

package/dist/network/MockNetworkProvider.js

@@ -14,8 +14,12 @@ export default class MockNetworkProvider {
         this.vmTarget = this.options.vmTarget ?? DEFAULT_VM_TARGET;
     }
     async getUtxos(address) {
-        const addressLockingBytecode = binToHex(addressToLockScript(address));
-        return this.utxoSet.filter(([lockingBytecode]) => lockingBytecode === addressLockingBytecode).map(([, utxo]) => utxo);
+        const addressLockingBytecode = addressToLockScript(address);
+        return this.getUtxosForLockingBytecode(addressLockingBytecode);
+    }
+    async getUtxosForLockingBytecode(lockingBytecode) {
+        const lockingBytecodeHex = typeof lockingBytecode === 'string' ? lockingBytecode : binToHex(lockingBytecode);
+        return this.utxoSet.filter(([key]) => key === lockingBytecodeHex).map(([, utxo]) => utxo);
     }
     setBlockHeight(newBlockHeight) {
         this.blockHeight = newBlockHeight;

package/dist/network/NetworkProvider.d.ts

@@ -10,6 +10,12 @@ export default interface NetworkProvider {
      * @returns List of UTXOs spendable by the provided address.
      */
     getUtxos(address: string): Promise<Utxo[]>;
+    /**
+     * Retrieve all UTXOs (confirmed and unconfirmed) for a given locking bytecode.
+     * @param lockingBytecode The locking bytecode for which we wish to retrieve UTXOs.
+     * @returns List of UTXOs spendable by the provided locking bytecode.
+     */
+    getUtxosForLockingBytecode(lockingBytecode: Uint8Array | string): Promise<Utxo[]>;
     /**
      * @returns The current block height.
      */

package/dist/utils.d.ts

@@ -1,6 +1,6 @@
 import { Transaction } from '@bitauth/libauth';
 import { Script } from '@cashscript/utils';
-import { Utxo, Output, LibauthOutput, TokenDetails, AddressType, UnlockableUtxo, LibauthTokenDetails } from './interfaces.js';
+import { Utxo, Output, LibauthOutput, TokenDetails, AddressType, UnlockableUtxo, LibauthTokenDetails, ContractType } from './interfaces.js';
 export declare function validateInput(utxo: Utxo): void;
 export declare function validateOutput(output: Output): void;
 export declare function calculateDust(output: Output): number;
@@ -12,12 +12,12 @@ export declare function libauthTokenDetailsToCashScriptTokenDetails(token: Libau
 export declare function generateLibauthSourceOutputs(inputs: UnlockableUtxo[]): LibauthOutput[];
 export declare function getInputSize(inputScript: Uint8Array): number;
 export declare function getTxSizeWithoutInputs(outputs: Output[]): number;
-export declare function createInputScript(redeemScript: Script, encodedArgs: Uint8Array[], selector?: number): Uint8Array;
+export declare function createUnlockingBytecode(contractType: ContractType, contractBytecode: Uint8Array, encodedArgs: Uint8Array[], selector?: number): Uint8Array;
 export declare function createOpReturnOutput(opReturnData: string[]): Output;
 export declare function createSighashPreimage(transaction: Transaction, sourceOutputs: LibauthOutput[], inputIndex: number, coveredBytecode: Uint8Array, hashtype: number): Uint8Array;
 export declare function toRegExp(reasons: string[]): RegExp;
 export declare function scriptToAddress(script: Script, network: string, addressType: AddressType, tokenSupport: boolean): string;
-export declare function scriptToLockingBytecode(script: Script, addressType: AddressType): Uint8Array;
+export declare function scriptToP2SHLockingBytecode(script: Script, addressType: AddressType): Uint8Array;
 export declare function publicKeyToP2PKHLockingBytecode(publicKey: Uint8Array): Uint8Array;
 export declare function utxoComparator(a: Utxo, b: Utxo): number;
 export declare function utxoTokenComparator(a: Utxo, b: Utxo): number;

package/dist/utils.js

@@ -123,13 +123,15 @@ export function getTxSizeWithoutInputs(outputs) {
     return size;
 }
 // ////////// BUILD OBJECTS ///////////////////////////////////////////////////
-export function createInputScript(redeemScript, encodedArgs, selector) {
-    // Create unlock script / redeemScriptSig (add potential selector)
+export function createUnlockingBytecode(contractType, contractBytecode, encodedArgs, selector) {
     const unlockScript = [...encodedArgs].reverse();
     if (selector !== undefined)
         unlockScript.push(encodeInt(BigInt(selector)));
+    // P2S inputs do not need to provide the redeem script
+    if (contractType === 'p2s')
+        return scriptToBytecode(unlockScript);
     // Create input script and compile it to bytecode
-    const inputScript = [...unlockScript, scriptToBytecode(redeemScript)];
+    const inputScript = [...unlockScript, contractBytecode];
     return scriptToBytecode(inputScript);
 }
 export function createOpReturnOutput(opReturnData) {
@@ -154,14 +156,14 @@ export function toRegExp(reasons) {
     return new RegExp(reasons.join('|').replace(/\(/g, '\\(').replace(/\)/g, '\\)'));
 }
 export function scriptToAddress(script, network, addressType, tokenSupport) {
-    const bytecode = scriptToLockingBytecode(script, addressType);
+    const bytecode = scriptToP2SHLockingBytecode(script, addressType);
     const prefix = getNetworkPrefix(network);
     const result = lockingBytecodeToCashAddress({ bytecode, prefix, tokenSupport });
     if (typeof result === 'string')
         throw new Error(result);
     return result.address;
 }
-export function scriptToLockingBytecode(script, addressType) {
+export function scriptToP2SHLockingBytecode(script, addressType) {
     const scriptBytecode = scriptToBytecode(script);
     const scriptHash = (addressType === 'p2sh20') ? hash160(scriptBytecode) : hash256(scriptBytecode);
     const addressContents = { payload: scriptHash, type: LockingBytecodeType[addressType] };

package/dist/walletconnect-utils.js

@@ -1,6 +1,5 @@
 import { isContractUnlocker } from './interfaces.js';
-import { scriptToBytecode } from '@cashscript/utils';
-import { cashAddressToLockingBytecode } from '@bitauth/libauth';
+import { cashAddressToLockingBytecode, hexToBin } from '@bitauth/libauth';
 export function getWcContractInfo(input) {
     // If the input does not have a contract unlocker, return an empty object
     if (!(isContractUnlocker(input.unlocker)))
@@ -14,7 +13,7 @@ export function getWcContractInfo(input) {
     const wcContractObj = {
         contract: {
             abiFunction: abiFunction,
-            redeemScript: scriptToBytecode(contract.redeemScript),
+            redeemScript: hexToBin(contract.bytecode),
             artifact: contract.artifact,
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cashscript",
-  "version": "0.13.0-next.2",
+  "version": "0.13.0-next.4",
   "description": "Easily write and interact with Bitcoin Cash contracts",
   "keywords": [
     "bitcoin cash",
@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "@bitauth/libauth": "^3.1.0-next.8",
-    "@cashscript/utils": "^0.13.0-next.2",
+    "@cashscript/utils": "^0.13.0-next.4",
     "@electrum-cash/network": "^4.1.3",
     "@mr-zwets/bchn-api-wrapper": "^1.0.1",
     "fflate": "^0.8.2",
@@ -56,5 +56,5 @@
     "typescript": "^5.9.2",
     "vitest": "^4.0.15"
   },
-  "gitHead": "817391f108ce46c826dbab6f11ee4f1bb269c27f"
+  "gitHead": "a9b4062bda82a2d80adf1bf21b846a62d7592e5b"
 }