@clarigen/core 4.1.4 → 4.1.5

package/dist/index.mjs

@@ -1,2 +1,831 @@
-import{a as e,i as t,n}from"./deployment-CGEqh8yH.mjs";import{ClarityType as r,broadcastTransaction as i,bufferCV as a,contractPrincipalCV as o,cvToHex as s,cvToHex as c,hexToCV as l,hexToCV as u,intCV as ee,listCV as te,noneCV as ne,parseToCV as d,responseErrorCV as re,responseOkCV as ie,someCV as ae,stringAsciiCV as oe,stringUtf8CV as se,tupleCV as ce,uintCV as le}from"@stacks/transactions";import{hex as f}from"@scure/base";import{Configuration as ue,SmartContractsApi as de}from"@stacks/blockchain-api-client";import{networkFrom as fe}from"@stacks/network";const p=`ST000000000000000000002AMW42H`,m=`SP000000000000000000002Q6VF78`,h=(e,t)=>{let n=typeof e==`string`?e:String(e);if(/^[A-Z_]+$/.test(n))return n;let[r,...i]=n.replace(`!`,`_x`).replace(`?`,`_q`).split(`-`),a=`${t?r[0].toUpperCase():r[0].toLowerCase()}${r.slice(1)}`;return i.forEach(e=>{let t=e[0].toUpperCase()+e.slice(1);a+=t}),a};function g(e){let t=e.match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g);return t?t.join(`-`).toLowerCase():e}function pe(e,t=!0){let n=e.split(`.`)[1];return t?h(n):n}const _=e=>{let t=e.split(`/`).at(-1),[n]=(t==null?void 0:t.split(`.`))??[];return n},me=e=>`${e.address}.${e.name}`,he=e=>{let t=_(e.contractFile);return o(e.address,t)};function ge(e,t){return`${t?m:p}.${e}`}function _e(e){return f.encode(e)}function v(e){return f.decode(e)}function ve(e){let t=Array.from(e);return String.fromCharCode.apply(null,t)}const ye=e=>typeof e==`number`;function y(e){let{constants:t}=e,n={};for(let e in t)if(e.toLowerCase().startsWith(`err`)){let r=t[e];typeof r==`object`&&r&&`isOk`in r&&!r.isOk&&`value`in r?n[e]=r.value:n[e]=r}return n}function be(e){let{contracts:t}=e,n={};for(let e in t)n[e]=y(t[e]);return n}let xe=function(e){return e.ContractEvent=`contract_event`,e.StxTransferEvent=`stx_transfer_event`,e.StxMintEvent=`stx_mint_event`,e.StxBurnEvent=`stx_burn_event`,e.StxLockEvent=`stx_lock_event`,e.NftTransferEvent=`nft_transfer_event`,e.NftMintEvent=`nft_mint_event`,e.NftBurnEvent=`nft_burn_event`,e.FtTransferEvent=`ft_transfer_event`,e.FtMintEvent=`ft_mint_event`,e.FtBurnEvent=`ft_burn_event`,e}({});function Se(e,t){return e.filter(e=>e.type===t)}function Ce(e,t={}){let n={};for(let r in e){let i=e[r],a=t.deployerAddress||i.address;n[r]={identifier:`${a}.${i.name}`,contract:i.contract(a,i.name)}}return n}function b(e){return{isOk:!0,value:e}}function x(e){return{isOk:!1,value:e}}function we(e){return typeof e==`object`&&!!e&&`isOk`in e}function S(e){return e.value}function C(e,t=!1){switch(e.type){case r.BoolTrue:return!0;case r.BoolFalse:return!1;case r.Int:case r.UInt:return e.value;case r.Buffer:return v(e.value);case r.OptionalNone:return null;case r.OptionalSome:return C(e.value,!0);case r.ResponseErr:return t?x(C(e.value,!0)):C(e.value,!0);case r.ResponseOk:return t?b(C(e.value,!0)):C(e.value,!0);case r.PrincipalStandard:case r.PrincipalContract:return S(e);case r.List:return e.value.map(e=>C(e,!0));case r.Tuple:return Object.entries(e.value).reduce((e,[t,n])=>{let r=h(t);return{...e,[r]:C(n,!0)}},{});case r.StringASCII:return e.value;case r.StringUTF8:return e.value}}function Te(e,t=!1){return C(u(e),t)}function w(e){if(!(typeof e==`bigint`||typeof e==`number`||typeof e==`string`))throw Error(`Invalid input type for integer`);return BigInt(e)}const T=e=>typeof e==`string`,E=e=>e.buffer!==void 0,D=e=>e[`string-ascii`]!==void 0,O=e=>e[`string-utf8`]!==void 0,k=e=>e.response!==void 0,A=e=>e.optional!==void 0,j=e=>e.tuple!==void 0,M=e=>e.list!==void 0,Ee=e=>e===`trait_reference`;function N(e,t){if(j(t)){if(typeof e!=`object`)throw Error(`Invalid tuple input`);let n={};return t.tuple.forEach(t=>{let r=e[z(t.name,e)];n[t.name]=N(r,t.type)}),ce(n)}if(M(t))return te(e.map(e=>N(e,t.list.type)));if(A(t))return e===null?ne():ae(N(e,t.optional));if(D(t)){if(typeof e!=`string`)throw Error(`Invalid string-ascii input`);return oe(e)}if(O(t)){if(typeof e!=`string`)throw Error(`Invalid string-ascii input`);return se(e)}if(t===`bool`)return d(typeof e==`boolean`?e.toString():e,t);if(t===`uint128`)return le(w(e).toString());if(t===`int128`)return ee(w(e).toString());if(t===`trait_reference`){if(typeof e!=`string`)throw Error(`Invalid input for trait_reference`);let[t,n]=e.split(`.`);return o(t,n)}return E(t)?a(e):d(e,t)}function P(e,t){let n=typeof t==`object`?t:{encoding:t,indent:void 0,depth:void 0},i=n.encoding??`hex`,a=n.indent,o=n.depth??0;switch(e.type){case r.BoolTrue:return`true`;case r.BoolFalse:return`false`;case r.Int:return e.value.toString();case r.UInt:return`u${e.value.toString()}`;case r.Buffer:if(i===`tryAscii`){let t=ve(v(e.value));if(/[ -~]/.test(t))return JSON.stringify(t)}return`0x${e.value}`;case r.OptionalNone:return`none`;case r.OptionalSome:return`(some ${P(e.value,n)})`;case r.ResponseErr:return`(err ${P(e.value,n)})`;case r.ResponseOk:return`(ok ${P(e.value,n)})`;case r.PrincipalStandard:case r.PrincipalContract:return`'${S(e)}`;case r.List:return`(list ${e.value.map(e=>P(e,n)).join(` `)})`;case r.Tuple:{let t=Object.keys(e.value);if(a===void 0||t.length===0)return`{ ${t.map(t=>`${t}: ${P(e.value[t],n)}`).join(`, `)} }`;let r=` `.repeat((o+1)*a),i=` `.repeat(o*a);return`{\n${t.map(t=>`${r}${t}: ${P(e.value[t],{...n,depth:o+1})}`).join(`,
-`)}\n${i}}`}case r.StringASCII:return`"${e.value}"`;case r.StringUTF8:return`u"${e.value}"`}}function F(e,t=!1){switch(e.type){case r.BoolTrue:return!0;case r.BoolFalse:return!1;case r.Int:case r.UInt:return`${e.value}`;case r.Buffer:return e.value;case r.OptionalNone:return null;case r.OptionalSome:return F(e.value);case r.ResponseErr:return t?x(F(e.value)):F(e.value);case r.ResponseOk:return t?b(F(e.value)):F(e.value);case r.PrincipalStandard:case r.PrincipalContract:return S(e);case r.List:return e.value.map(e=>F(e));case r.Tuple:return Object.entries(e.value).reduce((e,[t,n])=>{let r=h(t);return{...e,[r]:F(n)}},{});case r.StringASCII:return e.value;case r.StringUTF8:return e.value}}function I(e,t){return e.args.map(e=>{let n=t[z(e.name,t)];return N(n,e.type)})}function L(e,t){return t.map((t,n)=>N(t,e.args[n].type))}function R(e,t){if(t.length===0)return[];let[n]=t;if(t.length===1&&e.args.length!==1)return I(e,n);if(typeof n==`object`&&!Array.isArray(n)&&n!==null)try{let t=!0;if(e.args.forEach(e=>{try{z(e.name,n)}catch{t=!1}}),t)return I(e,n)}catch{}return L(e,t)}function z(e,t){let n=Object.keys(t).find(t=>{let n=e===t,r=e===g(t);return n||r});if(!n)throw Error(`Error encoding JS tuple: ${e} not found in input.`);return n}function B(e){if(e.isOk)return e.value;throw Error(`Expected OK, received error: ${String(e.value)}`)}function V(e){if(!e.isOk)return e.value;throw Error(`Expected Err, received ok: ${String(e.value)}`)}function H(e){if(T(e))return e===`int128`?`int`:e===`uint128`?`uint`:e;if(E(e))return`(buff ${e.buffer.length})`;if(D(e))return`(string-ascii ${e[`string-ascii`].length})`;if(O(e))return`(string-utf8 ${e[`string-utf8`].length})`;if(k(e))return`(response ${H(e.response.ok)} ${H(e.response.error)})`;if(A(e))return`(optional ${H(e.optional)})`;if(j(e))return`{ ${e.tuple.map(e=>`${e.name}: ${H(e.type)}`).join(`, `)} }`;if(M(e))return`(list ${e.list.length} ${H(e.list.type)})`;throw Error(`Type string unsupported for Clarity type: ${JSON.stringify(e)}`)}const De=[`devnet`,`simnet`,`testnet`,`mainnet`];function Oe(e,t){let n=[];return Object.entries(e.contracts).forEach(([r,i])=>{let a=e.deployments[r][t];return a&&n.push([r,W(i,a)]),!1}),Object.fromEntries(n)}function ke(e,t){return Object.fromEntries(Object.entries(e).map(([e,n])=>[e,W(n,`${t}.${n.contractName}`)]))}function U(e,t){return Object.fromEntries(Object.entries(e.functions).map(([n,r])=>[n,Object.assign((...n)=>{let i=R(r,n),[a,o]=t.split(`.`);return{functionArgs:i,contractAddress:a,contractName:o,function:r,functionName:r.name,nativeArgs:n,contractAbi:e}},{abi:r})]))}function W(e,t){let n={...e};return{...U(e,t),...n,identifier:t}}function Ae(r,i){let a={};return n(i.plan.batches).forEach(n=>{let i=e(n),[o,s]=i.split(`.`),c=h(s),l=r[c],u=r[c];if(u===void 0)throw Error(`Clarigen error: mismatch for contract '${c}'`);a[c]=u,u.contractFile=t(n),u.identifier=i,Object.keys(r[c].functions).forEach(e=>{let t=e;u[t]=((...e)=>{let n=l.functions[t];return{functionArgs:R(n,e),contractAddress:o,contractName:u.contractName,function:n,nativeArgs:e}})})}),a}function G(e,t){return{key:t,keyCV:N(t,e.key),map:e}}function K(e,t={}){let n={...t};return e&&(n[`x-api-key`]=e),n}function je(e,t,n){return new de(new ue({basePath:e,headers:K(t,n)}))}function Me(e){return`${e}/v2`}const Ne=(e,t)=>{try{let n=new URL(e);return Object.keys(t).forEach(e=>{let r=t[e];if(r){if(Array.isArray(r))return r.length===0?void 0:n.searchParams.set(`${e}[]`,Pe(e,r));if(typeof r==`boolean`||ye(r))return n.searchParams.set(e,String(r));n.searchParams.set(e,r)}}),n.toString()}catch(t){return console.error(`generateUrl`),console.error(t),e}},Pe=(e,t)=>t!=null&&t.length?`${t.map((t,n)=>`${n>0?encodeURIComponent(`${e}[]`):``}=${encodeURIComponent(t)}`).join(`&`)}`:``;function Fe(e){if(e.okay)return u(e.result);throw Error(e.cause)}async function Ie(e){let{contractAddress:t,functionArgs:n,senderAddress:r=t,url:i}=e;return Fe(await je(i,e.apiKey,e.headers).callReadOnlyFunction({...e,readOnlyFunctionArgs:{sender:r,arguments:n.map(e=>typeof e==`string`?e:c(e))}}))}function Le(e){return typeof e==`object`&&!!e&&`isNone`in e&&typeof e.isNone==`boolean`}function Re(e){return typeof e==`object`&&!!e&&`isOk`in e&&typeof e.isOk==`boolean`}function q(e,t){if(A(t))return Le(e)?e.isNone?null:q(e.value,t.optional):e;if(E(t))return typeof e==`string`?v(e.startsWith(`0x`)?e.slice(2):e):e;if(j(t)){if(typeof e!=`object`||!e)return e;let n={};for(let r of t.tuple){let t=e[r.name];n[r.name]=q(t,r.type)}return n}return M(t)&&Array.isArray(e)?e.map(e=>q(e,t.list.type)):e}function J(e,t){if(k(t)){if(!Re(e))throw Error(`Response type requires { isOk: boolean, value: unknown } form value`);let n=e.isOk?t.response.ok:t.response.error,r=J(e.isOk?e.ok??e.value:e.err??e.value,n);return e.isOk?ie(r):re(r)}return N(q(e,t),t)}function ze(e,t){if(e===void 0||e===``)return A(t)?{isNone:!0,value:null}:M(t)?[]:j(t)?{}:T(t)&&t===`bool`?!1:``;if(t===`principal`&&e.startsWith(`'`))return e.slice(1);if(A(t)||M(t)||j(t)||k(t))try{return JSON.parse(e)}catch{return e}return T(t)&&t===`bool`?e===`true`:e}function Be(e,t){return t.map(t=>{let n=e[t.name];return J(ze(Array.isArray(n)?n[0]:n,t.type),t.type)})}function Ve(e){if(e.latest!==!1)return e.latest||e.tip===void 0?`latest`:e.tip}async function Y(e,t){let n=Ve(t),r=await Ie({contractAddress:e.contractAddress,contractName:e.contractName,functionName:e.functionName,functionArgs:e.functionArgs,tip:n,url:X(t),apiKey:t.apiKey,headers:t.headers});return t.json?F(r):C(r,!0)}async function He(e,t){return B(await Y(e,t))}async function Ue(e,t){return V(await Y(e,t))}function X(e){return fe(e.network).client.baseUrl}async function We(e,t,n,r){let i=G(t,n),a=JSON.stringify(s(i.keyCV)),[o,c]=e.split(`.`),u=Ne(`${Me(X(r))}/map_entry/${o}/${c}/${i.map.name}`,{proof:0,tip:Ve(r)});return C(l((await(await fetch(u,{method:`POST`,body:a,headers:{"Content-Type":`application/json`,Accept:`application/json`,...K(r.apiKey,r.headers)}})).json()).data),!0)}async function Ge(e,t){let n=t.network,r=await i({transaction:e,network:n});if(`error`in r)throw Error(`Error broadcasting tx: ${r.error} - ${r.reason} - ${JSON.stringify(`reason_data`in r?r.reason_data:void 0)}`);return{txId:r.txid,stacksTransaction:e}}var Ke=class{network;constructor(e,t,n){this.apiKey=t,this.headers=n,this.network=e}roOptions(e){return{network:this.network,apiKey:this.apiKey,headers:this.headers,...e}}ro(e,t){return Y(e,this.roOptions(t||{}))}roOk(e,t){return He(e,this.roOptions(t||{}))}roErr(e,t){return Ue(e,this.roOptions(t||{}))}};function Z(e,t){let[n,r]=e.identifier.split(`.`);if(!(`identifier`in e))throw Error(`Invalid contract`);for(let i of e.non_fungible_tokens)if(i.name===t)return`${n}.${r}::${i.name}`;for(let i of e.fungible_tokens)if(i.name===t)return`${n}.${r}::${i.name}`;throw Error(`Invalid asset: "${t}" is not an asset in contract.`)}function qe(e,t,n,r){let[i]=e.non_fungible_tokens,a=Z(e,i.name),o=i.type;return{type:`nft-postcondition`,address:t,condition:n,asset:a,assetId:N(r,o)}}function Je(e,t,n,r){let[i,a]=t.split(`.`),[o]=e.fungible_tokens;return{type:`ft-postcondition`,address:t,condition:n,asset:Z(e,o.name),amount:r}}function Q(e,t=``){return e.slice(t.length+2,-1)}function $(e,t){if(j(t)){let n=Ze(e),r={},i=Object.entries(n).reduce((e,[t,n])=>{let r=t.trim();return{...e,[r]:n.trim()}},{});return t.tuple.forEach(({name:e,type:t})=>{let n=h(e);r[n]=$(i[e],t)}),r}if(M(t))return Xe(e).map(e=>$(e,t.list.type));if(A(t))return e===`none`?null:$(Q(e,`some`),t.optional);if(D(t))return e.slice(1,-1);if(O(t))return e.slice(2,-1);if(t===`bool`)return e===`true`;if(t===`uint128`)return BigInt(e.slice(1));if(t===`int128`)return BigInt(e);if(t===`trait_reference`||t===`principal`)return e.replace(/^'/,``);if(t===`none`)return null;if(E(t))return v(e.slice(2));if(k(t))return e.startsWith(`(ok`)?b($(Q(e,`ok`),t.response.ok)):x($(Q(e,`err`),t.response.error));throw Error(`Unable to parse cv string to value: ${e} ${JSON.stringify(t,null,2)}`)}const Ye=Array(255);for(let e=0;e<=255;++e)Ye[e]=e.toString(16).padStart(2,`0`);function Xe(e){if(e.charAt(0)!==`[`||e.at(-1)!==`]`)throw Error(`Expected (list ..), got ${e.toString()}`);let t=[],n=[],r=1;for(let i=0;i<e.length;i++)e.charAt(i)===`,`&&t.length===1&&(n.push(e.substring(r,i)),r=i+2),[`(`,`[`,`{`].includes(e.charAt(i))&&t.push(e.charAt(i)),e.charAt(i)===`)`&&t.at(-1)===`(`&&t.pop(),e.charAt(i)===`}`&&t.at(-1)===`{`&&t.pop(),e.charAt(i)===`]`&&t.at(-1)===`[`&&t.pop();let i=e.substring(r,e.length-1);return i.length>0&&n.push(i),n}function Ze(e){if(e.charAt(0)!==`{`||e.at(-1)!==`}`)throw Error(`Expected '(tuple ..)', got ${e.toString()}`);let t=1,n=[],r=[];for(let i=0;i<e.length;i++)e.charAt(i)===`,`&&n.length===1&&(r.push(e.substring(t,i)),t=i+2),[`(`,`[`,`{`].includes(e.charAt(i))&&n.push(e.charAt(i)),e.charAt(i)===`)`&&n.at(-1)===`(`&&n.pop(),e.charAt(i)===`}`&&n.at(-1)===`{`&&n.pop(),e.charAt(i)===`]`&&n.at(-1)===`[`&&n.pop();let i=e.substring(t,e.length-1);i.length>0&&r.push(i);let a={};for(let e of r)for(let t=0;t<e.length;t++)if(e.charAt(t)===`:`){let n=e.substring(0,t);a[n]=e.substring(t+2,e.length);break}return a}export{Ke as ClarigenClient,xe as CoreNodeEventType,De as DEPLOYMENT_NETWORKS,m as MAINNET_BURN_ADDRESS,p as TESTNET_BURN_ADDRESS,ge as bootContractIdentifier,Ge as broadcast,ve as bytesToAscii,_e as bytesToHex,Ie as callReadOnlyFunction,W as contractFactory,ke as contractsFactory,Z as createAssetInfo,s as cvToHex,F as cvToJSON,P as cvToString,C as cvToValue,Ae as deploymentFactory,x as err,V as expectErr,B as expectOk,y as extractErrors,We as fetchMapGet,Se as filterEvents,z as findJsTupleKey,J as formValueToCV,q as formValueToParseable,U as functionsFactory,X as getApiUrl,me as getContractIdentifier,pe as getContractName,_ as getContractNameFromPath,he as getContractPrincipalCV,H as getTypeString,v as hexToBytes,l as hexToCV,Te as hexToCvValue,E as isClarityAbiBuffer,M as isClarityAbiList,A as isClarityAbiOptional,T as isClarityAbiPrimitive,k as isClarityAbiResponse,D as isClarityAbiStringAscii,O as isClarityAbiStringUtf8,Ee as isClarityAbiTraitReference,j as isClarityAbiTuple,ye as isNumber,Le as isOptionalFormValue,we as isResponse,Re as isResponseFormValue,Ce as makeContracts,Je as makeFungiblePostCondition,qe as makeNonFungiblePostCondition,G as mapFactory,b as ok,ze as parseQueryValue,Fe as parseReadOnlyResponse,N as parseToCV,S as principalToString,be as projectErrors,Oe as projectFactory,Be as queryToFunctionArgs,$ as rawClarityToValue,Y as ro,Ue as roErr,He as roOk,h as toCamelCase,g as toKebabCase,L as transformArgsArray,R as transformArgsToCV,I as transformObjectArgs};
+import { a as getIdentifierForDeploymentTx, i as getDeploymentTxPath, n as getContractTxs } from "./deployment-BoAUH7JK.mjs";
+import { ClarityType, broadcastTransaction, bufferCV, contractPrincipalCV, cvToHex, cvToHex as cvToHex$1, hexToCV, hexToCV as hexToCV$1, intCV, listCV, noneCV, parseToCV as parseToCV$1, responseErrorCV, responseOkCV, someCV, stringAsciiCV, stringUtf8CV, tupleCV, uintCV } from "@stacks/transactions";
+import { hex } from "@scure/base";
+import { Configuration, SmartContractsApi } from "@stacks/blockchain-api-client";
+import { networkFrom } from "@stacks/network";
+
+//#region src/utils.ts
+/** biome-ignore-all lint/style/useTrimStartEnd: suppressed */
+const TESTNET_BURN_ADDRESS = "ST000000000000000000002AMW42H";
+const MAINNET_BURN_ADDRESS = "SP000000000000000000002Q6VF78";
+const toCamelCase = (input, titleCase) => {
+	const inputStr = typeof input === "string" ? input : String(input);
+	if (/^[A-Z_]+$/.test(inputStr)) return inputStr;
+	const [first, ...parts] = inputStr.replace("!", "_x").replace("?", "_q").split("-");
+	let result = `${titleCase ? first[0].toUpperCase() : first[0].toLowerCase()}${first.slice(1)}`;
+	parts.forEach((part) => {
+		const capitalized = part[0].toUpperCase() + part.slice(1);
+		result += capitalized;
+	});
+	return result;
+};
+function toKebabCase(input) {
+	const matches = input.match(/[A-Z]{2,}(?=[A-Z][a-z]+[0-9]*|\b)|[A-Z]?[a-z]+[0-9]*|[A-Z]|[0-9]+/g);
+	if (!matches) return input;
+	return matches.join("-").toLowerCase();
+}
+function getContractName(identifier, camelCase = true) {
+	const name = identifier.split(".")[1];
+	return camelCase ? toCamelCase(name) : name;
+}
+const getContractNameFromPath = (path) => {
+	const filename = path.split("/").at(-1);
+	const [contractName] = (filename === null || filename === void 0 ? void 0 : filename.split(".")) ?? [];
+	return contractName;
+};
+const getContractIdentifier = (contract) => `${contract.address}.${contract.name}`;
+const getContractPrincipalCV = (contract) => {
+	const contractName = getContractNameFromPath(contract.contractFile);
+	return contractPrincipalCV(contract.address, contractName);
+};
+function bootContractIdentifier(name, mainnet) {
+	return `${mainnet ? MAINNET_BURN_ADDRESS : TESTNET_BURN_ADDRESS}.${name}`;
+}
+function bytesToHex(bytes) {
+	return hex.encode(bytes);
+}
+function hexToBytes(hexString) {
+	return hex.decode(hexString);
+}
+function bytesToAscii(bytes) {
+	const bytesArray = Array.from(bytes);
+	return String.fromCharCode.apply(null, bytesArray);
+}
+const isNumber = (value) => typeof value === "number";
+function extractErrors(contract) {
+	const { constants } = contract;
+	const result = {};
+	for (const key in constants) if (key.toLowerCase().startsWith("err")) {
+		const value = constants[key];
+		if (typeof value === "object" && value && "isOk" in value && !value.isOk && "value" in value) result[key] = value.value;
+		else result[key] = value;
+	}
+	return result;
+}
+function projectErrors(project) {
+	const { contracts } = project;
+	const result = {};
+	for (const key in contracts) result[key] = extractErrors(contracts[key]);
+	return result;
+}
+
+//#endregion
+//#region src/events.ts
+let CoreNodeEventType = /* @__PURE__ */ function(CoreNodeEventType$1) {
+	CoreNodeEventType$1["ContractEvent"] = "contract_event";
+	CoreNodeEventType$1["StxTransferEvent"] = "stx_transfer_event";
+	CoreNodeEventType$1["StxMintEvent"] = "stx_mint_event";
+	CoreNodeEventType$1["StxBurnEvent"] = "stx_burn_event";
+	CoreNodeEventType$1["StxLockEvent"] = "stx_lock_event";
+	CoreNodeEventType$1["NftTransferEvent"] = "nft_transfer_event";
+	CoreNodeEventType$1["NftMintEvent"] = "nft_mint_event";
+	CoreNodeEventType$1["NftBurnEvent"] = "nft_burn_event";
+	CoreNodeEventType$1["FtTransferEvent"] = "ft_transfer_event";
+	CoreNodeEventType$1["FtMintEvent"] = "ft_mint_event";
+	CoreNodeEventType$1["FtBurnEvent"] = "ft_burn_event";
+	return CoreNodeEventType$1;
+}({});
+function filterEvents(events, type) {
+	return events.filter((event) => event.type === type);
+}
+
+//#endregion
+//#region src/contracts.ts
+function makeContracts(contracts, options = {}) {
+	const instances = {};
+	for (const k in contracts) {
+		const contract = contracts[k];
+		const address = options.deployerAddress || contract.address;
+		instances[k] = {
+			identifier: `${address}.${contract.name}`,
+			contract: contract.contract(address, contract.name)
+		};
+	}
+	return instances;
+}
+
+//#endregion
+//#region src/clarity-types.ts
+/** biome-ignore-all lint/style/useTrimStartEnd: suppressed */
+function ok(value) {
+	return {
+		isOk: true,
+		value
+	};
+}
+function err(value) {
+	return {
+		isOk: false,
+		value
+	};
+}
+function isResponse(value) {
+	return typeof value === "object" && value !== null && "isOk" in value;
+}
+function principalToString(principal) {
+	return principal.value;
+}
+/**
+* @param val - ClarityValue
+* @param returnResponse - if true, this will return a "response" object.
+* Otherwise, it returns the inner value of the response (whether ok or err)
+*/
+function cvToValue(val, returnResponse = false) {
+	switch (val.type) {
+		case ClarityType.BoolTrue: return true;
+		case ClarityType.BoolFalse: return false;
+		case ClarityType.Int:
+		case ClarityType.UInt: return val.value;
+		case ClarityType.Buffer: return hexToBytes(val.value);
+		case ClarityType.OptionalNone: return null;
+		case ClarityType.OptionalSome: return cvToValue(val.value, true);
+		case ClarityType.ResponseErr:
+			if (returnResponse) return err(cvToValue(val.value, true));
+			return cvToValue(val.value, true);
+		case ClarityType.ResponseOk:
+			if (returnResponse) return ok(cvToValue(val.value, true));
+			return cvToValue(val.value, true);
+		case ClarityType.PrincipalStandard:
+		case ClarityType.PrincipalContract: return principalToString(val);
+		case ClarityType.List: return val.value.map((v) => cvToValue(v, true));
+		case ClarityType.Tuple: return Object.entries(val.value).reduce((acc, [key, val$1]) => {
+			const keyFixed = toCamelCase(key);
+			return {
+				...acc,
+				[keyFixed]: cvToValue(val$1, true)
+			};
+		}, {});
+		case ClarityType.StringASCII: return val.value;
+		case ClarityType.StringUTF8: return val.value;
+	}
+}
+/**
+* Converts a hex encoded string to the javascript clarity value object {type: string; value: any}
+* @param hex - the hex encoded string with or without `0x` prefix
+* @param jsonCompat - enable to serialize bigints to strings
+*/
+function hexToCvValue(hex$1, jsonCompat = false) {
+	return cvToValue(hexToCV$1(hex$1), jsonCompat);
+}
+function inputToBigInt(input) {
+	if (!(typeof input === "bigint" || typeof input === "number" || typeof input === "string")) throw new Error("Invalid input type for integer");
+	return BigInt(input);
+}
+const isClarityAbiPrimitive = (val) => typeof val === "string";
+const isClarityAbiBuffer = (val) => val.buffer !== void 0;
+const isClarityAbiStringAscii = (val) => val["string-ascii"] !== void 0;
+const isClarityAbiStringUtf8 = (val) => val["string-utf8"] !== void 0;
+const isClarityAbiResponse = (val) => val.response !== void 0;
+const isClarityAbiOptional = (val) => val.optional !== void 0;
+const isClarityAbiTuple = (val) => val.tuple !== void 0;
+const isClarityAbiList = (val) => val.list !== void 0;
+const isClarityAbiTraitReference = (val) => val === "trait_reference";
+function parseToCV(input, type) {
+	if (isClarityAbiTuple(type)) {
+		if (typeof input !== "object") throw new Error("Invalid tuple input");
+		const tuple = {};
+		type.tuple.forEach((key) => {
+			const val = input[findJsTupleKey(key.name, input)];
+			tuple[key.name] = parseToCV(val, key.type);
+		});
+		return tupleCV(tuple);
+	}
+	if (isClarityAbiList(type)) return listCV(input.map((input$1) => parseToCV(input$1, type.list.type)));
+	if (isClarityAbiOptional(type)) {
+		if (input === null) return noneCV();
+		return someCV(parseToCV(input, type.optional));
+	}
+	if (isClarityAbiStringAscii(type)) {
+		if (typeof input !== "string") throw new Error("Invalid string-ascii input");
+		return stringAsciiCV(input);
+	}
+	if (isClarityAbiStringUtf8(type)) {
+		if (typeof input !== "string") throw new Error("Invalid string-ascii input");
+		return stringUtf8CV(input);
+	}
+	if (isClarityAbiResponse(type)) {
+		if (!isResponse(input)) throw new Error("Invalid response input");
+		if (input.isOk) return responseOkCV(parseToCV(input.value, type.response.ok));
+		return responseErrorCV(parseToCV(input.value, type.response.error));
+	}
+	if (type === "bool") return parseToCV$1(typeof input === "boolean" ? input.toString() : input, type);
+	if (type === "uint128") return uintCV(inputToBigInt(input).toString());
+	if (type === "int128") return intCV(inputToBigInt(input).toString());
+	if (type === "trait_reference") {
+		if (typeof input !== "string") throw new Error("Invalid input for trait_reference");
+		const [addr, name] = input.split(".");
+		return contractPrincipalCV(addr, name);
+	}
+	if (isClarityAbiBuffer(type)) return bufferCV(input);
+	return parseToCV$1(input, type);
+}
+function cvToString(val, optionsOrEncoding) {
+	const options = typeof optionsOrEncoding === "object" ? optionsOrEncoding : {
+		encoding: optionsOrEncoding,
+		indent: void 0,
+		depth: void 0
+	};
+	const encoding = options.encoding ?? "hex";
+	const indent = options.indent;
+	const depth = options.depth ?? 0;
+	switch (val.type) {
+		case ClarityType.BoolTrue: return "true";
+		case ClarityType.BoolFalse: return "false";
+		case ClarityType.Int: return val.value.toString();
+		case ClarityType.UInt: return `u${val.value.toString()}`;
+		case ClarityType.Buffer:
+			if (encoding === "tryAscii") {
+				const str = bytesToAscii(hexToBytes(val.value));
+				if (/[ -~]/.test(str)) return JSON.stringify(str);
+			}
+			return `0x${val.value}`;
+		case ClarityType.OptionalNone: return "none";
+		case ClarityType.OptionalSome: return `(some ${cvToString(val.value, options)})`;
+		case ClarityType.ResponseErr: return `(err ${cvToString(val.value, options)})`;
+		case ClarityType.ResponseOk: return `(ok ${cvToString(val.value, options)})`;
+		case ClarityType.PrincipalStandard:
+		case ClarityType.PrincipalContract: return `'${principalToString(val)}`;
+		case ClarityType.List: return `(list ${val.value.map((v) => cvToString(v, options)).join(" ")})`;
+		case ClarityType.Tuple: {
+			const keys = Object.keys(val.value);
+			if (indent === void 0 || keys.length === 0) return `{ ${keys.map((key) => `${key}: ${cvToString(val.value[key], options)}`).join(", ")} }`;
+			const padding = " ".repeat((depth + 1) * indent);
+			const outerPadding = " ".repeat(depth * indent);
+			return `{\n${keys.map((key) => `${padding}${key}: ${cvToString(val.value[key], {
+				...options,
+				depth: depth + 1
+			})}`).join(",\n")}\n${outerPadding}}`;
+		}
+		case ClarityType.StringASCII: return `"${val.value}"`;
+		case ClarityType.StringUTF8: return `u"${val.value}"`;
+	}
+}
+/**
+* Convert a Clarity value to valid JSON. This does this same thing as
+* `cvToValue`, except that integers are returned as strings, and buffers
+* are returned as hex-encoded strings.
+*
+* @param val - ClarityValue
+*/
+function cvToJSON(val, returnResponse = false) {
+	switch (val.type) {
+		case ClarityType.BoolTrue: return true;
+		case ClarityType.BoolFalse: return false;
+		case ClarityType.Int:
+		case ClarityType.UInt: return `${val.value}`;
+		case ClarityType.Buffer: return val.value;
+		case ClarityType.OptionalNone: return null;
+		case ClarityType.OptionalSome: return cvToJSON(val.value);
+		case ClarityType.ResponseErr:
+			if (returnResponse) return err(cvToJSON(val.value));
+			return cvToJSON(val.value);
+		case ClarityType.ResponseOk:
+			if (returnResponse) return ok(cvToJSON(val.value));
+			return cvToJSON(val.value);
+		case ClarityType.PrincipalStandard:
+		case ClarityType.PrincipalContract: return principalToString(val);
+		case ClarityType.List: return val.value.map((v) => cvToJSON(v));
+		case ClarityType.Tuple: return Object.entries(val.value).reduce((acc, [key, val$1]) => {
+			const keyFixed = toCamelCase(key);
+			return {
+				...acc,
+				[keyFixed]: cvToJSON(val$1)
+			};
+		}, {});
+		case ClarityType.StringASCII: return val.value;
+		case ClarityType.StringUTF8: return val.value;
+	}
+}
+function transformObjectArgs(func, args) {
+	return func.args.map((abiArg) => {
+		const val = args[findJsTupleKey(abiArg.name, args)];
+		return parseToCV(val, abiArg.type);
+	});
+}
+function transformArgsArray(func, args) {
+	return args.map((arg, index) => parseToCV(arg, func.args[index].type));
+}
+function transformArgsToCV(func, args) {
+	if (args.length === 0) return [];
+	const [firstArg] = args;
+	if (args.length === 1 && func.args.length !== 1) return transformObjectArgs(func, firstArg);
+	if (typeof firstArg === "object" && !Array.isArray(firstArg) && firstArg !== null) try {
+		let hasAllArgs = true;
+		func.args.forEach((a) => {
+			try {
+				findJsTupleKey(a.name, firstArg);
+			} catch (_error) {
+				hasAllArgs = false;
+			}
+		});
+		if (hasAllArgs) return transformObjectArgs(func, firstArg);
+	} catch (_error) {}
+	return transformArgsArray(func, args);
+}
+function findJsTupleKey(key, input) {
+	const found = Object.keys(input).find((k) => {
+		const camelEq = key === k;
+		const kebabEq = key === toKebabCase(k);
+		return camelEq || kebabEq;
+	});
+	if (!found) throw new Error(`Error encoding JS tuple: ${key} not found in input.`);
+	return found;
+}
+function expectOk(response) {
+	if (response.isOk) return response.value;
+	throw new Error(`Expected OK, received error: ${String(response.value)}`);
+}
+function expectErr(response) {
+	if (!response.isOk) return response.value;
+	throw new Error(`Expected Err, received ok: ${String(response.value)}`);
+}
+function getTypeString(val) {
+	if (isClarityAbiPrimitive(val)) {
+		if (val === "int128") return "int";
+		if (val === "uint128") return "uint";
+		return val;
+	}
+	if (isClarityAbiBuffer(val)) return `(buff ${val.buffer.length})`;
+	if (isClarityAbiStringAscii(val)) return `(string-ascii ${val["string-ascii"].length})`;
+	if (isClarityAbiStringUtf8(val)) return `(string-utf8 ${val["string-utf8"].length})`;
+	if (isClarityAbiResponse(val)) return `(response ${getTypeString(val.response.ok)} ${getTypeString(val.response.error)})`;
+	if (isClarityAbiOptional(val)) return `(optional ${getTypeString(val.optional)})`;
+	if (isClarityAbiTuple(val)) return `{ ${val.tuple.map((t) => `${t.name}: ${getTypeString(t.type)}`).join(", ")} }`;
+	if (isClarityAbiList(val)) return `(list ${val.list.length} ${getTypeString(val.list.type)})`;
+	throw new Error(`Type string unsupported for Clarity type: ${JSON.stringify(val)}`);
+}
+
+//#endregion
+//#region src/factory.ts
+const DEPLOYMENT_NETWORKS = [
+	"devnet",
+	"simnet",
+	"testnet",
+	"mainnet"
+];
+function projectFactory(project, network) {
+	const e = [];
+	Object.entries(project.contracts).forEach(([contractName, contract]) => {
+		const id = project.deployments[contractName][network];
+		if (id) e.push([contractName, contractFactory(contract, id)]);
+		return false;
+	});
+	return Object.fromEntries(e);
+}
+function contractsFactory(contracts, deployer) {
+	return Object.fromEntries(Object.entries(contracts).map(([contractName, contract]) => {
+		return [contractName, contractFactory(contract, `${deployer}.${contract.contractName}`)];
+	}));
+}
+function functionsFactory(abi, identifier) {
+	return Object.fromEntries(Object.entries(abi.functions).map(([fnName, foundFunction]) => {
+		return [fnName, Object.assign((...args) => {
+			const functionArgs = transformArgsToCV(foundFunction, args);
+			const [contractAddress, contractName] = identifier.split(".");
+			return {
+				functionArgs,
+				contractAddress,
+				contractName,
+				function: foundFunction,
+				functionName: foundFunction.name,
+				nativeArgs: args,
+				contractAbi: abi
+			};
+		}, { abi: foundFunction })];
+	}));
+}
+/**
+* Provide a contract's types and it's contract identifier to generate
+* a full contract object with all functions available.
+*
+* @param abi - The Clarigen-generated contract types
+* @param identifier - The contract's identifier, like `SP000000000000000000002Q6VF78.bns`
+* @returns
+*/
+function contractFactory(abi, identifier) {
+	const full = { ...abi };
+	return {
+		...functionsFactory(abi, identifier),
+		...full,
+		identifier
+	};
+}
+function deploymentFactory(contracts, deployer) {
+	const result = {};
+	getContractTxs(deployer.plan.batches).forEach((tx) => {
+		const id = getIdentifierForDeploymentTx(tx);
+		const [contractAddress, contractFileName] = id.split(".");
+		const contractName = toCamelCase(contractFileName);
+		const def = contracts[contractName];
+		const final = contracts[contractName];
+		if (typeof final === "undefined") throw new Error(`Clarigen error: mismatch for contract '${contractName}'`);
+		result[contractName] = final;
+		final.contractFile = getDeploymentTxPath(tx);
+		final.identifier = id;
+		Object.keys(contracts[contractName].functions).forEach((_fnName) => {
+			const fnName = _fnName;
+			const fn = ((...args) => {
+				const foundFunction = def.functions[fnName];
+				return {
+					functionArgs: transformArgsToCV(foundFunction, args),
+					contractAddress,
+					contractName: final.contractName,
+					function: foundFunction,
+					nativeArgs: args
+				};
+			});
+			final[fnName] = fn;
+		});
+	});
+	return result;
+}
+function mapFactory(map, key) {
+	return {
+		key,
+		keyCV: parseToCV(key, map.key),
+		map
+	};
+}
+
+//#endregion
+//#region src/api/api-helpers.ts
+/** biome-ignore-all lint/style/useTrimStartEnd: suppressed */
+function getHeaders(apiKey, headersOverride = {}) {
+	const headers = { ...headersOverride };
+	if (apiKey) headers["x-api-key"] = apiKey;
+	return headers;
+}
+function smartContractsApi(url, apiKey, headersOverride) {
+	return new SmartContractsApi(new Configuration({
+		basePath: url,
+		headers: getHeaders(apiKey, headersOverride)
+	}));
+}
+function v2Endpoint(url) {
+	return `${url}/v2`;
+}
+const generateUrl = (baseUrl, params) => {
+	try {
+		const url = new URL(baseUrl);
+		Object.keys(params).forEach((key) => {
+			const value = params[key];
+			if (!value) return;
+			if (Array.isArray(value)) {
+				if (value.length === 0) return;
+				return url.searchParams.set(`${key}[]`, generateQueryStringFromArray(key, value));
+			}
+			if (typeof value === "boolean" || isNumber(value)) return url.searchParams.set(key, String(value));
+			url.searchParams.set(key, value);
+		});
+		return url.toString();
+	} catch (e) {
+		console.error("generateUrl");
+		console.error(e);
+		return baseUrl;
+	}
+};
+const generateQueryStringFromArray = (key, values) => {
+	if (values === null || values === void 0 ? void 0 : values.length) return `${values.map((value, index) => `${index > 0 ? encodeURIComponent(`${key}[]`) : ""}=${encodeURIComponent(value)}`).join("&")}`;
+	return "";
+};
+
+//#endregion
+//#region src/api/call-read-only.ts
+/**
+* Converts the response of a read-only function call into its Clarity Value
+* @param response - {@link ReadOnlyFunctionResponse}
+*/
+function parseReadOnlyResponse(response) {
+	if (response.okay) return hexToCV$1(response.result);
+	throw new Error(response.cause);
+}
+/**
+* Calls a read only function from a contract interface
+*
+* @param options - the options object
+*
+* Returns an ClarityValue
+*
+*/
+async function callReadOnlyFunction(options) {
+	const { contractAddress, functionArgs, senderAddress = contractAddress, url } = options;
+	return parseReadOnlyResponse(await smartContractsApi(url, options.apiKey, options.headers).callReadOnlyFunction({
+		...options,
+		readOnlyFunctionArgs: {
+			sender: senderAddress,
+			arguments: functionArgs.map((arg) => typeof arg === "string" ? arg : cvToHex$1(arg))
+		}
+	}));
+}
+
+//#endregion
+//#region src/api/url-parsing.ts
+function isOptionalFormValue(value) {
+	return typeof value === "object" && value !== null && "isNone" in value && typeof value.isNone === "boolean";
+}
+function isResponseFormValue(value) {
+	return typeof value === "object" && value !== null && "isOk" in value && typeof value.isOk === "boolean";
+}
+/**
+* Converts a form value to the format expected by parseToCV.
+* Handles differences between form representation and parseToCV expectations:
+* - Optionals use { isNone, value } in forms but null for none in parseToCV
+* - Buffers are hex strings in forms but Uint8Array in parseToCV
+*/
+function formValueToParseable(value, type) {
+	if (isClarityAbiOptional(type)) {
+		if (isOptionalFormValue(value)) {
+			if (value.isNone) return null;
+			return formValueToParseable(value.value, type.optional);
+		}
+		return value;
+	}
+	if (isClarityAbiBuffer(type)) {
+		if (typeof value === "string") return hexToBytes(value.startsWith("0x") ? value.slice(2) : value);
+		return value;
+	}
+	if (isClarityAbiTuple(type)) {
+		if (typeof value !== "object" || value === null) return value;
+		const result = {};
+		for (const member of type.tuple) {
+			const memberValue = value[member.name];
+			result[member.name] = formValueToParseable(memberValue, member.type);
+		}
+		return result;
+	}
+	if (isClarityAbiList(type)) {
+		if (!Array.isArray(value)) return value;
+		return value.map((item) => formValueToParseable(item, type.list.type));
+	}
+	return value;
+}
+/**
+* Converts a single form value to a ClarityValue using the ABI type.
+*/
+function formValueToCV(value, type) {
+	if (isClarityAbiResponse(type)) {
+		if (!isResponseFormValue(value)) throw new Error("Response type requires { isOk: boolean, value: unknown } form value");
+		const innerType = value.isOk ? type.response.ok : type.response.error;
+		const innerCV = formValueToCV(value.isOk ? value.ok ?? value.value : value.err ?? value.value, innerType);
+		return value.isOk ? responseOkCV(innerCV) : responseErrorCV(innerCV);
+	}
+	return parseToCV(formValueToParseable(value, type), type);
+}
+/**
+* Parses a raw string value from a URL query parameter into a "form value"
+* based on the Clarity ABI type. This intermediate form value can then
+* be converted to a ClarityValue using `formValueToCV`.
+*/
+function parseQueryValue(value, type) {
+	if (value === void 0 || value === "") {
+		if (isClarityAbiOptional(type)) return {
+			isNone: true,
+			value: null
+		};
+		if (isClarityAbiList(type)) return [];
+		if (isClarityAbiTuple(type)) return {};
+		if (isClarityAbiPrimitive(type) && type === "bool") return false;
+		return "";
+	}
+	if (type === "principal" && value.startsWith("'")) return value.slice(1);
+	if (isClarityAbiOptional(type) || isClarityAbiList(type) || isClarityAbiTuple(type) || isClarityAbiResponse(type)) try {
+		return JSON.parse(value);
+	} catch {
+		return value;
+	}
+	if (isClarityAbiPrimitive(type) && type === "bool") return value === "true";
+	return value;
+}
+/**
+* Converts all query parameters to an array of ClarityValues based on the function's ABI args.
+*/
+function queryToFunctionArgs(query, args) {
+	return args.map((arg) => {
+		const rawValue = query[arg.name];
+		return formValueToCV(parseQueryValue(Array.isArray(rawValue) ? rawValue[0] : rawValue, arg.type), arg.type);
+	});
+}
+
+//#endregion
+//#region src/api/index.ts
+/** biome-ignore-all lint/style/useTrimStartEnd: suppressed */
+function getTip(options) {
+	if (options.latest === false) return;
+	if (options.latest) return "latest";
+	if (typeof options.tip === "undefined") return "latest";
+	return options.tip;
+}
+async function ro(tx, options) {
+	const tip = getTip(options);
+	const cv = await callReadOnlyFunction({
+		contractAddress: tx.contractAddress,
+		contractName: tx.contractName,
+		functionName: tx.functionName,
+		functionArgs: tx.functionArgs,
+		tip,
+		url: getApiUrl(options),
+		apiKey: options.apiKey,
+		headers: options.headers
+	});
+	if (options.json) return cvToJSON(cv);
+	return cvToValue(cv, true);
+}
+async function roOk(tx, options) {
+	return expectOk(await ro(tx, options));
+}
+async function roErr(tx, options) {
+	return expectErr(await ro(tx, options));
+}
+function getApiUrl(opts) {
+	return networkFrom(opts.network).client.baseUrl;
+}
+async function fetchMapGet(contractId, map, key, options) {
+	const payload = mapFactory(map, key);
+	const lookupKey = JSON.stringify(cvToHex(payload.keyCV));
+	const [addr, id] = contractId.split(".");
+	const path = generateUrl(`${v2Endpoint(getApiUrl(options))}/map_entry/${addr}/${id}/${payload.map.name}`, {
+		proof: 0,
+		tip: getTip(options)
+	});
+	return cvToValue(hexToCV((await (await fetch(path, {
+		method: "POST",
+		body: lookupKey,
+		headers: {
+			"Content-Type": "application/json",
+			Accept: "application/json",
+			...getHeaders(options.apiKey, options.headers)
+		}
+	})).json()).data), true);
+}
+async function broadcast(transaction, options) {
+	const network = options.network;
+	const result = await broadcastTransaction({
+		transaction,
+		network
+	});
+	if ("error" in result) throw new Error(`Error broadcasting tx: ${result.error} - ${result.reason} - ${JSON.stringify("reason_data" in result ? result.reason_data : void 0)}`);
+	return {
+		txId: result.txid,
+		stacksTransaction: transaction
+	};
+}
+var ClarigenClient = class {
+	network;
+	constructor(networkOrUrl, apiKey, headers) {
+		this.apiKey = apiKey;
+		this.headers = headers;
+		this.network = networkOrUrl;
+	}
+	roOptions(options) {
+		return {
+			network: this.network,
+			apiKey: this.apiKey,
+			headers: this.headers,
+			...options
+		};
+	}
+	ro(tx, options) {
+		return ro(tx, this.roOptions(options || {}));
+	}
+	roOk(tx, options) {
+		return roOk(tx, this.roOptions(options || {}));
+	}
+	roErr(tx, options) {
+		return roErr(tx, this.roOptions(options || {}));
+	}
+};
+
+//#endregion
+//#region src/post-conditions.ts
+function createAssetInfo(contract, asset) {
+	const [addr, name] = contract.identifier.split(".");
+	if (!("identifier" in contract)) throw new Error("Invalid contract");
+	for (const nft of contract.non_fungible_tokens) if (nft.name === asset) return `${addr}.${name}::${nft.name}`;
+	for (const ft of contract.fungible_tokens) if (ft.name === asset) return `${addr}.${name}::${ft.name}`;
+	throw new Error(`Invalid asset: "${asset}" is not an asset in contract.`);
+}
+function makeNonFungiblePostCondition(contract, sender, condition, value) {
+	const [nftType] = contract.non_fungible_tokens;
+	const asset = createAssetInfo(contract, nftType.name);
+	const abiType = nftType.type;
+	return {
+		type: "nft-postcondition",
+		address: sender,
+		condition,
+		asset,
+		assetId: parseToCV(value, abiType)
+	};
+}
+function makeFungiblePostCondition(contract, sender, condition, amount) {
+	const [_addr, _name] = sender.split(".");
+	const [ftType] = contract.fungible_tokens;
+	return {
+		type: "ft-postcondition",
+		address: sender,
+		condition,
+		asset: createAssetInfo(contract, ftType.name),
+		amount
+	};
+}
+
+//#endregion
+//#region src/raw-clarity.ts
+/** biome-ignore-all lint/style/useTrimStartEnd: suppressed */
+function unwrap(input, prefix = "") {
+	return input.slice(prefix.length + 2, -1);
+}
+function rawClarityToValue(input, type) {
+	if (isClarityAbiTuple(type)) {
+		const decoded = expectTuple(input);
+		const tuple = {};
+		const tupleReduced = Object.entries(decoded).reduce((acc, [key, val]) => {
+			const keyFixed = key.trim();
+			return {
+				...acc,
+				[keyFixed]: val.trim()
+			};
+		}, {});
+		type.tuple.forEach(({ name, type: _type }) => {
+			const camelName = toCamelCase(name);
+			tuple[camelName] = rawClarityToValue(tupleReduced[name], _type);
+		});
+		return tuple;
+	}
+	if (isClarityAbiList(type)) return expectList(input).map((e) => rawClarityToValue(e, type.list.type));
+	if (isClarityAbiOptional(type)) {
+		if (input === "none") return null;
+		return rawClarityToValue(unwrap(input, "some"), type.optional);
+	}
+	if (isClarityAbiStringAscii(type)) return input.slice(1, -1);
+	if (isClarityAbiStringUtf8(type)) return input.slice(2, -1);
+	if (type === "bool") return input === "true";
+	if (type === "uint128") return BigInt(input.slice(1));
+	if (type === "int128") return BigInt(input);
+	if (type === "trait_reference") return input.replace(/^'/, "");
+	if (type === "principal") return input.replace(/^'/, "");
+	if (type === "none") return null;
+	if (isClarityAbiBuffer(type)) return hexToBytes(input.slice(2));
+	if (isClarityAbiResponse(type)) {
+		if (input.startsWith("(ok")) return ok(rawClarityToValue(unwrap(input, "ok"), type.response.ok));
+		return err(rawClarityToValue(unwrap(input, "err"), type.response.error));
+	}
+	throw new Error(`Unable to parse cv string to value: ${input} ${JSON.stringify(type, null, 2)}`);
+}
+const byteToHexCache = new Array(255);
+for (let n = 0; n <= 255; ++n) byteToHexCache[n] = n.toString(16).padStart(2, "0");
+function expectList(input) {
+	if (input.charAt(0) !== "[" || input.at(-1) !== "]") throw new Error(`Expected (list ..), got ${input.toString()}`);
+	const stack = [];
+	const elements = [];
+	let start = 1;
+	for (let i = 0; i < input.length; i++) {
+		if (input.charAt(i) === "," && stack.length === 1) {
+			elements.push(input.substring(start, i));
+			start = i + 2;
+		}
+		if ([
+			"(",
+			"[",
+			"{"
+		].includes(input.charAt(i))) stack.push(input.charAt(i));
+		if (input.charAt(i) === ")" && stack.at(-1) === "(") stack.pop();
+		if (input.charAt(i) === "}" && stack.at(-1) === "{") stack.pop();
+		if (input.charAt(i) === "]" && stack.at(-1) === "[") stack.pop();
+	}
+	const remainder = input.substring(start, input.length - 1);
+	if (remainder.length > 0) elements.push(remainder);
+	return elements;
+}
+function expectTuple(input) {
+	if (input.charAt(0) !== "{" || input.at(-1) !== "}") throw new Error(`Expected '(tuple ..)', got ${input.toString()}`);
+	let start = 1;
+	const stack = [];
+	const elements = [];
+	for (let i = 0; i < input.length; i++) {
+		if (input.charAt(i) === "," && stack.length === 1) {
+			elements.push(input.substring(start, i));
+			start = i + 2;
+		}
+		if ([
+			"(",
+			"[",
+			"{"
+		].includes(input.charAt(i))) stack.push(input.charAt(i));
+		if (input.charAt(i) === ")" && stack.at(-1) === "(") stack.pop();
+		if (input.charAt(i) === "}" && stack.at(-1) === "{") stack.pop();
+		if (input.charAt(i) === "]" && stack.at(-1) === "[") stack.pop();
+	}
+	const remainder = input.substring(start, input.length - 1);
+	if (remainder.length > 0) elements.push(remainder);
+	const tuple = {};
+	for (const element of elements) for (let i = 0; i < element.length; i++) if (element.charAt(i) === ":") {
+		const key = element.substring(0, i);
+		tuple[key] = element.substring(i + 2, element.length);
+		break;
+	}
+	return tuple;
+}
+
+//#endregion
+export { ClarigenClient, CoreNodeEventType, DEPLOYMENT_NETWORKS, MAINNET_BURN_ADDRESS, TESTNET_BURN_ADDRESS, bootContractIdentifier, broadcast, bytesToAscii, bytesToHex, callReadOnlyFunction, contractFactory, contractsFactory, createAssetInfo, cvToHex, cvToJSON, cvToString, cvToValue, deploymentFactory, err, expectErr, expectOk, extractErrors, fetchMapGet, filterEvents, findJsTupleKey, formValueToCV, formValueToParseable, functionsFactory, getApiUrl, getContractIdentifier, getContractName, getContractNameFromPath, getContractPrincipalCV, getTypeString, hexToBytes, hexToCV, hexToCvValue, isClarityAbiBuffer, isClarityAbiList, isClarityAbiOptional, isClarityAbiPrimitive, isClarityAbiResponse, isClarityAbiStringAscii, isClarityAbiStringUtf8, isClarityAbiTraitReference, isClarityAbiTuple, isNumber, isOptionalFormValue, isResponse, isResponseFormValue, makeContracts, makeFungiblePostCondition, makeNonFungiblePostCondition, mapFactory, ok, parseQueryValue, parseReadOnlyResponse, parseToCV, principalToString, projectErrors, projectFactory, queryToFunctionArgs, rawClarityToValue, ro, roErr, roOk, toCamelCase, toKebabCase, transformArgsArray, transformArgsToCV, transformObjectArgs };
+//# sourceMappingURL=index.mjs.map