@amadeus-protocol/sdk 1.0.8 → 1.1.0

package/dist/constants.js

@@ -1,46 +1,50 @@
-/**
- * Amadeus Protocol Constants
- *
- * This module contains all protocol-level constants used throughout the SDK.
- */
-/**
- * SDK version
- */
-export const SDK_VERSION = '1.0.0';
-/**
- * Byte length of an Amadeus public key (BLS12-381 public key)
- */
-export const AMADEUS_PUBLIC_KEY_BYTE_LENGTH = 48;
-/**
- * Byte length of an Amadeus seed (private key seed)
- */
-export const AMADEUS_SEED_BYTE_LENGTH = 64;
-/**
- * Number of decimal places for AMA token
- */
-export const AMA_TOKEN_DECIMALS = 9;
-/**
- * Multiplier for converting between atomic units and AMA tokens
- */
-export const AMA_TOKEN_DECIMALS_MULTIPLIER = 10 ** AMA_TOKEN_DECIMALS;
-/**
- * Minimum transferable amount in AMA (1 atomic unit)
- */
-export const MIN_TRANSFERABLE_AMOUNT = 1 / AMA_TOKEN_DECIMALS_MULTIPLIER;
-/**
- * Flat network transfer fee in AMA for standard transfers
- */
-export const AMA_TRANSFER_FEE = 0.02;
-/**
- * Default explorer URL
- */
-export const EXPLORER_URL = 'https://explorer.ama.one';
-/**
- * Default node API URL
- */
-export const NODE_API_URL = 'https://mainnet-rpc.ama.one/api';
-/**
- * Default request timeout in milliseconds
- */
-export const DEFAULT_TIMEOUT = 30000;
+//#region src/constants.ts
+/**
+* Amadeus Protocol Constants
+*
+* This module contains all protocol-level constants used throughout the SDK.
+*/
+/**
+* SDK version
+*/
+const SDK_VERSION = "1.0.0";
+/**
+* Byte length of an Amadeus public key (BLS12-381 public key)
+*/
+const AMADEUS_PUBLIC_KEY_BYTE_LENGTH = 48;
+/**
+* Byte length of an Amadeus seed (private key seed)
+*/
+const AMADEUS_SEED_BYTE_LENGTH = 64;
+/**
+* Number of decimal places for AMA token
+*/
+const AMA_TOKEN_DECIMALS = 9;
+/**
+* Multiplier for converting between atomic units and AMA tokens
+*/
+const AMA_TOKEN_DECIMALS_MULTIPLIER = 10 ** 9;
+/**
+* Minimum transferable amount in AMA (1 atomic unit)
+*/
+const MIN_TRANSFERABLE_AMOUNT = 1 / AMA_TOKEN_DECIMALS_MULTIPLIER;
+/**
+* Flat network transfer fee in AMA for standard transfers
+*/
+const AMA_TRANSFER_FEE = .02;
+/**
+* Default explorer URL
+*/
+const EXPLORER_URL = "https://explorer.ama.one";
+/**
+* Default node API URL
+*/
+const NODE_API_URL = "https://mainnet-rpc.ama.one/api";
+/**
+* Default request timeout in milliseconds
+*/
+const DEFAULT_TIMEOUT = 3e4;
+//#endregion
+export { AMADEUS_PUBLIC_KEY_BYTE_LENGTH, AMADEUS_SEED_BYTE_LENGTH, AMA_TOKEN_DECIMALS, AMA_TOKEN_DECIMALS_MULTIPLIER, AMA_TRANSFER_FEE, DEFAULT_TIMEOUT, EXPLORER_URL, MIN_TRANSFERABLE_AMOUNT, NODE_API_URL, SDK_VERSION };
+
 //# sourceMappingURL=constants.js.map

package/dist/constants.js.map

@@ -1 +1 @@
-{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,OAAO,CAAA;AAElC;;GAEG;AACH,MAAM,CAAC,MAAM,8BAA8B,GAAG,EAAE,CAAA;AAEhD;;GAEG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,EAAE,CAAA;AAE1C;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAA;AAEnC;;GAEG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,EAAE,IAAI,kBAAkB,CAAA;AAErE;;GAEG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG,CAAC,GAAG,6BAA6B,CAAA;AAExE;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,IAAI,CAAA;AAEpC;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,0BAA0B,CAAA;AAEtD;;GAEG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,iCAAiC,CAAA;AAE7D;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,KAAK,CAAA"}
+{"version":3,"file":"constants.js","names":[],"sources":["../src/constants.ts"],"sourcesContent":["/**\n * Amadeus Protocol Constants\n *\n * This module contains all protocol-level constants used throughout the SDK.\n */\n\n/**\n * SDK version\n */\nexport const SDK_VERSION = '1.0.0'\n\n/**\n * Byte length of an Amadeus public key (BLS12-381 public key)\n */\nexport const AMADEUS_PUBLIC_KEY_BYTE_LENGTH = 48\n\n/**\n * Byte length of an Amadeus seed (private key seed)\n */\nexport const AMADEUS_SEED_BYTE_LENGTH = 64\n\n/**\n * Number of decimal places for AMA token\n */\nexport const AMA_TOKEN_DECIMALS = 9\n\n/**\n * Multiplier for converting between atomic units and AMA tokens\n */\nexport const AMA_TOKEN_DECIMALS_MULTIPLIER = 10 ** AMA_TOKEN_DECIMALS\n\n/**\n * Minimum transferable amount in AMA (1 atomic unit)\n */\nexport const MIN_TRANSFERABLE_AMOUNT = 1 / AMA_TOKEN_DECIMALS_MULTIPLIER\n\n/**\n * Flat network transfer fee in AMA for standard transfers\n */\nexport const AMA_TRANSFER_FEE = 0.02\n\n/**\n * Default explorer URL\n */\nexport const EXPLORER_URL = 'https://explorer.ama.one'\n\n/**\n * Default node API URL\n */\nexport const NODE_API_URL = 'https://mainnet-rpc.ama.one/api'\n\n/**\n * Default request timeout in milliseconds\n */\nexport const DEFAULT_TIMEOUT = 30000\n"],"mappings":";;;;;;;;;AASA,MAAa,cAAc;;;;AAK3B,MAAa,iCAAiC;;;;AAK9C,MAAa,2BAA2B;;;;AAKxC,MAAa,qBAAqB;;;;AAKlC,MAAa,gCAAgC,MAAA;;;;AAK7C,MAAa,0BAA0B,IAAI;;;;AAK3C,MAAa,mBAAmB;;;;AAKhC,MAAa,eAAe;;;;AAK5B,MAAa,eAAe;;;;AAK5B,MAAa,kBAAkB"}

package/dist/contract-state.d.ts

@@ -1,3 +1,4 @@
+//#region src/contract-state.d.ts
 /**
  * Contract State Utilities
  *
@@ -21,7 +22,7 @@
  * // entries: [["base64key", "base64value"], ...]
  * ```
  */
-export declare function decodeContractStateToBase64(bytes: Uint8Array | ArrayBuffer): Array<[string, string]>;
+declare function decodeContractStateToBase64(bytes: Uint8Array | ArrayBuffer): Array<[string, string]>;
 /**
  * Parse a contract state value as a number.
  *
@@ -42,7 +43,7 @@ export declare function decodeContractStateToBase64(bytes: Uint8Array | ArrayBuf
  * parseStateNumber(null)                             // 0
  * ```
  */
-export declare function parseStateNumber(value: string | number | Uint8Array | null | undefined): number;
+declare function parseStateNumber(value: string | number | Uint8Array | null | undefined): number;
 /**
  * Parse a contract state value as a string.
  *
@@ -55,5 +56,7 @@ export declare function parseStateNumber(value: string | number | Uint8Array | n
  * @param value - Raw contract state value
  * @returns Parsed string or null
  */
-export declare function parseStateString(value: string | number | Uint8Array | null | undefined): string | null;
+declare function parseStateString(value: string | number | Uint8Array | null | undefined): string | null;
+//#endregion
+export { decodeContractStateToBase64, parseStateNumber, parseStateString };
 //# sourceMappingURL=contract-state.d.ts.map

package/dist/contract-state.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contract-state.d.ts","sourceRoot":"","sources":["../src/contract-state.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,2BAA2B,CAC1C,KAAK,EAAE,UAAU,GAAG,WAAW,GAC7B,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAKzB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,gBAAgB,CAC/B,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,IAAI,GAAG,SAAS,GACpD,MAAM,CAWR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,gBAAgB,CAC/B,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,IAAI,GAAG,SAAS,GACpD,MAAM,GAAG,IAAI,CAQf"}
+{"version":3,"file":"contract-state.d.ts","names":[],"sources":["../src/contract-state.ts"],"mappings":";;AA2BA;;;;;;;;;;;;;;AA6BA;;;;;AAyBA;;;iBAtDgB,2BAAA,CACf,KAAA,EAAO,UAAA,GAAa,WAAA,GAClB,KAAA;;;;;;;;;;;;;;;;;;;;;iBA2Ba,gBAAA,CAAiB,KAAA,oBAAyB,UAAA;;;;;;;;;;;;;iBAyB1C,gBAAA,CACf,KAAA,oBAAyB,UAAA"}

package/dist/contract-state.js

@@ -1,117 +1,99 @@
+import { decodeContractState } from "./serialization.js";
+import { uint8ArrayToBase64 } from "./encoding.js";
+//#region src/contract-state.ts
 /**
- * Contract State Utilities
- *
- * Provides functions for parsing contract state values returned by the Amadeus chain.
- * Contract state values are stored as binary (Uint8Array) and need to be decoded
- * into usable types (numbers, strings, etc.).
- */
-import { uint8ArrayToBase64 } from './encoding';
-import { decodeContractState } from './serialization';
+* Contract State Utilities
+*
+* Provides functions for parsing contract state values returned by the Amadeus chain.
+* Contract state values are stored as binary (Uint8Array) and need to be decoded
+* into usable types (numbers, strings, etc.).
+*/
 /**
- * Decode VecPack-encoded contract state and convert keys/values to Base64 strings.
- *
- * Useful for serializing decoded contract state for Redux or other stores
- * that require JSON-serializable values.
- *
- * @param bytes - VecPack-encoded bytes (Uint8Array or ArrayBuffer)
- * @returns Array of [key, value] tuples as Base64 strings
- *
- * @example
- * ```ts
- * const buffer = await response.arrayBuffer()
- * const entries = decodeContractStateToBase64(buffer)
- * // entries: [["base64key", "base64value"], ...]
- * ```
- */
-export function decodeContractStateToBase64(bytes) {
-    const pairs = decodeContractState(bytes);
-    return pairs
-        .filter(([key, value]) => key.length > 0 && value.length > 0)
-        .map(([key, value]) => [uint8ArrayToBase64(key), uint8ArrayToBase64(value)]);
+* Decode VecPack-encoded contract state and convert keys/values to Base64 strings.
+*
+* Useful for serializing decoded contract state for Redux or other stores
+* that require JSON-serializable values.
+*
+* @param bytes - VecPack-encoded bytes (Uint8Array or ArrayBuffer)
+* @returns Array of [key, value] tuples as Base64 strings
+*
+* @example
+* ```ts
+* const buffer = await response.arrayBuffer()
+* const entries = decodeContractStateToBase64(buffer)
+* // entries: [["base64key", "base64value"], ...]
+* ```
+*/
+function decodeContractStateToBase64(bytes) {
+	return decodeContractState(bytes).filter(([key, value]) => key.length > 0 && value.length > 0).map(([key, value]) => [uint8ArrayToBase64(key), uint8ArrayToBase64(value)]);
 }
 /**
- * Parse a contract state value as a number.
- *
- * Handles multiple input types:
- * - `number` — returned directly
- * - `string` — parsed as integer
- * - `Uint8Array` — first tries UTF-8 digit string, then little-endian binary
- * - `null`/`undefined` — returns 0
- *
- * @param value - Raw contract state value
- * @returns Parsed number (0 if unparseable)
- *
- * @example
- * ```ts
- * parseStateNumber(new TextEncoder().encode('42'))  // 42
- * parseStateNumber(new Uint8Array([0x2a, 0x00]))    // 42 (little-endian)
- * parseStateNumber('100')                            // 100
- * parseStateNumber(null)                             // 0
- * ```
- */
-export function parseStateNumber(value) {
-    if (value === null || value === undefined)
-        return 0;
-    if (typeof value === 'number')
-        return Number.isInteger(value) && value >= 0 ? value : 0;
-    if (typeof value === 'string') {
-        const parsed = parseInt(value, 10);
-        return isNaN(parsed) || parsed < 0 ? 0 : parsed;
-    }
-    if (value instanceof Uint8Array) {
-        return decodeUint8ArrayAsNumber(value);
-    }
-    return 0;
+* Parse a contract state value as a number.
+*
+* Handles multiple input types:
+* - `number` — returned directly
+* - `string` — parsed as integer
+* - `Uint8Array` — first tries UTF-8 digit string, then little-endian binary
+* - `null`/`undefined` — returns 0
+*
+* @param value - Raw contract state value
+* @returns Parsed number (0 if unparseable)
+*
+* @example
+* ```ts
+* parseStateNumber(new TextEncoder().encode('42'))  // 42
+* parseStateNumber(new Uint8Array([0x2a, 0x00]))    // 42 (little-endian)
+* parseStateNumber('100')                            // 100
+* parseStateNumber(null)                             // 0
+* ```
+*/
+function parseStateNumber(value) {
+	if (value === null || value === void 0) return 0;
+	if (typeof value === "number") return Number.isInteger(value) && value >= 0 ? value : 0;
+	if (typeof value === "string") {
+		const parsed = parseInt(value, 10);
+		return isNaN(parsed) || parsed < 0 ? 0 : parsed;
+	}
+	if (value instanceof Uint8Array) return decodeUint8ArrayAsNumber(value);
+	return 0;
 }
 /**
- * Parse a contract state value as a string.
- *
- * Handles multiple input types:
- * - `string` — returned directly
- * - `number` — converted to string
- * - `Uint8Array` — decoded as UTF-8
- * - `null`/`undefined` — returns null
- *
- * @param value - Raw contract state value
- * @returns Parsed string or null
- */
-export function parseStateString(value) {
-    if (value === null || value === undefined)
-        return null;
-    if (typeof value === 'string')
-        return value;
-    if (typeof value === 'number')
-        return value.toString();
-    if (value instanceof Uint8Array) {
-        return new TextDecoder().decode(value);
-    }
-    return null;
+* Parse a contract state value as a string.
+*
+* Handles multiple input types:
+* - `string` — returned directly
+* - `number` — converted to string
+* - `Uint8Array` — decoded as UTF-8
+* - `null`/`undefined` — returns null
+*
+* @param value - Raw contract state value
+* @returns Parsed string or null
+*/
+function parseStateString(value) {
+	if (value === null || value === void 0) return null;
+	if (typeof value === "string") return value;
+	if (typeof value === "number") return value.toString();
+	if (value instanceof Uint8Array) return new TextDecoder().decode(value);
+	return null;
 }
 /**
- * Decode a Uint8Array contract state value as a number.
- * Tries UTF-8 digit string first, falls back to little-endian binary.
- */
+* Decode a Uint8Array contract state value as a number.
+* Tries UTF-8 digit string first, falls back to little-endian binary.
+*/
 function decodeUint8ArrayAsNumber(value) {
-    if (!value.length)
-        return 0;
-    // First try to interpret as UTF-8 digits
-    try {
-        const str = new TextDecoder().decode(value);
-        const parsed = parseInt(str, 10);
-        if (!isNaN(parsed)) {
-            return parsed;
-        }
-    }
-    catch {
-        // Fallthrough to binary parsing
-    }
-    // Fallback: parse as little-endian integer (u32/u64)
-    let result = 0n;
-    const bytesToRead = Math.min(value.length, 8);
-    for (let i = 0; i < bytesToRead; i++) {
-        result |= BigInt(value[i]) << BigInt(i * 8);
-    }
-    const asNumber = Number(result);
-    return Number.isSafeInteger(asNumber) ? asNumber : 0;
+	if (!value.length) return 0;
+	try {
+		const str = new TextDecoder().decode(value);
+		const parsed = parseInt(str, 10);
+		if (!isNaN(parsed)) return parsed;
+	} catch {}
+	let result = 0n;
+	const bytesToRead = Math.min(value.length, 8);
+	for (let i = 0; i < bytesToRead; i++) result |= BigInt(value[i]) << BigInt(i * 8);
+	const asNumber = Number(result);
+	return Number.isSafeInteger(asNumber) ? asNumber : 0;
 }
+//#endregion
+export { decodeContractStateToBase64, parseStateNumber, parseStateString };
+
 //# sourceMappingURL=contract-state.js.map

package/dist/contract-state.js.map

@@ -1 +1 @@
-{"version":3,"file":"contract-state.js","sourceRoot":"","sources":["../src/contract-state.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"contract-state.js","names":[],"sources":["../src/contract-state.ts"],"sourcesContent":["/**\n * Contract State Utilities\n *\n * Provides functions for parsing contract state values returned by the Amadeus chain.\n * Contract state values are stored as binary (Uint8Array) and need to be decoded\n * into usable types (numbers, strings, etc.).\n */\n\nimport { uint8ArrayToBase64 } from './encoding'\nimport { decodeContractState } from './serialization'\n\n/**\n * Decode VecPack-encoded contract state and convert keys/values to Base64 strings.\n *\n * Useful for serializing decoded contract state for Redux or other stores\n * that require JSON-serializable values.\n *\n * @param bytes - VecPack-encoded bytes (Uint8Array or ArrayBuffer)\n * @returns Array of [key, value] tuples as Base64 strings\n *\n * @example\n * ```ts\n * const buffer = await response.arrayBuffer()\n * const entries = decodeContractStateToBase64(buffer)\n * // entries: [[\"base64key\", \"base64value\"], ...]\n * ```\n */\nexport function decodeContractStateToBase64(\n\tbytes: Uint8Array | ArrayBuffer\n): Array<[string, string]> {\n\tconst pairs = decodeContractState(bytes)\n\treturn pairs\n\t\t.filter(([key, value]) => key.length > 0 && value.length > 0)\n\t\t.map(([key, value]) => [uint8ArrayToBase64(key), uint8ArrayToBase64(value)])\n}\n\n/**\n * Parse a contract state value as a number.\n *\n * Handles multiple input types:\n * - `number` — returned directly\n * - `string` — parsed as integer\n * - `Uint8Array` — first tries UTF-8 digit string, then little-endian binary\n * - `null`/`undefined` — returns 0\n *\n * @param value - Raw contract state value\n * @returns Parsed number (0 if unparseable)\n *\n * @example\n * ```ts\n * parseStateNumber(new TextEncoder().encode('42'))  // 42\n * parseStateNumber(new Uint8Array([0x2a, 0x00]))    // 42 (little-endian)\n * parseStateNumber('100')                            // 100\n * parseStateNumber(null)                             // 0\n * ```\n */\nexport function parseStateNumber(value: string | number | Uint8Array | null | undefined): number {\n\tif (value === null || value === undefined) return 0\n\tif (typeof value === 'number') return Number.isInteger(value) && value >= 0 ? value : 0\n\tif (typeof value === 'string') {\n\t\tconst parsed = parseInt(value, 10)\n\t\treturn isNaN(parsed) || parsed < 0 ? 0 : parsed\n\t}\n\tif (value instanceof Uint8Array) {\n\t\treturn decodeUint8ArrayAsNumber(value)\n\t}\n\treturn 0\n}\n\n/**\n * Parse a contract state value as a string.\n *\n * Handles multiple input types:\n * - `string` — returned directly\n * - `number` — converted to string\n * - `Uint8Array` — decoded as UTF-8\n * - `null`/`undefined` — returns null\n *\n * @param value - Raw contract state value\n * @returns Parsed string or null\n */\nexport function parseStateString(\n\tvalue: string | number | Uint8Array | null | undefined\n): string | null {\n\tif (value === null || value === undefined) return null\n\tif (typeof value === 'string') return value\n\tif (typeof value === 'number') return value.toString()\n\tif (value instanceof Uint8Array) {\n\t\treturn new TextDecoder().decode(value)\n\t}\n\treturn null\n}\n\n/**\n * Decode a Uint8Array contract state value as a number.\n * Tries UTF-8 digit string first, falls back to little-endian binary.\n */\nfunction decodeUint8ArrayAsNumber(value: Uint8Array): number {\n\tif (!value.length) return 0\n\n\t// First try to interpret as UTF-8 digits\n\ttry {\n\t\tconst str = new TextDecoder().decode(value)\n\t\tconst parsed = parseInt(str, 10)\n\t\tif (!isNaN(parsed)) {\n\t\t\treturn parsed\n\t\t}\n\t} catch {\n\t\t// Fallthrough to binary parsing\n\t}\n\n\t// Fallback: parse as little-endian integer (u32/u64)\n\tlet result = 0n\n\tconst bytesToRead = Math.min(value.length, 8)\n\tfor (let i = 0; i < bytesToRead; i++) {\n\t\tresult |= BigInt(value[i]!) << BigInt(i * 8)\n\t}\n\n\tconst asNumber = Number(result)\n\treturn Number.isSafeInteger(asNumber) ? asNumber : 0\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA2BA,SAAgB,4BACf,OAC0B;CAE1B,OADc,oBAAoB,MACtB,CACV,QAAQ,CAAC,KAAK,WAAW,IAAI,SAAS,KAAK,MAAM,SAAS,EAAE,CAC5D,KAAK,CAAC,KAAK,WAAW,CAAC,mBAAmB,IAAI,EAAE,mBAAmB,MAAM,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;AAuB9E,SAAgB,iBAAiB,OAAgE;CAChG,IAAI,UAAU,QAAQ,UAAU,KAAA,GAAW,OAAO;CAClD,IAAI,OAAO,UAAU,UAAU,OAAO,OAAO,UAAU,MAAM,IAAI,SAAS,IAAI,QAAQ;CACtF,IAAI,OAAO,UAAU,UAAU;EAC9B,MAAM,SAAS,SAAS,OAAO,GAAG;EAClC,OAAO,MAAM,OAAO,IAAI,SAAS,IAAI,IAAI;;CAE1C,IAAI,iBAAiB,YACpB,OAAO,yBAAyB,MAAM;CAEvC,OAAO;;;;;;;;;;;;;;AAeR,SAAgB,iBACf,OACgB;CAChB,IAAI,UAAU,QAAQ,UAAU,KAAA,GAAW,OAAO;CAClD,IAAI,OAAO,UAAU,UAAU,OAAO;CACtC,IAAI,OAAO,UAAU,UAAU,OAAO,MAAM,UAAU;CACtD,IAAI,iBAAiB,YACpB,OAAO,IAAI,aAAa,CAAC,OAAO,MAAM;CAEvC,OAAO;;;;;;AAOR,SAAS,yBAAyB,OAA2B;CAC5D,IAAI,CAAC,MAAM,QAAQ,OAAO;CAG1B,IAAI;EACH,MAAM,MAAM,IAAI,aAAa,CAAC,OAAO,MAAM;EAC3C,MAAM,SAAS,SAAS,KAAK,GAAG;EAChC,IAAI,CAAC,MAAM,OAAO,EACjB,OAAO;SAED;CAKR,IAAI,SAAS;CACb,MAAM,cAAc,KAAK,IAAI,MAAM,QAAQ,EAAE;CAC7C,KAAK,IAAI,IAAI,GAAG,IAAI,aAAa,KAChC,UAAU,OAAO,MAAM,GAAI,IAAI,OAAO,IAAI,EAAE;CAG7C,MAAM,WAAW,OAAO,OAAO;CAC/B,OAAO,OAAO,cAAc,SAAS,GAAG,WAAW"}

package/dist/contracts/abi-types.d.ts

@@ -1,3 +1,4 @@
+//#region src/contracts/abi-types.d.ts
 /**
  * Generic ABI Type Extractors
  *
@@ -7,39 +8,39 @@
 /**
  * Shape of an ABI function input
  */
-export interface AbiInput {
-    readonly name: string;
-    readonly type: string;
-    readonly description?: string;
-    readonly validation?: {
-        readonly min?: string;
-        readonly max?: string;
-        readonly type?: string;
-    };
-    readonly enum?: readonly string[];
+interface AbiInput {
+  readonly name: string;
+  readonly type: string;
+  readonly description?: string;
+  readonly validation?: {
+    readonly min?: string;
+    readonly max?: string;
+    readonly type?: string;
+  };
+  readonly enum?: readonly string[];
 }
 /**
  * Shape of an ABI function entry
  */
-export interface AbiFunction {
-    readonly type: 'function';
-    readonly name: string;
-    readonly inputs: readonly AbiInput[];
-    readonly outputs: readonly unknown[];
-    readonly stateMutability: string;
-    readonly description?: string;
-    readonly requirements?: readonly string[];
-    readonly storage?: unknown;
+interface AbiFunction {
+  readonly type: 'function';
+  readonly name: string;
+  readonly inputs: readonly AbiInput[];
+  readonly outputs: readonly unknown[];
+  readonly stateMutability: string;
+  readonly description?: string;
+  readonly requirements?: readonly string[];
+  readonly storage?: unknown;
 }
 /**
  * Shape of any ABI definition (contractName, abi[], errors[], storage)
  */
-export interface AbiDefinition {
-    readonly contractName: string;
-    readonly contractVersion?: string;
-    readonly abi: readonly AbiFunction[];
-    readonly errors?: readonly unknown[];
-    readonly storage?: unknown;
+interface AbiDefinition {
+  readonly contractName: string;
+  readonly contractVersion?: string;
+  readonly abi: readonly AbiFunction[];
+  readonly errors?: readonly unknown[];
+  readonly storage?: unknown;
 }
 /**
  * Extract the literal contract name from an ABI definition
@@ -50,7 +51,7 @@ export interface AbiDefinition {
  * // => 'LockupPrime'
  * ```
  */
-export type ExtractContractName<T extends AbiDefinition> = T['contractName'];
+type ExtractContractName<T extends AbiDefinition> = T['contractName'];
 /**
  * Extract a union of all function names from an ABI definition
  *
@@ -60,12 +61,12 @@ export type ExtractContractName<T extends AbiDefinition> = T['contractName'];
  * // => 'lock' | 'unlock' | 'daily_checkin'
  * ```
  */
-export type ExtractFunctionNames<T extends AbiDefinition> = T['abi'][number]['name'];
+type ExtractFunctionNames<T extends AbiDefinition> = T['abi'][number]['name'];
 /**
  * Find a specific function entry in the ABI by name
  */
 type FindFunction<TAbi extends AbiDefinition, TFn extends string> = Extract<TAbi['abi'][number], {
-    readonly name: TFn;
+  readonly name: TFn;
 }>;
 /**
  * Extract the inputs array for a specific function
@@ -80,8 +81,7 @@ type FunctionInputs<TAbi extends AbiDefinition, TFn extends string> = FindFuncti
  * // => { amount: string; tier: string }
  * ```
  */
-export type FunctionParams<TAbi extends AbiDefinition, TFn extends string> = {
-    [K in FunctionInputs<TAbi, TFn>[number] as K['name']]: string;
-};
-export {};
+type FunctionParams<TAbi extends AbiDefinition, TFn extends string> = { [K in FunctionInputs<TAbi, TFn>[number] as K['name']]: string };
+//#endregion
+export { AbiDefinition, AbiFunction, AbiInput, ExtractContractName, ExtractFunctionNames, FunctionParams };
 //# sourceMappingURL=abi-types.d.ts.map

package/dist/contracts/abi-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"abi-types.d.ts","sourceRoot":"","sources":["../../src/contracts/abi-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,WAAW,QAAQ;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,UAAU,CAAC,EAAE;QACrB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;QACrB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAA;QACrB,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KACtB,CAAA;IACD,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC3B,QAAQ,CAAC,IAAI,EAAE,UAAU,CAAA;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM,EAAE,SAAS,QAAQ,EAAE,CAAA;IACpC,QAAQ,CAAC,OAAO,EAAE,SAAS,OAAO,EAAE,CAAA;IACpC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAA;IAChC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;IACzC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAC1B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAA;IACjC,QAAQ,CAAC,GAAG,EAAE,SAAS,WAAW,EAAE,CAAA;IACpC,QAAQ,CAAC,MAAM,CAAC,EAAE,SAAS,OAAO,EAAE,CAAA;IACpC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAC1B;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,aAAa,IAAI,CAAC,CAAC,cAAc,CAAC,CAAA;AAE5E;;;;;;;;GAQG;AACH,MAAM,MAAM,oBAAoB,CAAC,CAAC,SAAS,aAAa,IAAI,CAAC,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAA;AAEpF;;GAEG;AACH,KAAK,YAAY,CAChB,IAAI,SAAS,aAAa,EAC1B,GAAG,SAAS,MAAM,IACf,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,EAAE;IAAE,QAAQ,CAAC,IAAI,EAAE,GAAG,CAAA;CAAE,CAAC,CAAA;AAExD;;GAEG;AACH,KAAK,cAAc,CAClB,IAAI,SAAS,aAAa,EAC1B,GAAG,SAAS,MAAM,IACf,YAAY,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,QAAQ,CAAC,CAAA;AAErC;;;;;;;;GAQG;AACH,MAAM,MAAM,cAAc,CACzB,IAAI,SAAS,aAAa,EAC1B,GAAG,SAAS,MAAM,IACf;KACF,CAAC,IAAI,cAAc,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM;CAC7D,CAAA"}
+{"version":3,"file":"abi-types.d.ts","names":[],"sources":["../../src/contracts/abi-types.ts"],"mappings":";;AAUA;;;;;;;;UAAiB,QAAA;EAAA,SACP,IAAA;EAAA,SACA,IAAA;EAAA,SACA,WAAA;EAAA,SACA,UAAA;IAAA,SACC,GAAA;IAAA,SACA,GAAA;IAAA,SACA,IAAA;EAAA;EAAA,SAED,IAAA;AAAA;;;;UAMO,WAAA;EAAA,SACP,IAAA;EAAA,SACA,IAAA;EAAA,SACA,MAAA,WAAiB,QAAA;EAAA,SACjB,OAAA;EAAA,SACA,eAAA;EAAA,SACA,WAAA;EAAA,SACA,YAAA;EAAA,SACA,OAAA;AAAA;;;;UAMO,aAAA;EAAA,SACP,YAAA;EAAA,SACA,eAAA;EAAA,SACA,GAAA,WAAc,WAAA;EAAA,SACd,MAAA;EAAA,SACA,OAAA;AAAA;;;;;;;;;AAuBV;KAXY,mBAAA,WAA8B,aAAA,IAAiB,CAAA;;;;;;;;AAWyB;;KAAxE,oBAAA,WAA+B,aAAA,IAAiB,CAAA;;;;KAKvD,YAAA,cAA0B,aAAA,wBAAqC,OAAA,CACnE,IAAA;EAAA,SACW,IAAA,EAAM,GAAA;AAAA;;;;KAMb,cAAA,cAA4B,aAAA,wBAAqC,YAAA,CACrE,IAAA,EACA,GAAA;;;;;;AARoB;;;;KAoBT,cAAA,cAA4B,aAAA,gCACjC,cAAA,CAAe,IAAA,EAAM,GAAA,aAAgB,CAAA"}

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"}