@amadeus-protocol/sdk 1.0.8 → 1.1.0

package/dist/contracts/contract-call.d.ts

@@ -1,24 +1,20 @@
-/**
- * Core ContractCall Abstraction
- *
- * Provides a generic, ABI-driven way to build contract calls with both
- * compile-time type safety and runtime validation.
- */
-import type { SerializableValue } from '../types';
-import type { AbiDefinition, ExtractFunctionNames, FunctionParams } from './abi-types';
+import { SerializableValue } from "../types.js";
+import { AbiDefinition, ExtractFunctionNames, FunctionParams } from "./abi-types.js";
+
+//#region src/contracts/contract-call.d.ts
 /**
  * A fully-resolved contract call ready for TransactionBuilder.
  *
  * The type parameters are optional and used only for documentation;
  * at runtime this is just `{ contract, method, args }`.
  */
-export interface ContractCall<_TAbi extends AbiDefinition = AbiDefinition, _TFn extends string = string> {
-    /** Contract name (e.g. 'LockupPrime', 'Lockup', 'Coin') */
-    readonly contract: string;
-    /** Function/method name (e.g. 'lock', 'unlock', 'transfer') */
-    readonly method: string;
-    /** Serialized args array ready for VecPack encoding */
-    readonly args: SerializableValue[];
+interface ContractCall<_TAbi extends AbiDefinition = AbiDefinition, _TFn extends string = string> {
+  /** Contract name (e.g. 'LockupPrime', 'Lockup', 'Coin') */
+  readonly contract: string;
+  /** Function/method name (e.g. 'lock', 'unlock', 'transfer') */
+  readonly method: string;
+  /** Serialized args array ready for VecPack encoding */
+  readonly args: SerializableValue[];
 }
 /**
  * Build a type-safe ContractCall from an ABI definition.
@@ -45,5 +41,7 @@ export interface ContractCall<_TAbi extends AbiDefinition = AbiDefinition, _TFn
  * // call.args === ['1000000000', '30d']
  * ```
  */
-export declare function buildContractCall<TAbi extends AbiDefinition, TFn extends ExtractFunctionNames<TAbi>>(abi: TAbi, functionName: TFn, params: FunctionParams<TAbi, TFn & string>): ContractCall<TAbi, TFn & string>;
+declare function buildContractCall<TAbi extends AbiDefinition, TFn extends ExtractFunctionNames<TAbi>>(abi: TAbi, functionName: TFn, params: FunctionParams<TAbi, TFn & string>): ContractCall<TAbi, TFn & string>;
+//#endregion
+export { ContractCall, buildContractCall };
 //# sourceMappingURL=contract-call.d.ts.map

package/dist/contracts/contract-call.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contract-call.d.ts","sourceRoot":"","sources":["../../src/contracts/contract-call.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AACjD,OAAO,KAAK,EAAE,aAAa,EAAuB,oBAAoB,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAE3G;;;;;GAKG;AACH,MAAM,WAAW,YAAY,CAC5B,KAAK,SAAS,aAAa,GAAG,aAAa,EAC3C,IAAI,SAAS,MAAM,GAAG,MAAM;IAE5B,2DAA2D;IAC3D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,+DAA+D;IAC/D,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,uDAAuD;IACvD,QAAQ,CAAC,IAAI,EAAE,iBAAiB,EAAE,CAAA;CAClC;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,SAAS,aAAa,EAC1B,GAAG,SAAS,oBAAoB,CAAC,IAAI,CAAC,EAEtC,GAAG,EAAE,IAAI,EACT,YAAY,EAAE,GAAG,EACjB,MAAM,EAAE,cAAc,CAAC,IAAI,EAAE,GAAG,GAAG,MAAM,CAAC,GACxC,YAAY,CAAC,IAAI,EAAE,GAAG,GAAG,MAAM,CAAC,CAkClC"}
+{"version":3,"file":"contract-call.d.ts","names":[],"sources":["../../src/contracts/contract-call.ts"],"mappings":";;;;;;;;;;UAqBiB,YAAA,eACF,aAAA,GAAgB,aAAA;EAC9B;EAAA,SAGS,QAAA;EAEA;EAAA,SAAA,MAAA;EAEM;EAAA,SAAN,IAAA,EAAM,iBAAA;AAAA;AA4BhB;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,iBAAgB,iBAAA,cACF,aAAA,cACD,oBAAA,CAAqB,IAAA,EAAA,CAEjC,GAAA,EAAK,IAAA,EACL,YAAA,EAAc,GAAA,EACd,MAAA,EAAQ,cAAA,CAAe,IAAA,EAAM,GAAA,aAC3B,YAAA,CAAa,IAAA,EAAM,GAAA"}

package/dist/contracts/contract-call.js

@@ -1,57 +1,48 @@
+//#region src/contracts/contract-call.ts
 /**
- * Core ContractCall Abstraction
- *
- * Provides a generic, ABI-driven way to build contract calls with both
- * compile-time type safety and runtime validation.
- */
-/**
- * Build a type-safe ContractCall from an ABI definition.
- *
- * Compile-time:
- * - `functionName` is constrained to the ABI's function name union
- * - `params` is typed per the function's declared inputs
- *
- * Runtime:
- * - Validates function exists in ABI
- * - Validates all required params are present
- * - Validates enum constraints on inputs that declare them
- *
- * @example
- * ```ts
- * import { LOCKUP_PRIME_ABI } from './lockup-prime/abi'
- *
- * const call = buildContractCall(LOCKUP_PRIME_ABI, 'lock', {
- *   amount: '1000000000',
- *   tier: '30d'
- * })
- * // call.contract === 'LockupPrime'
- * // call.method === 'lock'
- * // call.args === ['1000000000', '30d']
- * ```
- */
-export function buildContractCall(abi, functionName, params) {
-    const fn = abi.abi.find((f) => f.name === functionName);
-    if (!fn) {
-        throw new Error(`Function "${String(functionName)}" not found in ${abi.contractName} ABI`);
-    }
-    const args = [];
-    for (const input of fn.inputs) {
-        const value = params[input.name];
-        if (value === undefined || value === null) {
-            throw new Error(`Missing required parameter "${input.name}" for ${abi.contractName}.${String(functionName)}`);
-        }
-        if (input.enum && input.enum.length > 0) {
-            if (!input.enum.includes(value)) {
-                throw new Error(`Invalid value "${value}" for parameter "${input.name}". ` +
-                    `Expected one of: ${input.enum.join(', ')}`);
-            }
-        }
-        args.push(value);
-    }
-    return {
-        contract: abi.contractName,
-        method: functionName,
-        args
-    };
+* Build a type-safe ContractCall from an ABI definition.
+*
+* Compile-time:
+* - `functionName` is constrained to the ABI's function name union
+* - `params` is typed per the function's declared inputs
+*
+* Runtime:
+* - Validates function exists in ABI
+* - Validates all required params are present
+* - Validates enum constraints on inputs that declare them
+*
+* @example
+* ```ts
+* import { LOCKUP_PRIME_ABI } from './lockup-prime/abi'
+*
+* const call = buildContractCall(LOCKUP_PRIME_ABI, 'lock', {
+*   amount: '1000000000',
+*   tier: '30d'
+* })
+* // call.contract === 'LockupPrime'
+* // call.method === 'lock'
+* // call.args === ['1000000000', '30d']
+* ```
+*/
+function buildContractCall(abi, functionName, params) {
+	const fn = abi.abi.find((f) => f.name === functionName);
+	if (!fn) throw new Error(`Function "${String(functionName)}" not found in ${abi.contractName} ABI`);
+	const args = [];
+	for (const input of fn.inputs) {
+		const value = params[input.name];
+		if (value === void 0 || value === null) throw new Error(`Missing required parameter "${input.name}" for ${abi.contractName}.${String(functionName)}`);
+		if (input.enum && input.enum.length > 0) {
+			if (!input.enum.includes(value)) throw new Error(`Invalid value "${value}" for parameter "${input.name}". Expected one of: ${input.enum.join(", ")}`);
+		}
+		args.push(value);
+	}
+	return {
+		contract: abi.contractName,
+		method: functionName,
+		args
+	};
 }
+//#endregion
+export { buildContractCall };
+
 //# sourceMappingURL=contract-call.js.map

package/dist/contracts/contract-call.js.map

@@ -1 +1 @@
-{"version":3,"file":"contract-call.js","sourceRoot":"","sources":["../../src/contracts/contract-call.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAuBH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,MAAM,UAAU,iBAAiB,CAIhC,GAAS,EACT,YAAiB,EACjB,MAA0C;IAE1C,MAAM,EAAE,GAAG,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,YAAY,CAAC,CAAA;IACvD,IAAI,CAAC,EAAE,EAAE,CAAC;QACT,MAAM,IAAI,KAAK,CACd,aAAa,MAAM,CAAC,YAAY,CAAC,kBAAkB,GAAG,CAAC,YAAY,MAAM,CACzE,CAAA;IACF,CAAC;IAED,MAAM,IAAI,GAAwB,EAAE,CAAA;IACpC,KAAK,MAAM,KAAK,IAAI,EAAE,CAAC,MAAM,EAAE,CAAC;QAC/B,MAAM,KAAK,GAAI,MAAiC,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAC5D,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;YAC3C,MAAM,IAAI,KAAK,CACd,+BAA+B,KAAK,CAAC,IAAI,SAAS,GAAG,CAAC,YAAY,IAAI,MAAM,CAAC,YAAY,CAAC,EAAE,CAC5F,CAAA;QACF,CAAC;QAED,IAAI,KAAK,CAAC,IAAI,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACzC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;gBACjC,MAAM,IAAI,KAAK,CACd,kBAAkB,KAAK,oBAAoB,KAAK,CAAC,IAAI,KAAK;oBAC1D,oBAAoB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC3C,CAAA;YACF,CAAC;QACF,CAAC;QAED,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;IACjB,CAAC;IAED,OAAO;QACN,QAAQ,EAAE,GAAG,CAAC,YAAyC;QACvD,MAAM,EAAE,YAAsB;QAC9B,IAAI;KACJ,CAAA;AACF,CAAC"}
+{"version":3,"file":"contract-call.js","names":[],"sources":["../../src/contracts/contract-call.ts"],"sourcesContent":["/**\n * Core ContractCall Abstraction\n *\n * Provides a generic, ABI-driven way to build contract calls with both\n * compile-time type safety and runtime validation.\n */\n\nimport type { SerializableValue } from '../types'\nimport type {\n\tAbiDefinition,\n\tExtractContractName,\n\tExtractFunctionNames,\n\tFunctionParams\n} from './abi-types'\n\n/**\n * A fully-resolved contract call ready for TransactionBuilder.\n *\n * The type parameters are optional and used only for documentation;\n * at runtime this is just `{ contract, method, args }`.\n */\nexport interface ContractCall<\n\t_TAbi extends AbiDefinition = AbiDefinition,\n\t_TFn extends string = string\n> {\n\t/** Contract name (e.g. 'LockupPrime', 'Lockup', 'Coin') */\n\treadonly contract: string\n\t/** Function/method name (e.g. 'lock', 'unlock', 'transfer') */\n\treadonly method: string\n\t/** Serialized args array ready for VecPack encoding */\n\treadonly args: SerializableValue[]\n}\n\n/**\n * Build a type-safe ContractCall from an ABI definition.\n *\n * Compile-time:\n * - `functionName` is constrained to the ABI's function name union\n * - `params` is typed per the function's declared inputs\n *\n * Runtime:\n * - Validates function exists in ABI\n * - Validates all required params are present\n * - Validates enum constraints on inputs that declare them\n *\n * @example\n * ```ts\n * import { LOCKUP_PRIME_ABI } from './lockup-prime/abi'\n *\n * const call = buildContractCall(LOCKUP_PRIME_ABI, 'lock', {\n *   amount: '1000000000',\n *   tier: '30d'\n * })\n * // call.contract === 'LockupPrime'\n * // call.method === 'lock'\n * // call.args === ['1000000000', '30d']\n * ```\n */\nexport function buildContractCall<\n\tTAbi extends AbiDefinition,\n\tTFn extends ExtractFunctionNames<TAbi>\n>(\n\tabi: TAbi,\n\tfunctionName: TFn,\n\tparams: FunctionParams<TAbi, TFn & string>\n): ContractCall<TAbi, TFn & string> {\n\tconst fn = abi.abi.find((f) => f.name === functionName)\n\tif (!fn) {\n\t\tthrow new Error(`Function \"${String(functionName)}\" not found in ${abi.contractName} ABI`)\n\t}\n\n\tconst args: SerializableValue[] = []\n\tfor (const input of fn.inputs) {\n\t\tconst value = (params as Record<string, string>)[input.name]\n\t\tif (value === undefined || value === null) {\n\t\t\tthrow new Error(\n\t\t\t\t`Missing required parameter \"${input.name}\" for ${abi.contractName}.${String(functionName)}`\n\t\t\t)\n\t\t}\n\n\t\tif (input.enum && input.enum.length > 0) {\n\t\t\tif (!input.enum.includes(value)) {\n\t\t\t\tthrow new Error(\n\t\t\t\t\t`Invalid value \"${value}\" for parameter \"${input.name}\". ` +\n\t\t\t\t\t\t`Expected one of: ${input.enum.join(', ')}`\n\t\t\t\t)\n\t\t\t}\n\t\t}\n\n\t\targs.push(value)\n\t}\n\n\treturn {\n\t\tcontract: abi.contractName as ExtractContractName<TAbi>,\n\t\tmethod: functionName as string,\n\t\targs\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0DA,SAAgB,kBAIf,KACA,cACA,QACmC;CACnC,MAAM,KAAK,IAAI,IAAI,MAAM,MAAM,EAAE,SAAS,aAAa;CACvD,IAAI,CAAC,IACJ,MAAM,IAAI,MAAM,aAAa,OAAO,aAAa,CAAC,iBAAiB,IAAI,aAAa,MAAM;CAG3F,MAAM,OAA4B,EAAE;CACpC,KAAK,MAAM,SAAS,GAAG,QAAQ;EAC9B,MAAM,QAAS,OAAkC,MAAM;EACvD,IAAI,UAAU,KAAA,KAAa,UAAU,MACpC,MAAM,IAAI,MACT,+BAA+B,MAAM,KAAK,QAAQ,IAAI,aAAa,GAAG,OAAO,aAAa,GAC1F;EAGF,IAAI,MAAM,QAAQ,MAAM,KAAK,SAAS;OACjC,CAAC,MAAM,KAAK,SAAS,MAAM,EAC9B,MAAM,IAAI,MACT,kBAAkB,MAAM,mBAAmB,MAAM,KAAK,sBACjC,MAAM,KAAK,KAAK,KAAK,GAC1C;;EAIH,KAAK,KAAK,MAAM;;CAGjB,OAAO;EACN,UAAU,IAAI;EACd,QAAQ;EACR;EACA"}

package/dist/contracts/contract.d.ts

@@ -1,51 +1,23 @@
-/**
- * ABI-Driven Contract Factory
- *
- * Generates fully-typed contract interfaces from `as const` ABI definitions,
- * similar to viem's getContract() or ethers typechain.
- *
- * Each function declared in the ABI becomes a typed method on the contract
- * object — with autocomplete for function names and typed params derived
- * from the ABI inputs.
- *
- * @example
- * ```ts
- * import { createContract, LOCKUP_PRIME_ABI, toAtomicAma } from '@amadeus-protocol/sdk'
- *
- * // Unsigned — returns ContractCall for TransactionBuilder.signCall()
- * const lockupPrime = createContract(LOCKUP_PRIME_ABI)
- * const call = lockupPrime.lock({ amount: toAtomicAma(100).toString(), tier: '30d' })
- * const { txHash, txPacked } = TransactionBuilder.signCall(privateKey, call)
- *
- * // Signed — bind a private key, methods return BuildTransactionResult directly
- * const signed = createContract(LOCKUP_PRIME_ABI).connect(privateKey)
- * const result = signed.lock({ amount: toAtomicAma(100).toString(), tier: '30d' })
- * ```
- */
-import type { BuildTransactionResult } from '../types';
-import type { AbiDefinition, AbiInput } from './abi-types';
-import type { ContractCall } from './contract-call';
+import { BuildTransactionResult } from "../types.js";
+import { AbiDefinition, AbiInput } from "./abi-types.js";
+import { ContractCall } from "./contract-call.js";
+
+//#region src/contracts/contract.d.ts
 /**
  * Map an ABI inputs tuple to a params object: `{ inputName: string }`
  */
-type InputsToParams<Inputs extends readonly AbiInput[]> = {
-    readonly [I in Inputs[number] as I['name']]: string;
-};
+type InputsToParams<Inputs extends readonly AbiInput[]> = { readonly [I in Inputs[number] as I['name']]: string };
 /**
  * For each function in the ABI, generate a typed method signature.
  *
  * - Functions with inputs → `(params: { name: string, ... }) => ContractCall`
  * - Functions without inputs → `() => ContractCall`
  */
-type ContractMethods<TAbi extends AbiDefinition> = {
-    readonly [F in TAbi['abi'][number] as F['name']]: F['inputs'] extends readonly [] ? () => ContractCall : (params: InputsToParams<F['inputs']>) => ContractCall;
-};
+type ContractMethods<TAbi extends AbiDefinition> = { readonly [F in TAbi['abi'][number] as F['name']]: F['inputs'] extends readonly [] ? () => ContractCall : (params: InputsToParams<F['inputs']>) => ContractCall };
 /**
  * Same as ContractMethods but methods return signed `BuildTransactionResult`.
  */
-type SignedContractMethods<TAbi extends AbiDefinition> = {
-    readonly [F in TAbi['abi'][number] as F['name']]: F['inputs'] extends readonly [] ? () => BuildTransactionResult : (params: InputsToParams<F['inputs']>) => BuildTransactionResult;
-};
+type SignedContractMethods<TAbi extends AbiDefinition> = { readonly [F in TAbi['abi'][number] as F['name']]: F['inputs'] extends readonly [] ? () => BuildTransactionResult : (params: InputsToParams<F['inputs']>) => BuildTransactionResult };
 /**
  * A typed contract interface generated from an ABI definition.
  *
@@ -55,18 +27,16 @@ type SignedContractMethods<TAbi extends AbiDefinition> = {
  * Call `.connect(privateKey)` to get a `SignedContract` where methods
  * return `BuildTransactionResult` directly.
  */
-export type TypedContract<TAbi extends AbiDefinition> = ContractMethods<TAbi> & {
-    /** The original ABI definition */
-    readonly abi: TAbi;
-    /** Contract name extracted from ABI */
-    readonly contractName: TAbi['contractName'];
-    /**
-     * Bind a signer to produce a `SignedContract` where every method
-     * derives keys, builds, and signs in one step.
-     *
-     * @param privateKey - Base58 encoded private key (seed)
-     */
-    connect(privateKey: string): SignedContract<TAbi>;
+type TypedContract<TAbi extends AbiDefinition> = ContractMethods<TAbi> & {
+  /** The original ABI definition */readonly abi: TAbi; /** Contract name extracted from ABI */
+  readonly contractName: TAbi['contractName'];
+  /**
+   * Bind a signer to produce a `SignedContract` where every method
+   * derives keys, builds, and signs in one step.
+   *
+   * @param privateKey - Base58 encoded private key (seed)
+   */
+  connect(privateKey: string): SignedContract<TAbi>;
 };
 /**
  * A signer-bound contract interface.
@@ -74,11 +44,9 @@ export type TypedContract<TAbi extends AbiDefinition> = ContractMethods<TAbi> &
  * Every ABI function is a method that returns `BuildTransactionResult`
  * (txHash + txPacked ready for submission).
  */
-export type SignedContract<TAbi extends AbiDefinition> = SignedContractMethods<TAbi> & {
-    /** The original ABI definition */
-    readonly abi: TAbi;
-    /** Contract name extracted from ABI */
-    readonly contractName: TAbi['contractName'];
+type SignedContract<TAbi extends AbiDefinition> = SignedContractMethods<TAbi> & {
+  /** The original ABI definition */readonly abi: TAbi; /** Contract name extracted from ABI */
+  readonly contractName: TAbi['contractName'];
 };
 /**
  * Create a typed contract interface from an ABI definition.
@@ -108,6 +76,7 @@ export type SignedContract<TAbi extends AbiDefinition> = SignedContractMethods<T
  * const result = signed.lock({ amount: '100000000000', tier: '30d' })
  * ```
  */
-export declare function createContract<TAbi extends AbiDefinition>(abi: TAbi): TypedContract<TAbi>;
-export {};
+declare function createContract<TAbi extends AbiDefinition>(abi: TAbi): TypedContract<TAbi>;
+//#endregion
+export { SignedContract, TypedContract, createContract };
 //# sourceMappingURL=contract.d.ts.map

package/dist/contracts/contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../src/contracts/contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAEtD,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAKnD;;GAEG;AACH,KAAK,cAAc,CAAC,MAAM,SAAS,SAAS,QAAQ,EAAE,IAAI;IACzD,QAAQ,EAAE,CAAC,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM;CACnD,CAAA;AAED;;;;;GAKG;AACH,KAAK,eAAe,CAAC,IAAI,SAAS,aAAa,IAAI;IAClD,QAAQ,EAAE,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,SAAS,SAAS,EAAE,GAC9E,MAAM,YAAY,GAClB,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,YAAY;CACxD,CAAA;AAED;;GAEG;AACH,KAAK,qBAAqB,CAAC,IAAI,SAAS,aAAa,IAAI;IACxD,QAAQ,EAAE,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,SAAS,SAAS,EAAE,GAC9E,MAAM,sBAAsB,GAC5B,CAAC,MAAM,EAAE,cAAc,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,sBAAsB;CAClE,CAAA;AAID;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,CAAC,IAAI,SAAS,aAAa,IAAI,eAAe,CAAC,IAAI,CAAC,GAAG;IAC/E,kCAAkC;IAClC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAA;IAClB,uCAAuC;IACvC,QAAQ,CAAC,YAAY,EAAE,IAAI,CAAC,cAAc,CAAC,CAAA;IAC3C;;;;;OAKG;IACH,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,cAAc,CAAC,IAAI,CAAC,CAAA;CACjD,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,cAAc,CAAC,IAAI,SAAS,aAAa,IAAI,qBAAqB,CAAC,IAAI,CAAC,GAAG;IACtF,kCAAkC;IAClC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAA;IAClB,uCAAuC;IACvC,QAAQ,CAAC,YAAY,EAAE,IAAI,CAAC,cAAc,CAAC,CAAA;CAC3C,CAAA;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,cAAc,CAAC,IAAI,SAAS,aAAa,EAAE,GAAG,EAAE,IAAI,GAAG,aAAa,CAAC,IAAI,CAAC,CA6CzF"}
+{"version":3,"file":"contract.d.ts","names":[],"sources":["../../src/contracts/contract.ts"],"mappings":";;;;;;;;KAoCK,cAAA,yBAAuC,QAAA,uBAC5B,MAAA,YAAkB,CAAA;;;;;;;KAS7B,eAAA,cAA6B,aAAA,qBAClB,IAAA,mBAAuB,CAAA,WAAY,CAAA,uCACzC,YAAA,IACL,MAAA,EAAQ,cAAA,CAAe,CAAA,gBAAiB,YAAA;;;;KAMxC,qBAAA,cAAmC,aAAA,qBACxB,IAAA,mBAAuB,CAAA,WAAY,CAAA,uCACzC,sBAAA,IACL,MAAA,EAAQ,cAAA,CAAe,CAAA,gBAAiB,sBAAA;;;;;;;;;;KAcjC,aAAA,cAA2B,aAAA,IAAiB,eAAA,CAAgB,IAAA;EAdL,2CAgBzD,GAAA,EAAK,IAAA,EAnByB;EAAA,SAqB9B,YAAA,EAAc,IAAA;EApBR;;;;;;EA2Bf,OAAA,CAAQ,UAAA,WAAqB,cAAA,CAAe,IAAA;AAAA;;;AAX7C;;;;KAoBY,cAAA,cAA4B,aAAA,IAAiB,qBAAA,CAAsB,IAAA;EApBvB,2CAsB9C,GAAA,EAAK,IAAA,EAlBS;EAAA,SAoBd,YAAA,EAAc,IAAA;AAAA;;;;;;;;;;;;;;;;;AAJxB;;;;;;;;;;;;iBAqCgB,cAAA,cAA4B,aAAA,CAAA,CAAe,GAAA,EAAK,IAAA,GAAO,aAAA,CAAc,IAAA"}

package/dist/contracts/contract.js

@@ -1,107 +1,69 @@
+import { signContractCall } from "../signing.js";
+import { buildContractCall } from "./contract-call.js";
+//#region src/contracts/contract.ts
 /**
- * ABI-Driven Contract Factory
- *
- * Generates fully-typed contract interfaces from `as const` ABI definitions,
- * similar to viem's getContract() or ethers typechain.
- *
- * Each function declared in the ABI becomes a typed method on the contract
- * object — with autocomplete for function names and typed params derived
- * from the ABI inputs.
- *
- * @example
- * ```ts
- * import { createContract, LOCKUP_PRIME_ABI, toAtomicAma } from '@amadeus-protocol/sdk'
- *
- * // Unsigned — returns ContractCall for TransactionBuilder.signCall()
- * const lockupPrime = createContract(LOCKUP_PRIME_ABI)
- * const call = lockupPrime.lock({ amount: toAtomicAma(100).toString(), tier: '30d' })
- * const { txHash, txPacked } = TransactionBuilder.signCall(privateKey, call)
- *
- * // Signed — bind a private key, methods return BuildTransactionResult directly
- * const signed = createContract(LOCKUP_PRIME_ABI).connect(privateKey)
- * const result = signed.lock({ amount: toAtomicAma(100).toString(), tier: '30d' })
- * ```
- */
-import { signContractCall } from '../signing';
-import { buildContractCall } from './contract-call';
-// ── Factory functions ───────────────────────────────────────────────
-/**
- * Create a typed contract interface from an ABI definition.
- *
- * Returns an object where each ABI function is a method with fully typed
- * params (derived from ABI inputs) and autocomplete on function names.
- *
- * @param abi - An ABI definition object (must be declared `as const`)
- * @returns A typed `TypedContract<TAbi>` with methods for each ABI function
- *
- * @example
- * ```ts
- * import { createContract, LOCKUP_PRIME_ABI, LOCKUP_ABI, toAtomicAma } from '@amadeus-protocol/sdk'
- *
- * // Each ABI function becomes a typed method:
- * const lockupPrime = createContract(LOCKUP_PRIME_ABI)
- * lockupPrime.lock({ amount: toAtomicAma(100).toString(), tier: '30d' })   // typed
- * lockupPrime.unlock({ vaultIndex: '3' })                                   // typed
- * lockupPrime.daily_checkin({ vaultIndex: '7' })                            // typed
- *
- * // Sign the call:
- * const call = lockupPrime.lock({ amount: '100000000000', tier: '30d' })
- * const { txHash, txPacked } = TransactionBuilder.signCall(privateKey, call)
- *
- * // Or bind a signer:
- * const signed = lockupPrime.connect(privateKey)
- * const result = signed.lock({ amount: '100000000000', tier: '30d' })
- * ```
- */
-export function createContract(abi) {
-    if (!abi || typeof abi !== 'object') {
-        throw new Error('Invalid ABI: expected an object');
-    }
-    if (typeof abi.contractName !== 'string' || !abi.contractName) {
-        throw new Error('Invalid ABI: missing or empty "contractName"');
-    }
-    if (!Array.isArray(abi.abi)) {
-        throw new Error(`Invalid ABI for ${abi.contractName}: "abi" must be an array of functions`);
-    }
-    for (const fn of abi.abi) {
-        if (fn.type !== 'function') {
-            throw new Error(`Invalid ABI for ${abi.contractName}: entry "${fn.name ?? '?'}" has type "${fn.type}", expected "function"`);
-        }
-        if (typeof fn.name !== 'string' || !fn.name) {
-            throw new Error(`Invalid ABI for ${abi.contractName}: function entry missing "name"`);
-        }
-        if (!Array.isArray(fn.inputs)) {
-            throw new Error(`Invalid ABI for ${abi.contractName}: function "${fn.name}" missing "inputs" array`);
-        }
-    }
-    const contract = {
-        abi,
-        contractName: abi.contractName,
-        connect(privateKey) {
-            return createSignedContract(abi, privateKey);
-        }
-    };
-    for (const fn of abi.abi) {
-        contract[fn.name] = (params) => {
-            return buildContractCall(abi, fn.name, (params ?? {}));
-        };
-    }
-    return contract;
+* Create a typed contract interface from an ABI definition.
+*
+* Returns an object where each ABI function is a method with fully typed
+* params (derived from ABI inputs) and autocomplete on function names.
+*
+* @param abi - An ABI definition object (must be declared `as const`)
+* @returns A typed `TypedContract<TAbi>` with methods for each ABI function
+*
+* @example
+* ```ts
+* import { createContract, LOCKUP_PRIME_ABI, LOCKUP_ABI, toAtomicAma } from '@amadeus-protocol/sdk'
+*
+* // Each ABI function becomes a typed method:
+* const lockupPrime = createContract(LOCKUP_PRIME_ABI)
+* lockupPrime.lock({ amount: toAtomicAma(100).toString(), tier: '30d' })   // typed
+* lockupPrime.unlock({ vaultIndex: '3' })                                   // typed
+* lockupPrime.daily_checkin({ vaultIndex: '7' })                            // typed
+*
+* // Sign the call:
+* const call = lockupPrime.lock({ amount: '100000000000', tier: '30d' })
+* const { txHash, txPacked } = TransactionBuilder.signCall(privateKey, call)
+*
+* // Or bind a signer:
+* const signed = lockupPrime.connect(privateKey)
+* const result = signed.lock({ amount: '100000000000', tier: '30d' })
+* ```
+*/
+function createContract(abi) {
+	if (!abi || typeof abi !== "object") throw new Error("Invalid ABI: expected an object");
+	if (typeof abi.contractName !== "string" || !abi.contractName) throw new Error("Invalid ABI: missing or empty \"contractName\"");
+	if (!Array.isArray(abi.abi)) throw new Error(`Invalid ABI for ${abi.contractName}: "abi" must be an array of functions`);
+	for (const fn of abi.abi) {
+		if (fn.type !== "function") throw new Error(`Invalid ABI for ${abi.contractName}: entry "${fn.name ?? "?"}" has type "${fn.type}", expected "function"`);
+		if (typeof fn.name !== "string" || !fn.name) throw new Error(`Invalid ABI for ${abi.contractName}: function entry missing "name"`);
+		if (!Array.isArray(fn.inputs)) throw new Error(`Invalid ABI for ${abi.contractName}: function "${fn.name}" missing "inputs" array`);
+	}
+	const contract = {
+		abi,
+		contractName: abi.contractName,
+		connect(privateKey) {
+			return createSignedContract(abi, privateKey);
+		}
+	};
+	for (const fn of abi.abi) contract[fn.name] = (params) => {
+		return buildContractCall(abi, fn.name, params ?? {});
+	};
+	return contract;
 }
 /**
- * Create a signer-bound contract where each method builds + signs in one step.
- */
+* Create a signer-bound contract where each method builds + signs in one step.
+*/
 function createSignedContract(abi, privateKey) {
-    const contract = {
-        abi,
-        contractName: abi.contractName
-    };
-    for (const fn of abi.abi) {
-        contract[fn.name] = (params) => {
-            const call = buildContractCall(abi, fn.name, (params ?? {}));
-            return signContractCall(privateKey, call);
-        };
-    }
-    return contract;
+	const contract = {
+		abi,
+		contractName: abi.contractName
+	};
+	for (const fn of abi.abi) contract[fn.name] = (params) => {
+		return signContractCall(privateKey, buildContractCall(abi, fn.name, params ?? {}));
+	};
+	return contract;
 }
+//#endregion
+export { createContract };
+
 //# sourceMappingURL=contract.js.map

package/dist/contracts/contract.js.map

@@ -1 +1 @@
-{"version":3,"file":"contract.js","sourceRoot":"","sources":["../../src/contracts/contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAGH,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAG7C,OAAO,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAA;AAsEnD,uEAAuE;AAEvE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,UAAU,cAAc,CAA6B,GAAS;IACnE,IAAI,CAAC,GAAG,IAAI,OAAO,GAAG,KAAK,QAAQ,EAAE,CAAC;QACrC,MAAM,IAAI,KAAK,CAAC,iCAAiC,CAAC,CAAA;IACnD,CAAC;IACD,IAAI,OAAO,GAAG,CAAC,YAAY,KAAK,QAAQ,IAAI,CAAC,GAAG,CAAC,YAAY,EAAE,CAAC;QAC/D,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAA;IAChE,CAAC;IACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,KAAK,CAAC,mBAAmB,GAAG,CAAC,YAAY,uCAAuC,CAAC,CAAA;IAC5F,CAAC;IACD,KAAK,MAAM,EAAE,IAAI,GAAG,CAAC,GAAG,EAAE,CAAC;QAC1B,IAAI,EAAE,CAAC,IAAI,KAAK,UAAU,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CACd,mBAAmB,GAAG,CAAC,YAAY,YAAY,EAAE,CAAC,IAAI,IAAI,GAAG,eAAe,EAAE,CAAC,IAAI,wBAAwB,CAC3G,CAAA;QACF,CAAC;QACD,IAAI,OAAO,EAAE,CAAC,IAAI,KAAK,QAAQ,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC;YAC7C,MAAM,IAAI,KAAK,CAAC,mBAAmB,GAAG,CAAC,YAAY,iCAAiC,CAAC,CAAA;QACtF,CAAC;QACD,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC;YAC/B,MAAM,IAAI,KAAK,CACd,mBAAmB,GAAG,CAAC,YAAY,eAAe,EAAE,CAAC,IAAI,0BAA0B,CACnF,CAAA;QACF,CAAC;IACF,CAAC;IAED,MAAM,QAAQ,GAA4B;QACzC,GAAG;QACH,YAAY,EAAE,GAAG,CAAC,YAAY;QAC9B,OAAO,CAAC,UAAkB;YACzB,OAAO,oBAAoB,CAAC,GAAG,EAAE,UAAU,CAAC,CAAA;QAC7C,CAAC;KACD,CAAA;IAED,KAAK,MAAM,EAAE,IAAI,GAAG,CAAC,GAAG,EAAE,CAAC;QAC1B,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,MAA+B,EAAE,EAAE;YACvD,OAAO,iBAAiB,CACvB,GAAG,EACH,EAAE,CAAC,IAAa,EAChB,CAAC,MAAM,IAAI,EAAE,CAAU,CACvB,CAAA;QACF,CAAC,CAAA;IACF,CAAC;IAED,OAAO,QAA+B,CAAA;AACvC,CAAC;AAED;;GAEG;AACH,SAAS,oBAAoB,CAC5B,GAAS,EACT,UAAkB;IAElB,MAAM,QAAQ,GAA4B;QACzC,GAAG;QACH,YAAY,EAAE,GAAG,CAAC,YAAY;KAC9B,CAAA;IAED,KAAK,MAAM,EAAE,IAAI,GAAG,CAAC,GAAG,EAAE,CAAC;QAC1B,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,MAA+B,EAAE,EAAE;YACvD,MAAM,IAAI,GAAG,iBAAiB,CAC7B,GAAG,EACH,EAAE,CAAC,IAAa,EAChB,CAAC,MAAM,IAAI,EAAE,CAAU,CACvB,CAAA;YACD,OAAO,gBAAgB,CAAC,UAAU,EAAE,IAAI,CAAC,CAAA;QAC1C,CAAC,CAAA;IACF,CAAC;IAED,OAAO,QAAgC,CAAA;AACxC,CAAC"}
+{"version":3,"file":"contract.js","names":[],"sources":["../../src/contracts/contract.ts"],"sourcesContent":["/**\n * ABI-Driven Contract Factory\n *\n * Generates fully-typed contract interfaces from `as const` ABI definitions,\n * similar to viem's getContract() or ethers typechain.\n *\n * Each function declared in the ABI becomes a typed method on the contract\n * object — with autocomplete for function names and typed params derived\n * from the ABI inputs.\n *\n * @example\n * ```ts\n * import { createContract, LOCKUP_PRIME_ABI, toAtomicAma } from '@amadeus-protocol/sdk'\n *\n * // Unsigned — returns ContractCall for TransactionBuilder.signCall()\n * const lockupPrime = createContract(LOCKUP_PRIME_ABI)\n * const call = lockupPrime.lock({ amount: toAtomicAma(100).toString(), tier: '30d' })\n * const { txHash, txPacked } = TransactionBuilder.signCall(privateKey, call)\n *\n * // Signed — bind a private key, methods return BuildTransactionResult directly\n * const signed = createContract(LOCKUP_PRIME_ABI).connect(privateKey)\n * const result = signed.lock({ amount: toAtomicAma(100).toString(), tier: '30d' })\n * ```\n */\n\nimport type { BuildTransactionResult } from '../types'\nimport { signContractCall } from '../signing'\nimport type { AbiDefinition, AbiInput } from './abi-types'\nimport type { ContractCall } from './contract-call'\nimport { buildContractCall } from './contract-call'\n\n// ── Type-level ABI → Method mapping ─────────────────────────────────\n\n/**\n * Map an ABI inputs tuple to a params object: `{ inputName: string }`\n */\ntype InputsToParams<Inputs extends readonly AbiInput[]> = {\n\treadonly [I in Inputs[number] as I['name']]: string\n}\n\n/**\n * For each function in the ABI, generate a typed method signature.\n *\n * - Functions with inputs → `(params: { name: string, ... }) => ContractCall`\n * - Functions without inputs → `() => ContractCall`\n */\ntype ContractMethods<TAbi extends AbiDefinition> = {\n\treadonly [F in TAbi['abi'][number] as F['name']]: F['inputs'] extends readonly []\n\t\t? () => ContractCall\n\t\t: (params: InputsToParams<F['inputs']>) => ContractCall\n}\n\n/**\n * Same as ContractMethods but methods return signed `BuildTransactionResult`.\n */\ntype SignedContractMethods<TAbi extends AbiDefinition> = {\n\treadonly [F in TAbi['abi'][number] as F['name']]: F['inputs'] extends readonly []\n\t\t? () => BuildTransactionResult\n\t\t: (params: InputsToParams<F['inputs']>) => BuildTransactionResult\n}\n\n// ── Public types ────────────────────────────────────────────────────\n\n/**\n * A typed contract interface generated from an ABI definition.\n *\n * Each ABI function is exposed as a method that returns a `ContractCall`\n * (ready for `TransactionBuilder.signCall()`).\n *\n * Call `.connect(privateKey)` to get a `SignedContract` where methods\n * return `BuildTransactionResult` directly.\n */\nexport type TypedContract<TAbi extends AbiDefinition> = ContractMethods<TAbi> & {\n\t/** The original ABI definition */\n\treadonly abi: TAbi\n\t/** Contract name extracted from ABI */\n\treadonly contractName: TAbi['contractName']\n\t/**\n\t * Bind a signer to produce a `SignedContract` where every method\n\t * derives keys, builds, and signs in one step.\n\t *\n\t * @param privateKey - Base58 encoded private key (seed)\n\t */\n\tconnect(privateKey: string): SignedContract<TAbi>\n}\n\n/**\n * A signer-bound contract interface.\n *\n * Every ABI function is a method that returns `BuildTransactionResult`\n * (txHash + txPacked ready for submission).\n */\nexport type SignedContract<TAbi extends AbiDefinition> = SignedContractMethods<TAbi> & {\n\t/** The original ABI definition */\n\treadonly abi: TAbi\n\t/** Contract name extracted from ABI */\n\treadonly contractName: TAbi['contractName']\n}\n\n// ── Factory functions ───────────────────────────────────────────────\n\n/**\n * Create a typed contract interface from an ABI definition.\n *\n * Returns an object where each ABI function is a method with fully typed\n * params (derived from ABI inputs) and autocomplete on function names.\n *\n * @param abi - An ABI definition object (must be declared `as const`)\n * @returns A typed `TypedContract<TAbi>` with methods for each ABI function\n *\n * @example\n * ```ts\n * import { createContract, LOCKUP_PRIME_ABI, LOCKUP_ABI, toAtomicAma } from '@amadeus-protocol/sdk'\n *\n * // Each ABI function becomes a typed method:\n * const lockupPrime = createContract(LOCKUP_PRIME_ABI)\n * lockupPrime.lock({ amount: toAtomicAma(100).toString(), tier: '30d' })   // typed\n * lockupPrime.unlock({ vaultIndex: '3' })                                   // typed\n * lockupPrime.daily_checkin({ vaultIndex: '7' })                            // typed\n *\n * // Sign the call:\n * const call = lockupPrime.lock({ amount: '100000000000', tier: '30d' })\n * const { txHash, txPacked } = TransactionBuilder.signCall(privateKey, call)\n *\n * // Or bind a signer:\n * const signed = lockupPrime.connect(privateKey)\n * const result = signed.lock({ amount: '100000000000', tier: '30d' })\n * ```\n */\nexport function createContract<TAbi extends AbiDefinition>(abi: TAbi): TypedContract<TAbi> {\n\tif (!abi || typeof abi !== 'object') {\n\t\tthrow new Error('Invalid ABI: expected an object')\n\t}\n\tif (typeof abi.contractName !== 'string' || !abi.contractName) {\n\t\tthrow new Error('Invalid ABI: missing or empty \"contractName\"')\n\t}\n\tif (!Array.isArray(abi.abi)) {\n\t\tthrow new Error(`Invalid ABI for ${abi.contractName}: \"abi\" must be an array of functions`)\n\t}\n\tfor (const fn of abi.abi) {\n\t\tif (fn.type !== 'function') {\n\t\t\tthrow new Error(\n\t\t\t\t`Invalid ABI for ${abi.contractName}: entry \"${fn.name ?? '?'}\" has type \"${fn.type}\", expected \"function\"`\n\t\t\t)\n\t\t}\n\t\tif (typeof fn.name !== 'string' || !fn.name) {\n\t\t\tthrow new Error(`Invalid ABI for ${abi.contractName}: function entry missing \"name\"`)\n\t\t}\n\t\tif (!Array.isArray(fn.inputs)) {\n\t\t\tthrow new Error(\n\t\t\t\t`Invalid ABI for ${abi.contractName}: function \"${fn.name}\" missing \"inputs\" array`\n\t\t\t)\n\t\t}\n\t}\n\n\tconst contract: Record<string, unknown> = {\n\t\tabi,\n\t\tcontractName: abi.contractName,\n\t\tconnect(privateKey: string) {\n\t\t\treturn createSignedContract(abi, privateKey)\n\t\t}\n\t}\n\n\tfor (const fn of abi.abi) {\n\t\tcontract[fn.name] = (params?: Record<string, string>) => {\n\t\t\treturn buildContractCall(abi, fn.name as never, (params ?? {}) as never)\n\t\t}\n\t}\n\n\treturn contract as TypedContract<TAbi>\n}\n\n/**\n * Create a signer-bound contract where each method builds + signs in one step.\n */\nfunction createSignedContract<TAbi extends AbiDefinition>(\n\tabi: TAbi,\n\tprivateKey: string\n): SignedContract<TAbi> {\n\tconst contract: Record<string, unknown> = {\n\t\tabi,\n\t\tcontractName: abi.contractName\n\t}\n\n\tfor (const fn of abi.abi) {\n\t\tcontract[fn.name] = (params?: Record<string, string>) => {\n\t\t\tconst call = buildContractCall(abi, fn.name as never, (params ?? {}) as never)\n\t\t\treturn signContractCall(privateKey, call)\n\t\t}\n\t}\n\n\treturn contract as SignedContract<TAbi>\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiIA,SAAgB,eAA2C,KAAgC;CAC1F,IAAI,CAAC,OAAO,OAAO,QAAQ,UAC1B,MAAM,IAAI,MAAM,kCAAkC;CAEnD,IAAI,OAAO,IAAI,iBAAiB,YAAY,CAAC,IAAI,cAChD,MAAM,IAAI,MAAM,iDAA+C;CAEhE,IAAI,CAAC,MAAM,QAAQ,IAAI,IAAI,EAC1B,MAAM,IAAI,MAAM,mBAAmB,IAAI,aAAa,uCAAuC;CAE5F,KAAK,MAAM,MAAM,IAAI,KAAK;EACzB,IAAI,GAAG,SAAS,YACf,MAAM,IAAI,MACT,mBAAmB,IAAI,aAAa,WAAW,GAAG,QAAQ,IAAI,cAAc,GAAG,KAAK,wBACpF;EAEF,IAAI,OAAO,GAAG,SAAS,YAAY,CAAC,GAAG,MACtC,MAAM,IAAI,MAAM,mBAAmB,IAAI,aAAa,iCAAiC;EAEtF,IAAI,CAAC,MAAM,QAAQ,GAAG,OAAO,EAC5B,MAAM,IAAI,MACT,mBAAmB,IAAI,aAAa,cAAc,GAAG,KAAK,0BAC1D;;CAIH,MAAM,WAAoC;EACzC;EACA,cAAc,IAAI;EAClB,QAAQ,YAAoB;GAC3B,OAAO,qBAAqB,KAAK,WAAW;;EAE7C;CAED,KAAK,MAAM,MAAM,IAAI,KACpB,SAAS,GAAG,SAAS,WAAoC;EACxD,OAAO,kBAAkB,KAAK,GAAG,MAAgB,UAAU,EAAE,CAAW;;CAI1E,OAAO;;;;;AAMR,SAAS,qBACR,KACA,YACuB;CACvB,MAAM,WAAoC;EACzC;EACA,cAAc,IAAI;EAClB;CAED,KAAK,MAAM,MAAM,IAAI,KACpB,SAAS,GAAG,SAAS,WAAoC;EAExD,OAAO,iBAAiB,YADX,kBAAkB,KAAK,GAAG,MAAgB,UAAU,EAAE,CAC3B,CAAC;;CAI3C,OAAO"}