@laceio/sdk 0.1.1 → 0.1.2-canary.0

package/dist/identity-BMLuufva.cjs

@@ -0,0 +1,263 @@
+require("./rolldown-runtime-Br2OG8yv.cjs");
+const require_hex = require("./hex-D9ITYbwt.cjs");
+let _laceio_cardano_core = require("@laceio/cardano/core");
+//#region ../../packages/lib/cardano-custody/src/stake-script.ts
+/** Flat-encoded program version 1.1.0: three one-byte naturals. */
+const PROGRAM_VERSION = [
+	1,
+	1,
+	0
+];
+const PROGRAM_VERSION_BITS = PROGRAM_VERSION.length * 8;
+const APPLY_TERM_TAG = 3;
+const CONSTANT_TERM_TAG = 4;
+const DATA_TYPE_TAG = 8;
+const TERM_TAG_BITS = 4;
+/** Writes the flat encoding: bits fill each byte from the most significant end. */
+var FlatWriter = class {
+	bytes = [];
+	pending = 0;
+	pendingBits = 0;
+	get byteLength() {
+		return this.bytes.length;
+	}
+	writeBits(value, count) {
+		for (let shift = count - 1; shift >= 0; shift--) this.writeBit(value >> shift & 1);
+	}
+	writeBit(bit) {
+		this.pending = this.pending << 1 | bit;
+		this.pendingBits++;
+		if (this.pendingBits === 8) {
+			this.bytes.push(this.pending);
+			this.pending = 0;
+			this.pendingBits = 0;
+		}
+	}
+	/** Zero or more 0 bits and a closing 1 bit, ending on a byte boundary. */
+	writeFiller() {
+		while (this.pendingBits !== 7) this.writeBit(0);
+		this.writeBit(1);
+	}
+	/** Callers write whole bytes only after a filler or other whole bytes. */
+	writeAlignedBytes(bytes) {
+		this.bytes.push(...bytes);
+	}
+	toBytes() {
+		return Uint8Array.from(this.bytes);
+	}
+};
+const bitAt = (bytes, position) => bytes[position >> 3] >> 7 - (position & 7) & 1;
+/**
+* Applies one Plutus Data byte-string parameter: a constant term of type
+* `[data]` whose value is the CBOR of the data, as a flat byte string.
+* Returns the offset, in the flat output, of the parameter's raw bytes.
+*/
+const writeDataBytesConstant = (writer, parameter) => {
+	writer.writeBits(CONSTANT_TERM_TAG, TERM_TAG_BITS);
+	writer.writeBit(1);
+	writer.writeBits(DATA_TYPE_TAG, TERM_TAG_BITS);
+	writer.writeBit(0);
+	const cbor = require_hex.hexToBytes(_laceio_cardano_core.Serialization.PlutusData.newBytes(parameter).toCbor());
+	writer.writeFiller();
+	writer.writeAlignedBytes([cbor.length]);
+	const parameterOffset = writer.byteLength + cbor.length - parameter.length;
+	writer.writeAlignedBytes(cbor);
+	writer.writeAlignedBytes([0]);
+	return parameterOffset;
+};
+/** The flat program a blueprint's compiled code wraps in one CBOR byte string. */
+const unwrapCompiledCode = (compiledCode) => new _laceio_cardano_core.Serialization.CborReader(compiledCode).readByteString();
+const assertUnappliedProgramShape = (program, bodyBitLength) => {
+	if (PROGRAM_VERSION.some((byte, index) => program[index] !== byte)) throw new Error("The stake validator is not a version 1.1.0 program");
+	const bodyEnd = PROGRAM_VERSION_BITS + bodyBitLength;
+	const fillerBits = program.length * 8 - bodyEnd;
+	if (!(fillerBits >= 1 && fillerBits <= 8 && Array.from({ length: fillerBits }, (_, index) => bitAt(program, bodyEnd + index)).every((bit, index) => bit === (index === fillerBits - 1 ? 1 : 0)))) throw new Error(`The stake validator body is not ${bodyBitLength} bits followed by a filler`);
+};
+/**
+* Builds what `aiken blueprint apply` produces for the owner, then the
+* account validator hash: the unapplied body under two Apply terms, followed
+* by one Data byte-string constant per parameter. The two Apply tags take
+* exactly one byte, so the body bits keep their position within each byte
+* and the owner always lands at the same offset.
+*/
+const buildStakeScriptTemplate = (version) => {
+	const { compiledCode, bodyBitLength } = version.unappliedStakeValidator;
+	const program = unwrapCompiledCode(compiledCode);
+	assertUnappliedProgramShape(program, bodyBitLength);
+	const writer = new FlatWriter();
+	writer.writeAlignedBytes(PROGRAM_VERSION);
+	writer.writeBits(APPLY_TERM_TAG, TERM_TAG_BITS);
+	writer.writeBits(APPLY_TERM_TAG, TERM_TAG_BITS);
+	for (let index = 0; index < bodyBitLength; index++) writer.writeBit(bitAt(program, PROGRAM_VERSION_BITS + index));
+	const ownerFlatOffset = writeDataBytesConstant(writer, new Uint8Array(28));
+	writeDataBytesConstant(writer, require_hex.hexToBytes(version.accountValidatorHash));
+	writer.writeFiller();
+	const flat = writer.toBytes();
+	const wrapped = new _laceio_cardano_core.Serialization.CborWriter().writeByteString(flat).encode();
+	return {
+		compiledCode: wrapped,
+		ownerOffset: wrapped.length - flat.length + ownerFlatOffset
+	};
+};
+const templates = /* @__PURE__ */ new Map();
+const templateFor = (version) => {
+	let template = templates.get(version.accountValidatorHash);
+	if (!template) {
+		template = buildStakeScriptTemplate(version);
+		templates.set(version.accountValidatorHash, template);
+	}
+	return template;
+};
+/**
+* The compiled code of an account's stake script: the version's stake
+* validator applied to the owner (creator) key hash and then to the
+* version's account validator hash. Byte for byte what the Aiken CLI emits.
+*
+* @param ownerKeyHash - lower-case hex of exactly 28 bytes, checked by the caller
+*/
+const applyStakeValidatorToOwner = (version, ownerKeyHash) => {
+	const { compiledCode, ownerOffset } = templateFor(version);
+	const applied = compiledCode.slice();
+	applied.set(require_hex.hexToBytes(ownerKeyHash), ownerOffset);
+	return require_hex.bytesToHex(applied);
+};
+//#endregion
+//#region ../../packages/lib/cardano-custody/src/identity.ts
+/**
+* Derives the identity of a creator key hash and chain id the caller has
+* already validated.
+*/
+const identityOfValidatedCreator = ({ contractVersion, creatorKeyHash, chainId }) => {
+	const stakeScript = {
+		__type: _laceio_cardano_core.Cardano.ScriptType.Plutus,
+		bytes: applyStakeValidatorToOwner(contractVersion, creatorKeyHash),
+		version: _laceio_cardano_core.Cardano.PlutusLanguageVersion.V3
+	};
+	const stakeScriptHash = _laceio_cardano_core.Serialization.Script.fromCore(stakeScript).hash();
+	const stakeCredential = {
+		type: _laceio_cardano_core.Cardano.CredentialType.ScriptHash,
+		hash: stakeScriptHash
+	};
+	return {
+		contractVersion,
+		chainId,
+		creatorKeyHash,
+		stakeScript,
+		stakeScriptHash,
+		address: _laceio_cardano_core.Cardano.BaseAddress.fromCredentials(chainId.networkId, {
+			type: _laceio_cardano_core.Cardano.CredentialType.ScriptHash,
+			hash: contractVersion.accountValidatorHash
+		}, stakeCredential).toAddress().toBech32(),
+		rewardAccount: _laceio_cardano_core.Cardano.RewardAccount.fromCredential(stakeCredential, chainId.networkId),
+		stateNftAssetId: _laceio_cardano_core.Cardano.AssetId.fromParts(_laceio_cardano_core.Cardano.PolicyId(contractVersion.accountValidatorHash), _laceio_cardano_core.Cardano.AssetName(stakeScriptHash))
+	};
+};
+const MAINNET_NETWORK_MAGIC = _laceio_cardano_core.Cardano.NetworkMagics.Mainnet;
+/**
+* The chain a network magic names. Records carry only the magic; every
+* Cardano network except mainnet uses network id 0.
+*/
+const chainIdFromNetworkMagic = (networkMagic) => ({
+	networkId: networkMagic === MAINNET_NETWORK_MAGIC ? _laceio_cardano_core.Cardano.NetworkId.Mainnet : _laceio_cardano_core.Cardano.NetworkId.Testnet,
+	networkMagic
+});
+/** Whether a value is a network magic: a 32-bit unsigned integer. */
+const isNetworkMagic = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 4294967295;
+/**
+* Whether a chain id is one a record can name: the record keeps only the
+* magic, so the network id must be the one the magic implies.
+*/
+const isConsistentChainId = ({ networkId, networkMagic }) => isNetworkMagic(networkMagic) && networkId === chainIdFromNetworkMagic(networkMagic).networkId;
+/**
+* The identity of the account a creator key hash creates on a chain. Refuses
+* a key hash that is not lower-case hex of exactly 28 bytes, and a chain id
+* whose network id contradicts its network magic, such as network id 0 with
+* the mainnet magic.
+*/
+const deriveCustodyAccountIdentity = (params) => {
+	if (!isConsistentChainId(params.chainId)) return require_hex.fail({
+		code: "invalid-chain-id",
+		chainId: params.chainId
+	});
+	return require_hex.isHash28Hex(params.creatorKeyHash) ? require_hex.ok(identityOfValidatedCreator(params)) : require_hex.fail({
+		code: "invalid-key-hash",
+		keyHash: params.creatorKeyHash
+	});
+};
+//#endregion
+//#region ../../packages/contract/cardano-context/src/custody/identity.ts
+/**
+* Re-derives a persisted custody account's identity from its contract
+* version, creator key hash and chain, and refuses it unless the stored
+* stake script hash, address and reward account are exactly the derived
+* ones. Persisted props are only as trustworthy as storage, and an address
+* the contract does not govern for this creator must never be synced or
+* shown as the account.
+*/
+const verifyCardanoCustodyAccountIdentity = (stored) => {
+	const contractVersion = require_hex.findCustodyContractVersion(stored.accountValidatorHash);
+	if (!contractVersion.ok) return contractVersion;
+	const derived = deriveCustodyAccountIdentity({
+		contractVersion: contractVersion.value,
+		creatorKeyHash: stored.creatorKeyHash,
+		chainId: stored.chainId
+	});
+	if (!derived.ok) return derived;
+	const mismatch = [
+		[
+			"stakeScriptHash",
+			stored.stakeScriptHash,
+			derived.value.stakeScriptHash
+		],
+		[
+			"address",
+			stored.address,
+			derived.value.address
+		],
+		[
+			"rewardAccount",
+			stored.rewardAccount,
+			derived.value.rewardAccount
+		]
+	].find(([, storedValue, derivedValue]) => storedValue !== derivedValue);
+	return mismatch ? {
+		ok: false,
+		error: {
+			code: "identity-mismatch",
+			field: mismatch[0],
+			stored: mismatch[1],
+			derived: mismatch[2]
+		}
+	} : derived;
+};
+//#endregion
+Object.defineProperty(exports, "chainIdFromNetworkMagic", {
+	enumerable: true,
+	get: function() {
+		return chainIdFromNetworkMagic;
+	}
+});
+Object.defineProperty(exports, "deriveCustodyAccountIdentity", {
+	enumerable: true,
+	get: function() {
+		return deriveCustodyAccountIdentity;
+	}
+});
+Object.defineProperty(exports, "identityOfValidatedCreator", {
+	enumerable: true,
+	get: function() {
+		return identityOfValidatedCreator;
+	}
+});
+Object.defineProperty(exports, "isNetworkMagic", {
+	enumerable: true,
+	get: function() {
+		return isNetworkMagic;
+	}
+});
+Object.defineProperty(exports, "verifyCardanoCustodyAccountIdentity", {
+	enumerable: true,
+	get: function() {
+		return verifyCardanoCustodyAccountIdentity;
+	}
+});

package/dist/identity-DII6f-h7.js

@@ -0,0 +1,233 @@
+import { d as fail, f as ok, l as findCustodyContractVersion, n as hexToBytes, r as isHash28Hex, t as bytesToHex } from "./hex-mkXcV3pN.js";
+import { Cardano, Serialization } from "@laceio/cardano/core";
+//#region ../../packages/lib/cardano-custody/src/stake-script.ts
+/** Flat-encoded program version 1.1.0: three one-byte naturals. */
+const PROGRAM_VERSION = [
+	1,
+	1,
+	0
+];
+const PROGRAM_VERSION_BITS = PROGRAM_VERSION.length * 8;
+const APPLY_TERM_TAG = 3;
+const CONSTANT_TERM_TAG = 4;
+const DATA_TYPE_TAG = 8;
+const TERM_TAG_BITS = 4;
+/** Writes the flat encoding: bits fill each byte from the most significant end. */
+var FlatWriter = class {
+	bytes = [];
+	pending = 0;
+	pendingBits = 0;
+	get byteLength() {
+		return this.bytes.length;
+	}
+	writeBits(value, count) {
+		for (let shift = count - 1; shift >= 0; shift--) this.writeBit(value >> shift & 1);
+	}
+	writeBit(bit) {
+		this.pending = this.pending << 1 | bit;
+		this.pendingBits++;
+		if (this.pendingBits === 8) {
+			this.bytes.push(this.pending);
+			this.pending = 0;
+			this.pendingBits = 0;
+		}
+	}
+	/** Zero or more 0 bits and a closing 1 bit, ending on a byte boundary. */
+	writeFiller() {
+		while (this.pendingBits !== 7) this.writeBit(0);
+		this.writeBit(1);
+	}
+	/** Callers write whole bytes only after a filler or other whole bytes. */
+	writeAlignedBytes(bytes) {
+		this.bytes.push(...bytes);
+	}
+	toBytes() {
+		return Uint8Array.from(this.bytes);
+	}
+};
+const bitAt = (bytes, position) => bytes[position >> 3] >> 7 - (position & 7) & 1;
+/**
+* Applies one Plutus Data byte-string parameter: a constant term of type
+* `[data]` whose value is the CBOR of the data, as a flat byte string.
+* Returns the offset, in the flat output, of the parameter's raw bytes.
+*/
+const writeDataBytesConstant = (writer, parameter) => {
+	writer.writeBits(CONSTANT_TERM_TAG, TERM_TAG_BITS);
+	writer.writeBit(1);
+	writer.writeBits(DATA_TYPE_TAG, TERM_TAG_BITS);
+	writer.writeBit(0);
+	const cbor = hexToBytes(Serialization.PlutusData.newBytes(parameter).toCbor());
+	writer.writeFiller();
+	writer.writeAlignedBytes([cbor.length]);
+	const parameterOffset = writer.byteLength + cbor.length - parameter.length;
+	writer.writeAlignedBytes(cbor);
+	writer.writeAlignedBytes([0]);
+	return parameterOffset;
+};
+/** The flat program a blueprint's compiled code wraps in one CBOR byte string. */
+const unwrapCompiledCode = (compiledCode) => new Serialization.CborReader(compiledCode).readByteString();
+const assertUnappliedProgramShape = (program, bodyBitLength) => {
+	if (PROGRAM_VERSION.some((byte, index) => program[index] !== byte)) throw new Error("The stake validator is not a version 1.1.0 program");
+	const bodyEnd = PROGRAM_VERSION_BITS + bodyBitLength;
+	const fillerBits = program.length * 8 - bodyEnd;
+	if (!(fillerBits >= 1 && fillerBits <= 8 && Array.from({ length: fillerBits }, (_, index) => bitAt(program, bodyEnd + index)).every((bit, index) => bit === (index === fillerBits - 1 ? 1 : 0)))) throw new Error(`The stake validator body is not ${bodyBitLength} bits followed by a filler`);
+};
+/**
+* Builds what `aiken blueprint apply` produces for the owner, then the
+* account validator hash: the unapplied body under two Apply terms, followed
+* by one Data byte-string constant per parameter. The two Apply tags take
+* exactly one byte, so the body bits keep their position within each byte
+* and the owner always lands at the same offset.
+*/
+const buildStakeScriptTemplate = (version) => {
+	const { compiledCode, bodyBitLength } = version.unappliedStakeValidator;
+	const program = unwrapCompiledCode(compiledCode);
+	assertUnappliedProgramShape(program, bodyBitLength);
+	const writer = new FlatWriter();
+	writer.writeAlignedBytes(PROGRAM_VERSION);
+	writer.writeBits(APPLY_TERM_TAG, TERM_TAG_BITS);
+	writer.writeBits(APPLY_TERM_TAG, TERM_TAG_BITS);
+	for (let index = 0; index < bodyBitLength; index++) writer.writeBit(bitAt(program, PROGRAM_VERSION_BITS + index));
+	const ownerFlatOffset = writeDataBytesConstant(writer, new Uint8Array(28));
+	writeDataBytesConstant(writer, hexToBytes(version.accountValidatorHash));
+	writer.writeFiller();
+	const flat = writer.toBytes();
+	const wrapped = new Serialization.CborWriter().writeByteString(flat).encode();
+	return {
+		compiledCode: wrapped,
+		ownerOffset: wrapped.length - flat.length + ownerFlatOffset
+	};
+};
+const templates = /* @__PURE__ */ new Map();
+const templateFor = (version) => {
+	let template = templates.get(version.accountValidatorHash);
+	if (!template) {
+		template = buildStakeScriptTemplate(version);
+		templates.set(version.accountValidatorHash, template);
+	}
+	return template;
+};
+/**
+* The compiled code of an account's stake script: the version's stake
+* validator applied to the owner (creator) key hash and then to the
+* version's account validator hash. Byte for byte what the Aiken CLI emits.
+*
+* @param ownerKeyHash - lower-case hex of exactly 28 bytes, checked by the caller
+*/
+const applyStakeValidatorToOwner = (version, ownerKeyHash) => {
+	const { compiledCode, ownerOffset } = templateFor(version);
+	const applied = compiledCode.slice();
+	applied.set(hexToBytes(ownerKeyHash), ownerOffset);
+	return bytesToHex(applied);
+};
+//#endregion
+//#region ../../packages/lib/cardano-custody/src/identity.ts
+/**
+* Derives the identity of a creator key hash and chain id the caller has
+* already validated.
+*/
+const identityOfValidatedCreator = ({ contractVersion, creatorKeyHash, chainId }) => {
+	const stakeScript = {
+		__type: Cardano.ScriptType.Plutus,
+		bytes: applyStakeValidatorToOwner(contractVersion, creatorKeyHash),
+		version: Cardano.PlutusLanguageVersion.V3
+	};
+	const stakeScriptHash = Serialization.Script.fromCore(stakeScript).hash();
+	const stakeCredential = {
+		type: Cardano.CredentialType.ScriptHash,
+		hash: stakeScriptHash
+	};
+	return {
+		contractVersion,
+		chainId,
+		creatorKeyHash,
+		stakeScript,
+		stakeScriptHash,
+		address: Cardano.BaseAddress.fromCredentials(chainId.networkId, {
+			type: Cardano.CredentialType.ScriptHash,
+			hash: contractVersion.accountValidatorHash
+		}, stakeCredential).toAddress().toBech32(),
+		rewardAccount: Cardano.RewardAccount.fromCredential(stakeCredential, chainId.networkId),
+		stateNftAssetId: Cardano.AssetId.fromParts(Cardano.PolicyId(contractVersion.accountValidatorHash), Cardano.AssetName(stakeScriptHash))
+	};
+};
+const MAINNET_NETWORK_MAGIC = Cardano.NetworkMagics.Mainnet;
+/**
+* The chain a network magic names. Records carry only the magic; every
+* Cardano network except mainnet uses network id 0.
+*/
+const chainIdFromNetworkMagic = (networkMagic) => ({
+	networkId: networkMagic === MAINNET_NETWORK_MAGIC ? Cardano.NetworkId.Mainnet : Cardano.NetworkId.Testnet,
+	networkMagic
+});
+/** Whether a value is a network magic: a 32-bit unsigned integer. */
+const isNetworkMagic = (value) => typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 4294967295;
+/**
+* Whether a chain id is one a record can name: the record keeps only the
+* magic, so the network id must be the one the magic implies.
+*/
+const isConsistentChainId = ({ networkId, networkMagic }) => isNetworkMagic(networkMagic) && networkId === chainIdFromNetworkMagic(networkMagic).networkId;
+/**
+* The identity of the account a creator key hash creates on a chain. Refuses
+* a key hash that is not lower-case hex of exactly 28 bytes, and a chain id
+* whose network id contradicts its network magic, such as network id 0 with
+* the mainnet magic.
+*/
+const deriveCustodyAccountIdentity = (params) => {
+	if (!isConsistentChainId(params.chainId)) return fail({
+		code: "invalid-chain-id",
+		chainId: params.chainId
+	});
+	return isHash28Hex(params.creatorKeyHash) ? ok(identityOfValidatedCreator(params)) : fail({
+		code: "invalid-key-hash",
+		keyHash: params.creatorKeyHash
+	});
+};
+//#endregion
+//#region ../../packages/contract/cardano-context/src/custody/identity.ts
+/**
+* Re-derives a persisted custody account's identity from its contract
+* version, creator key hash and chain, and refuses it unless the stored
+* stake script hash, address and reward account are exactly the derived
+* ones. Persisted props are only as trustworthy as storage, and an address
+* the contract does not govern for this creator must never be synced or
+* shown as the account.
+*/
+const verifyCardanoCustodyAccountIdentity = (stored) => {
+	const contractVersion = findCustodyContractVersion(stored.accountValidatorHash);
+	if (!contractVersion.ok) return contractVersion;
+	const derived = deriveCustodyAccountIdentity({
+		contractVersion: contractVersion.value,
+		creatorKeyHash: stored.creatorKeyHash,
+		chainId: stored.chainId
+	});
+	if (!derived.ok) return derived;
+	const mismatch = [
+		[
+			"stakeScriptHash",
+			stored.stakeScriptHash,
+			derived.value.stakeScriptHash
+		],
+		[
+			"address",
+			stored.address,
+			derived.value.address
+		],
+		[
+			"rewardAccount",
+			stored.rewardAccount,
+			derived.value.rewardAccount
+		]
+	].find(([, storedValue, derivedValue]) => storedValue !== derivedValue);
+	return mismatch ? {
+		ok: false,
+		error: {
+			code: "identity-mismatch",
+			field: mismatch[0],
+			stored: mismatch[1],
+			derived: mismatch[2]
+		}
+	} : derived;
+};
+//#endregion
+export { isNetworkMagic as a, identityOfValidatedCreator as i, chainIdFromNetworkMagic as n, deriveCustodyAccountIdentity as r, verifyCardanoCustodyAccountIdentity as t };