@amadeus-protocol/sdk 1.0.8 → 1.1.1

package/dist/contracts/coin.d.ts

@@ -1,25 +1,16 @@
-/**
- * Coin Contract (Special Case)
- *
- * The Coin contract is a built-in native contract with no WASM ABI file.
- * It differs from WASM contracts:
- * - First arg (recipient) is raw binary Uint8Array from fromBase58(), not a UTF-8 string
- * - Amount requires toAtomicAma() conversion
- *
- * This module provides a dedicated builder that handles these special encodings
- * while returning a standard ContractCall for uniform consumption by TransactionBuilder.
- */
-import type { ContractCall } from './contract-call';
+import { ContractCall } from "./contract-call.js";
+
+//#region src/contracts/coin.d.ts
 /**
  * Parameters for building a Coin transfer call
  */
-export interface CoinTransferParams {
-    /** Base58-encoded recipient address */
-    recipient: string;
-    /** Amount in human-readable units (e.g. 10.5 AMA) */
-    amount: number | string;
-    /** Token symbol (e.g. 'AMA') */
-    symbol: string;
+interface CoinTransferParams {
+  /** Base58-encoded recipient address */
+  recipient: string;
+  /** Amount in human-readable units (e.g. 10.5 AMA) */
+  amount: number | string;
+  /** Token symbol (e.g. 'AMA') */
+  symbol: string;
 }
 /**
  * Build a Coin transfer ContractCall.
@@ -38,5 +29,7 @@ export interface CoinTransferParams {
  * TransactionBuilder.signCall(privateKey, call)
  * ```
  */
-export declare function buildCoinTransfer(params: CoinTransferParams): ContractCall;
+declare function buildCoinTransfer(params: CoinTransferParams): ContractCall;
+//#endregion
+export { CoinTransferParams, buildCoinTransfer };
 //# sourceMappingURL=coin.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"coin.d.ts","sourceRoot":"","sources":["../../src/contracts/coin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAIH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAEnD;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAA;IACjB,qDAAqD;IACrD,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;IACvB,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAA;CACd;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,kBAAkB,GAAG,YAAY,CAU1E"}
+{"version":3,"file":"coin.d.ts","names":[],"sources":["../../src/contracts/coin.ts"],"mappings":";;;AA6CA;;;AAAA,UA1BiB,kBAAA;EA0ByB;EAxBzC,SAAA;EAwB8D;EAtB9D,MAAA;EAsB0E;EApB1E,MAAA;AAAA;;;;;;;;;;;;;;;;;;iBAoBe,iBAAA,CAAkB,MAAA,EAAQ,kBAAA,GAAqB,YAAA"}

package/dist/contracts/coin.js

@@ -1,42 +1,46 @@
+import { fromBase58 } from "../encoding.js";
+import { toAtomicAma } from "../conversion.js";
+//#region src/contracts/coin.ts
 /**
- * Coin Contract (Special Case)
- *
- * The Coin contract is a built-in native contract with no WASM ABI file.
- * It differs from WASM contracts:
- * - First arg (recipient) is raw binary Uint8Array from fromBase58(), not a UTF-8 string
- * - Amount requires toAtomicAma() conversion
- *
- * This module provides a dedicated builder that handles these special encodings
- * while returning a standard ContractCall for uniform consumption by TransactionBuilder.
- */
-import { toAtomicAma } from '../conversion';
-import { fromBase58 } from '../encoding';
+* Coin Contract (Special Case)
+*
+* The Coin contract is a built-in native contract with no WASM ABI file.
+* It differs from WASM contracts:
+* - First arg (recipient) is raw binary Uint8Array from fromBase58(), not a UTF-8 string
+* - Amount requires toAtomicAma() conversion
+*
+* This module provides a dedicated builder that handles these special encodings
+* while returning a standard ContractCall for uniform consumption by TransactionBuilder.
+*/
 /**
- * Build a Coin transfer ContractCall.
- *
- * Handles the special encoding requirements of the Coin contract:
- * - recipient is decoded from Base58 to raw Uint8Array
- * - amount is converted to atomic units via toAtomicAma()
- *
- * @example
- * ```ts
- * const call = buildCoinTransfer({
- *   recipient: '5Kd3N...',
- *   amount: 10.5,
- *   symbol: 'AMA'
- * })
- * TransactionBuilder.signCall(privateKey, call)
- * ```
- */
-export function buildCoinTransfer(params) {
-    return {
-        contract: 'Coin',
-        method: 'transfer',
-        args: [
-            fromBase58(params.recipient),
-            toAtomicAma(params.amount).toString(),
-            params.symbol
-        ]
-    };
+* Build a Coin transfer ContractCall.
+*
+* Handles the special encoding requirements of the Coin contract:
+* - recipient is decoded from Base58 to raw Uint8Array
+* - amount is converted to atomic units via toAtomicAma()
+*
+* @example
+* ```ts
+* const call = buildCoinTransfer({
+*   recipient: '5Kd3N...',
+*   amount: 10.5,
+*   symbol: 'AMA'
+* })
+* TransactionBuilder.signCall(privateKey, call)
+* ```
+*/
+function buildCoinTransfer(params) {
+	return {
+		contract: "Coin",
+		method: "transfer",
+		args: [
+			fromBase58(params.recipient),
+			toAtomicAma(params.amount).toString(),
+			params.symbol
+		]
+	};
 }
+//#endregion
+export { buildCoinTransfer };
+
 //# sourceMappingURL=coin.js.map

package/dist/contracts/coin.js.map

@@ -1 +1 @@
-{"version":3,"file":"coin.js","sourceRoot":"","sources":["../../src/contracts/coin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAexC;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAA0B;IAC3D,OAAO;QACN,QAAQ,EAAE,MAAM;QAChB,MAAM,EAAE,UAAU;QAClB,IAAI,EAAE;YACL,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC;YAC5B,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE;YACrC,MAAM,CAAC,MAAM;SACb;KACD,CAAA;AACF,CAAC"}
+{"version":3,"file":"coin.js","names":[],"sources":["../../src/contracts/coin.ts"],"sourcesContent":["/**\n * Coin Contract (Special Case)\n *\n * The Coin contract is a built-in native contract with no WASM ABI file.\n * It differs from WASM contracts:\n * - First arg (recipient) is raw binary Uint8Array from fromBase58(), not a UTF-8 string\n * - Amount requires toAtomicAma() conversion\n *\n * This module provides a dedicated builder that handles these special encodings\n * while returning a standard ContractCall for uniform consumption by TransactionBuilder.\n */\n\nimport { toAtomicAma } from '../conversion'\nimport { fromBase58 } from '../encoding'\nimport type { ContractCall } from './contract-call'\n\n/**\n * Parameters for building a Coin transfer call\n */\nexport interface CoinTransferParams {\n\t/** Base58-encoded recipient address */\n\trecipient: string\n\t/** Amount in human-readable units (e.g. 10.5 AMA) */\n\tamount: number | string\n\t/** Token symbol (e.g. 'AMA') */\n\tsymbol: string\n}\n\n/**\n * Build a Coin transfer ContractCall.\n *\n * Handles the special encoding requirements of the Coin contract:\n * - recipient is decoded from Base58 to raw Uint8Array\n * - amount is converted to atomic units via toAtomicAma()\n *\n * @example\n * ```ts\n * const call = buildCoinTransfer({\n *   recipient: '5Kd3N...',\n *   amount: 10.5,\n *   symbol: 'AMA'\n * })\n * TransactionBuilder.signCall(privateKey, call)\n * ```\n */\nexport function buildCoinTransfer(params: CoinTransferParams): ContractCall {\n\treturn {\n\t\tcontract: 'Coin',\n\t\tmethod: 'transfer',\n\t\targs: [fromBase58(params.recipient), toAtomicAma(params.amount).toString(), params.symbol]\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6CA,SAAgB,kBAAkB,QAA0C;CAC3E,OAAO;EACN,UAAU;EACV,QAAQ;EACR,MAAM;GAAC,WAAW,OAAO,UAAU;GAAE,YAAY,OAAO,OAAO,CAAC,UAAU;GAAE,OAAO;GAAO;EAC1F"}

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