@amadeus-protocol/sdk 1.0.8 → 1.1.0

package/dist/api/proof.d.ts

@@ -1,25 +1,46 @@
-/**
- * Proof API
- *
- * Provides methods for querying validator proofs
- */
-import type { AmadeusClient } from '../client';
-import type { ProofValidators } from '../types';
-export declare class ProofAPI {
-    private client;
-    constructor(client: AmadeusClient);
-    /**
-     * Get validator proof for an entry hash
-     *
-     * @param entryHash - Entry hash (Base58 encoded)
-     * @returns Promise resolving to validator proof data
-     * @throws {Error} If entry hash is invalid
-     *
-     * @example
-     * ```ts
-     * const proof = await sdk.proof.getValidators('5Kd3N...')
-     * ```
-     */
-    getValidators(entryHash: string): Promise<ProofValidators>;
+import { ContractStateProof, ProofValidators } from "../types.js";
+import { AmadeusClient } from "../client.js";
+
+//#region src/api/proof.d.ts
+declare class ProofAPI {
+  private client;
+  constructor(client: AmadeusClient);
+  /**
+   * Get validator proof for an entry hash
+   *
+   * @param entryHash - Entry hash (Base58 encoded)
+   * @returns Promise resolving to validator proof data
+   * @throws {Error} If entry hash is invalid
+   *
+   * @example
+   * ```ts
+   * const proof = await sdk.proof.getValidators('5Kd3N...')
+   * ```
+   */
+  getValidators(entryHash: string): Promise<ProofValidators>;
+  /**
+   * Get a merkle proof for a contract state entry.
+   *
+   * If `value` is supplied the node also verifies the proof and returns
+   * `result: true | false` indicating whether the value matches the proof.
+   *
+   * @param key - Contract state key, either raw bytes or already-Base58-encoded
+   * @param value - Optional value to verify against the proof (raw bytes or Base58)
+   *
+   * @example
+   * ```ts
+   * // Just fetch the proof
+   * const proof = await sdk.proof.getContractStateProof(
+   *   new TextEncoder().encode('account:5Kd3N...:balance:AMA')
+   * )
+   *
+   * // Fetch and verify the value
+   * const verified = await sdk.proof.getContractStateProof(key, expectedValueBytes)
+   * if (verified.result) console.log('matches')
+   * ```
+   */
+  getContractStateProof(key: Uint8Array | string, value?: Uint8Array | string): Promise<ContractStateProof>;
 }
+//#endregion
+export { ProofAPI };
 //# sourceMappingURL=proof.d.ts.map

package/dist/api/proof.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"proof.d.ts","sourceRoot":"","sources":["../../src/api/proof.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAC9C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAI/C,qBAAa,QAAQ;IACR,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAEzC;;;;;;;;;;;OAWG;IACG,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,eAAe,CAAC;CAIhE"}
+{"version":3,"file":"proof.d.ts","names":[],"sources":["../../src/api/proof.ts"],"mappings":";;;;cAYa,QAAA;EAAA,QACQ,MAAA;cAAA,MAAA,EAAQ,aAAA;EAyCtB;;;;;;;;;;;;EA3BA,aAAA,CAAc,SAAA,WAAoB,OAAA,CAAQ,eAAA;EAAA;;;;;;;;;;;;;;;;;;;;;EA0B1C,qBAAA,CACL,GAAA,EAAK,UAAA,WACL,KAAA,GAAQ,UAAA,YACN,OAAA,CAAQ,kBAAA;AAAA"}

package/dist/api/proof.js

@@ -1,30 +1,57 @@
-/**
- * Proof API
- *
- * Provides methods for querying validator proofs
- */
-import { Base58HashSchema } from '../schemas';
-import { validate } from '../validation';
-export class ProofAPI {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Get validator proof for an entry hash
-     *
-     * @param entryHash - Entry hash (Base58 encoded)
-     * @returns Promise resolving to validator proof data
-     * @throws {Error} If entry hash is invalid
-     *
-     * @example
-     * ```ts
-     * const proof = await sdk.proof.getValidators('5Kd3N...')
-     * ```
-     */
-    async getValidators(entryHash) {
-        validate(Base58HashSchema, entryHash);
-        return this.client.get(`/api/proof/validators/${entryHash}`);
-    }
-}
+import { toBase58 } from "../encoding.js";
+import { validate } from "../validation.js";
+import { Base58HashSchema } from "../schemas.js";
+//#region src/api/proof.ts
+var ProofAPI = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	/**
+	* Get validator proof for an entry hash
+	*
+	* @param entryHash - Entry hash (Base58 encoded)
+	* @returns Promise resolving to validator proof data
+	* @throws {Error} If entry hash is invalid
+	*
+	* @example
+	* ```ts
+	* const proof = await sdk.proof.getValidators('5Kd3N...')
+	* ```
+	*/
+	async getValidators(entryHash) {
+		validate(Base58HashSchema, entryHash);
+		return this.client.get(`/api/proof/validators/${entryHash}`);
+	}
+	/**
+	* Get a merkle proof for a contract state entry.
+	*
+	* If `value` is supplied the node also verifies the proof and returns
+	* `result: true | false` indicating whether the value matches the proof.
+	*
+	* @param key - Contract state key, either raw bytes or already-Base58-encoded
+	* @param value - Optional value to verify against the proof (raw bytes or Base58)
+	*
+	* @example
+	* ```ts
+	* // Just fetch the proof
+	* const proof = await sdk.proof.getContractStateProof(
+	*   new TextEncoder().encode('account:5Kd3N...:balance:AMA')
+	* )
+	*
+	* // Fetch and verify the value
+	* const verified = await sdk.proof.getContractStateProof(key, expectedValueBytes)
+	* if (verified.result) console.log('matches')
+	* ```
+	*/
+	async getContractStateProof(key, value) {
+		const path = `/api/proof/contractstate/${typeof key === "string" ? key : toBase58(key)}`;
+		if (value === void 0) return this.client.get(path);
+		const valueB58 = typeof value === "string" ? value : toBase58(value);
+		return this.client.get(`${path}/${valueB58}`);
+	}
+};
+//#endregion
+export { ProofAPI };
+
 //# sourceMappingURL=proof.js.map

package/dist/api/proof.js.map

@@ -1 +1 @@
-{"version":3,"file":"proof.js","sourceRoot":"","sources":["../../src/api/proof.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAExC,MAAM,OAAO,QAAQ;IACA;IAApB,YAAoB,MAAqB;QAArB,WAAM,GAAN,MAAM,CAAe;IAAG,CAAC;IAE7C;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,aAAa,CAAC,SAAiB;QACpC,QAAQ,CAAC,gBAAgB,EAAE,SAAS,CAAC,CAAA;QACrC,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAkB,yBAAyB,SAAS,EAAE,CAAC,CAAA;IAC9E,CAAC;CACD"}
+{"version":3,"file":"proof.js","names":[],"sources":["../../src/api/proof.ts"],"sourcesContent":["/**\n * Proof API\n *\n * Provides methods for querying validator proofs\n */\n\nimport type { AmadeusClient } from '../client'\nimport type { ProofValidators, ContractStateProof } from '../types'\nimport { Base58HashSchema } from '../schemas'\nimport { toBase58 } from '../encoding'\nimport { validate } from '../validation'\n\nexport class ProofAPI {\n\tconstructor(private client: AmadeusClient) {}\n\n\t/**\n\t * Get validator proof for an entry hash\n\t *\n\t * @param entryHash - Entry hash (Base58 encoded)\n\t * @returns Promise resolving to validator proof data\n\t * @throws {Error} If entry hash is invalid\n\t *\n\t * @example\n\t * ```ts\n\t * const proof = await sdk.proof.getValidators('5Kd3N...')\n\t * ```\n\t */\n\tasync getValidators(entryHash: string): Promise<ProofValidators> {\n\t\tvalidate(Base58HashSchema, entryHash)\n\t\treturn this.client.get<ProofValidators>(`/api/proof/validators/${entryHash}`)\n\t}\n\n\t/**\n\t * Get a merkle proof for a contract state entry.\n\t *\n\t * If `value` is supplied the node also verifies the proof and returns\n\t * `result: true | false` indicating whether the value matches the proof.\n\t *\n\t * @param key - Contract state key, either raw bytes or already-Base58-encoded\n\t * @param value - Optional value to verify against the proof (raw bytes or Base58)\n\t *\n\t * @example\n\t * ```ts\n\t * // Just fetch the proof\n\t * const proof = await sdk.proof.getContractStateProof(\n\t *   new TextEncoder().encode('account:5Kd3N...:balance:AMA')\n\t * )\n\t *\n\t * // Fetch and verify the value\n\t * const verified = await sdk.proof.getContractStateProof(key, expectedValueBytes)\n\t * if (verified.result) console.log('matches')\n\t * ```\n\t */\n\tasync getContractStateProof(\n\t\tkey: Uint8Array | string,\n\t\tvalue?: Uint8Array | string\n\t): Promise<ContractStateProof> {\n\t\tconst keyB58 = typeof key === 'string' ? key : toBase58(key)\n\t\tconst path = `/api/proof/contractstate/${keyB58}`\n\t\tif (value === undefined) {\n\t\t\treturn this.client.get<ContractStateProof>(path)\n\t\t}\n\t\tconst valueB58 = typeof value === 'string' ? value : toBase58(value)\n\t\treturn this.client.get<ContractStateProof>(`${path}/${valueB58}`)\n\t}\n}\n"],"mappings":";;;;AAYA,IAAa,WAAb,MAAsB;CACD;CAApB,YAAY,QAA+B;EAAvB,KAAA,SAAA;;;;;;;;;;;;;;CAcpB,MAAM,cAAc,WAA6C;EAChE,SAAS,kBAAkB,UAAU;EACrC,OAAO,KAAK,OAAO,IAAqB,yBAAyB,YAAY;;;;;;;;;;;;;;;;;;;;;;;CAwB9E,MAAM,sBACL,KACA,OAC8B;EAE9B,MAAM,OAAO,4BADE,OAAO,QAAQ,WAAW,MAAM,SAAS,IAAI;EAE5D,IAAI,UAAU,KAAA,GACb,OAAO,KAAK,OAAO,IAAwB,KAAK;EAEjD,MAAM,WAAW,OAAO,UAAU,WAAW,QAAQ,SAAS,MAAM;EACpE,OAAO,KAAK,OAAO,IAAwB,GAAG,KAAK,GAAG,WAAW"}

package/dist/api/transaction.d.ts

@@ -1,71 +1,70 @@
-/**
- * Transaction API
- *
- * Provides methods for submitting transactions and querying transaction data
- */
-import type { AmadeusClient } from '../client';
-import type { SubmitTransactionResponse, SubmitAndWaitTransactionResponse, GetTransactionsInEntryResponse, Transaction } from '../types';
-export declare class TransactionAPI {
-    private client;
-    constructor(client: AmadeusClient);
-    /**
-     * Submit a transaction to the network
-     *
-     * @param txPacked - Packed transaction as Uint8Array or Base58 string
-     * @returns Promise resolving to submission result
-     * @throws {AmadeusSDKError} If transaction data is invalid
-     *
-     * @example
-     * ```ts
-     * const result = await sdk.transaction.submit(txPacked)
-     * if (result.error === 'ok') {
-     *   console.log('Transaction hash:', result.hash)
-     * }
-     * ```
-     */
-    submit(txPacked: Uint8Array | string): Promise<SubmitTransactionResponse>;
-    /**
-     * Submit a transaction and wait for confirmation
-     *
-     * @param txPacked - Packed transaction as Uint8Array or Base58 string
-     * @returns Promise resolving to submission result with confirmation
-     * @throws {AmadeusSDKError} If transaction data is invalid
-     *
-     * @example
-     * ```ts
-     * const result = await sdk.transaction.submitAndWait(txPacked)
-     * if (result.error === 'ok') {
-     *   console.log('Transaction hash:', result.hash)
-     *   console.log('Entry hash:', result.entry_hash)
-     * }
-     * ```
-     */
-    submitAndWait(txPacked: Uint8Array | string): Promise<SubmitAndWaitTransactionResponse>;
-    /**
-     * Get transaction by ID
-     *
-     * @param txid - Transaction ID (Base58 encoded)
-     * @returns Promise resolving to transaction data
-     * @throws {AmadeusSDKError} If transaction ID is invalid
-     *
-     * @example
-     * ```ts
-     * const tx = await sdk.transaction.get('5Kd3N...')
-     * ```
-     */
-    get(txid: string): Promise<Transaction>;
-    /**
-     * Get transactions by entry hash
-     *
-     * @param entryHash - Entry hash (Base58 encoded)
-     * @returns Promise resolving to transactions in the entry
-     * @throws {AmadeusSDKError} If entry hash is invalid
-     *
-     * @example
-     * ```ts
-     * const { txs } = await sdk.transaction.getByEntry('5Kd3N...')
-     * ```
-     */
-    getByEntry(entryHash: string): Promise<GetTransactionsInEntryResponse>;
+import { GetTransactionsInEntryResponse, SubmitAndWaitOptions, SubmitAndWaitTransactionResponse, SubmitTransactionResponse, Transaction } from "../types.js";
+import { AmadeusClient } from "../client.js";
+
+//#region src/api/transaction.d.ts
+declare class TransactionAPI {
+  private client;
+  constructor(client: AmadeusClient);
+  /**
+   * Submit a transaction to the network
+   *
+   * @param txPacked - Packed transaction as Uint8Array or Base58 string
+   * @returns Promise resolving to submission result
+   * @throws {AmadeusSDKError} If transaction data is invalid
+   *
+   * @example
+   * ```ts
+   * const result = await sdk.transaction.submit(txPacked)
+   * if (result.error === 'ok') {
+   *   console.log('Transaction hash:', result.hash)
+   * }
+   * ```
+   */
+  submit(txPacked: Uint8Array | string): Promise<SubmitTransactionResponse>;
+  /**
+   * Submit a transaction and wait for confirmation.
+   *
+   * Pass `{ finalized: true }` to wait for finality (consensus reached) instead
+   * of just confirmation. Default behavior is to return as soon as the tx is
+   * included in an entry.
+   *
+   * @example
+   * ```ts
+   * // Wait for confirmation only (fast)
+   * const result = await sdk.transaction.submitAndWait(txPacked)
+   *
+   * // Wait for finality (slower but stronger guarantee)
+   * const finalized = await sdk.transaction.submitAndWait(txPacked, { finalized: true })
+   * ```
+   */
+  submitAndWait(txPacked: Uint8Array | string, options?: SubmitAndWaitOptions): Promise<SubmitAndWaitTransactionResponse>;
+  /**
+   * Get transaction by ID
+   *
+   * @param txid - Transaction ID (Base58 encoded)
+   * @returns Promise resolving to transaction data
+   * @throws {AmadeusSDKError} If transaction ID is invalid
+   *
+   * @example
+   * ```ts
+   * const tx = await sdk.transaction.get('5Kd3N...')
+   * ```
+   */
+  get(txid: string): Promise<Transaction>;
+  /**
+   * Get transactions by entry hash
+   *
+   * @param entryHash - Entry hash (Base58 encoded)
+   * @returns Promise resolving to transactions in the entry
+   * @throws {AmadeusSDKError} If entry hash is invalid
+   *
+   * @example
+   * ```ts
+   * const { txs } = await sdk.transaction.getByEntry('5Kd3N...')
+   * ```
+   */
+  getByEntry(entryHash: string): Promise<GetTransactionsInEntryResponse>;
 }
+//#endregion
+export { TransactionAPI };
 //# sourceMappingURL=transaction.d.ts.map

package/dist/api/transaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../src/api/transaction.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAC9C,OAAO,KAAK,EACX,yBAAyB,EACzB,gCAAgC,EAChC,8BAA8B,EAC9B,WAAW,EACX,MAAM,UAAU,CAAA;AAIjB,qBAAa,cAAc;IACd,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAEzC;;;;;;;;;;;;;;OAcG;IACG,MAAM,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,yBAAyB,CAAC;IAK/E;;;;;;;;;;;;;;;OAeG;IACG,aAAa,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,OAAO,CAAC,gCAAgC,CAAC;IAQ7F;;;;;;;;;;;OAWG;IACG,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,CAAC;IAK7C;;;;;;;;;;;OAWG;IACG,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,8BAA8B,CAAC;CAM5E"}
+{"version":3,"file":"transaction.d.ts","names":[],"sources":["../../src/api/transaction.ts"],"mappings":";;;;cAiBa,cAAA;EAAA,QACQ,MAAA;cAAA,MAAA,EAAQ,aAAA;EAiBiB;;;;;;;;;;;;;;;EAAvC,MAAA,CAAO,QAAA,EAAU,UAAA,YAAsB,OAAA,CAAQ,yBAAA;EAA9B;;;;;;;;;;;;;;;;EAqBjB,aAAA,CACL,QAAA,EAAU,UAAA,WACV,OAAA,GAAS,oBAAA,GACP,OAAA,CAAQ,gCAAA;EAqC0B;;;;;;;;;;;;EAjB/B,GAAA,CAAI,IAAA,WAAe,OAAA,CAAQ,WAAA;;;;;;;;;;;;;EAiB3B,UAAA,CAAW,SAAA,WAAoB,OAAA,CAAQ,8BAAA;AAAA"}

package/dist/api/transaction.js

@@ -1,85 +1,85 @@
-/**
- * Transaction API
- *
- * Provides methods for submitting transactions and querying transaction data
- */
-import { Base58HashSchema, TransactionDataSchema } from '../schemas';
-import { validate } from '../validation';
-export class TransactionAPI {
-    client;
-    constructor(client) {
-        this.client = client;
-    }
-    /**
-     * Submit a transaction to the network
-     *
-     * @param txPacked - Packed transaction as Uint8Array or Base58 string
-     * @returns Promise resolving to submission result
-     * @throws {AmadeusSDKError} If transaction data is invalid
-     *
-     * @example
-     * ```ts
-     * const result = await sdk.transaction.submit(txPacked)
-     * if (result.error === 'ok') {
-     *   console.log('Transaction hash:', result.hash)
-     * }
-     * ```
-     */
-    async submit(txPacked) {
-        validate(TransactionDataSchema, txPacked);
-        return this.client.post('/api/tx/submit', txPacked);
-    }
-    /**
-     * Submit a transaction and wait for confirmation
-     *
-     * @param txPacked - Packed transaction as Uint8Array or Base58 string
-     * @returns Promise resolving to submission result with confirmation
-     * @throws {AmadeusSDKError} If transaction data is invalid
-     *
-     * @example
-     * ```ts
-     * const result = await sdk.transaction.submitAndWait(txPacked)
-     * if (result.error === 'ok') {
-     *   console.log('Transaction hash:', result.hash)
-     *   console.log('Entry hash:', result.entry_hash)
-     * }
-     * ```
-     */
-    async submitAndWait(txPacked) {
-        validate(TransactionDataSchema, txPacked);
-        return this.client.post('/api/tx/submit_and_wait', txPacked);
-    }
-    /**
-     * Get transaction by ID
-     *
-     * @param txid - Transaction ID (Base58 encoded)
-     * @returns Promise resolving to transaction data
-     * @throws {AmadeusSDKError} If transaction ID is invalid
-     *
-     * @example
-     * ```ts
-     * const tx = await sdk.transaction.get('5Kd3N...')
-     * ```
-     */
-    async get(txid) {
-        validate(Base58HashSchema, txid);
-        return this.client.get(`/api/chain/tx/${txid}`);
-    }
-    /**
-     * Get transactions by entry hash
-     *
-     * @param entryHash - Entry hash (Base58 encoded)
-     * @returns Promise resolving to transactions in the entry
-     * @throws {AmadeusSDKError} If entry hash is invalid
-     *
-     * @example
-     * ```ts
-     * const { txs } = await sdk.transaction.getByEntry('5Kd3N...')
-     * ```
-     */
-    async getByEntry(entryHash) {
-        validate(Base58HashSchema, entryHash);
-        return this.client.get(`/api/chain/txs_in_entry/${entryHash}`);
-    }
-}
+import { validate } from "../validation.js";
+import { Base58HashSchema, TransactionDataSchema } from "../schemas.js";
+//#region src/api/transaction.ts
+var TransactionAPI = class {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	/**
+	* Submit a transaction to the network
+	*
+	* @param txPacked - Packed transaction as Uint8Array or Base58 string
+	* @returns Promise resolving to submission result
+	* @throws {AmadeusSDKError} If transaction data is invalid
+	*
+	* @example
+	* ```ts
+	* const result = await sdk.transaction.submit(txPacked)
+	* if (result.error === 'ok') {
+	*   console.log('Transaction hash:', result.hash)
+	* }
+	* ```
+	*/
+	async submit(txPacked) {
+		validate(TransactionDataSchema, txPacked);
+		return this.client.post("/api/tx/submit", txPacked);
+	}
+	/**
+	* Submit a transaction and wait for confirmation.
+	*
+	* Pass `{ finalized: true }` to wait for finality (consensus reached) instead
+	* of just confirmation. Default behavior is to return as soon as the tx is
+	* included in an entry.
+	*
+	* @example
+	* ```ts
+	* // Wait for confirmation only (fast)
+	* const result = await sdk.transaction.submitAndWait(txPacked)
+	*
+	* // Wait for finality (slower but stronger guarantee)
+	* const finalized = await sdk.transaction.submitAndWait(txPacked, { finalized: true })
+	* ```
+	*/
+	async submitAndWait(txPacked, options = {}) {
+		validate(TransactionDataSchema, txPacked);
+		const endpoint = options.finalized ? "/api/tx/submit_and_wait?finalized=true" : "/api/tx/submit_and_wait";
+		return this.client.post(endpoint, txPacked);
+	}
+	/**
+	* Get transaction by ID
+	*
+	* @param txid - Transaction ID (Base58 encoded)
+	* @returns Promise resolving to transaction data
+	* @throws {AmadeusSDKError} If transaction ID is invalid
+	*
+	* @example
+	* ```ts
+	* const tx = await sdk.transaction.get('5Kd3N...')
+	* ```
+	*/
+	async get(txid) {
+		validate(Base58HashSchema, txid);
+		return this.client.get(`/api/chain/tx/${txid}`);
+	}
+	/**
+	* Get transactions by entry hash
+	*
+	* @param entryHash - Entry hash (Base58 encoded)
+	* @returns Promise resolving to transactions in the entry
+	* @throws {AmadeusSDKError} If entry hash is invalid
+	*
+	* @example
+	* ```ts
+	* const { txs } = await sdk.transaction.getByEntry('5Kd3N...')
+	* ```
+	*/
+	async getByEntry(entryHash) {
+		validate(Base58HashSchema, entryHash);
+		return this.client.get(`/api/chain/txs_in_entry/${entryHash}`);
+	}
+};
+//#endregion
+export { TransactionAPI };
+
 //# sourceMappingURL=transaction.js.map

package/dist/api/transaction.js.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../src/api/transaction.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AASH,OAAO,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAA;AACpE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AAExC,MAAM,OAAO,cAAc;IACN;IAApB,YAAoB,MAAqB;QAArB,WAAM,GAAN,MAAM,CAAe;IAAG,CAAC;IAE7C;;;;;;;;;;;;;;OAcG;IACH,KAAK,CAAC,MAAM,CAAC,QAA6B;QACzC,QAAQ,CAAC,qBAAqB,EAAE,QAAQ,CAAC,CAAA;QACzC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CAA4B,gBAAgB,EAAE,QAAQ,CAAC,CAAA;IAC/E,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACH,KAAK,CAAC,aAAa,CAAC,QAA6B;QAChD,QAAQ,CAAC,qBAAqB,EAAE,QAAQ,CAAC,CAAA;QACzC,OAAO,IAAI,CAAC,MAAM,CAAC,IAAI,CACtB,yBAAyB,EACzB,QAAQ,CACR,CAAA;IACF,CAAC;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,GAAG,CAAC,IAAY;QACrB,QAAQ,CAAC,gBAAgB,EAAE,IAAI,CAAC,CAAA;QAChC,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CAAc,iBAAiB,IAAI,EAAE,CAAC,CAAA;IAC7D,CAAC;IAED;;;;;;;;;;;OAWG;IACH,KAAK,CAAC,UAAU,CAAC,SAAiB;QACjC,QAAQ,CAAC,gBAAgB,EAAE,SAAS,CAAC,CAAA;QACrC,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,CACrB,2BAA2B,SAAS,EAAE,CACtC,CAAA;IACF,CAAC;CACD"}
+{"version":3,"file":"transaction.js","names":[],"sources":["../../src/api/transaction.ts"],"sourcesContent":["/**\n * Transaction API\n *\n * Provides methods for submitting transactions and querying transaction data\n */\n\nimport type { AmadeusClient } from '../client'\nimport type {\n\tSubmitTransactionResponse,\n\tSubmitAndWaitTransactionResponse,\n\tSubmitAndWaitOptions,\n\tGetTransactionsInEntryResponse,\n\tTransaction\n} from '../types'\nimport { Base58HashSchema, TransactionDataSchema } from '../schemas'\nimport { validate } from '../validation'\n\nexport class TransactionAPI {\n\tconstructor(private client: AmadeusClient) {}\n\n\t/**\n\t * Submit a transaction to the network\n\t *\n\t * @param txPacked - Packed transaction as Uint8Array or Base58 string\n\t * @returns Promise resolving to submission result\n\t * @throws {AmadeusSDKError} If transaction data is invalid\n\t *\n\t * @example\n\t * ```ts\n\t * const result = await sdk.transaction.submit(txPacked)\n\t * if (result.error === 'ok') {\n\t *   console.log('Transaction hash:', result.hash)\n\t * }\n\t * ```\n\t */\n\tasync submit(txPacked: Uint8Array | string): Promise<SubmitTransactionResponse> {\n\t\tvalidate(TransactionDataSchema, txPacked)\n\t\treturn this.client.post<SubmitTransactionResponse>('/api/tx/submit', txPacked)\n\t}\n\n\t/**\n\t * Submit a transaction and wait for confirmation.\n\t *\n\t * Pass `{ finalized: true }` to wait for finality (consensus reached) instead\n\t * of just confirmation. Default behavior is to return as soon as the tx is\n\t * included in an entry.\n\t *\n\t * @example\n\t * ```ts\n\t * // Wait for confirmation only (fast)\n\t * const result = await sdk.transaction.submitAndWait(txPacked)\n\t *\n\t * // Wait for finality (slower but stronger guarantee)\n\t * const finalized = await sdk.transaction.submitAndWait(txPacked, { finalized: true })\n\t * ```\n\t */\n\tasync submitAndWait(\n\t\ttxPacked: Uint8Array | string,\n\t\toptions: SubmitAndWaitOptions = {}\n\t): Promise<SubmitAndWaitTransactionResponse> {\n\t\tvalidate(TransactionDataSchema, txPacked)\n\t\tconst endpoint = options.finalized\n\t\t\t? '/api/tx/submit_and_wait?finalized=true'\n\t\t\t: '/api/tx/submit_and_wait'\n\t\treturn this.client.post<SubmitAndWaitTransactionResponse>(endpoint, txPacked)\n\t}\n\n\t/**\n\t * Get transaction by ID\n\t *\n\t * @param txid - Transaction ID (Base58 encoded)\n\t * @returns Promise resolving to transaction data\n\t * @throws {AmadeusSDKError} If transaction ID is invalid\n\t *\n\t * @example\n\t * ```ts\n\t * const tx = await sdk.transaction.get('5Kd3N...')\n\t * ```\n\t */\n\tasync get(txid: string): Promise<Transaction> {\n\t\tvalidate(Base58HashSchema, txid)\n\t\treturn this.client.get<Transaction>(`/api/chain/tx/${txid}`)\n\t}\n\n\t/**\n\t * Get transactions by entry hash\n\t *\n\t * @param entryHash - Entry hash (Base58 encoded)\n\t * @returns Promise resolving to transactions in the entry\n\t * @throws {AmadeusSDKError} If entry hash is invalid\n\t *\n\t * @example\n\t * ```ts\n\t * const { txs } = await sdk.transaction.getByEntry('5Kd3N...')\n\t * ```\n\t */\n\tasync getByEntry(entryHash: string): Promise<GetTransactionsInEntryResponse> {\n\t\tvalidate(Base58HashSchema, entryHash)\n\t\treturn this.client.get<GetTransactionsInEntryResponse>(\n\t\t\t`/api/chain/txs_in_entry/${entryHash}`\n\t\t)\n\t}\n}\n"],"mappings":";;;AAiBA,IAAa,iBAAb,MAA4B;CACP;CAApB,YAAY,QAA+B;EAAvB,KAAA,SAAA;;;;;;;;;;;;;;;;;CAiBpB,MAAM,OAAO,UAAmE;EAC/E,SAAS,uBAAuB,SAAS;EACzC,OAAO,KAAK,OAAO,KAAgC,kBAAkB,SAAS;;;;;;;;;;;;;;;;;;CAmB/E,MAAM,cACL,UACA,UAAgC,EAAE,EACU;EAC5C,SAAS,uBAAuB,SAAS;EACzC,MAAM,WAAW,QAAQ,YACtB,2CACA;EACH,OAAO,KAAK,OAAO,KAAuC,UAAU,SAAS;;;;;;;;;;;;;;CAe9E,MAAM,IAAI,MAAoC;EAC7C,SAAS,kBAAkB,KAAK;EAChC,OAAO,KAAK,OAAO,IAAiB,iBAAiB,OAAO;;;;;;;;;;;;;;CAe7D,MAAM,WAAW,WAA4D;EAC5E,SAAS,kBAAkB,UAAU;EACrC,OAAO,KAAK,OAAO,IAClB,2BAA2B,YAC3B"}

package/dist/api/wallet.d.ts

@@ -1,39 +1,38 @@
-/**
- * Wallet API
- *
- * Provides methods for querying wallet balances and information
- */
-import type { AmadeusClient } from '../client';
-import type { WalletBalance, GetAllBalancesResponse } from '../types';
-export declare class WalletAPI {
-    private client;
-    constructor(client: AmadeusClient);
-    /**
-     * Get balance for a specific address and symbol
-     *
-     * @param address - Base58 encoded wallet address
-     * @param symbol - Token symbol (default: 'AMA')
-     * @returns Promise resolving to wallet balance
-     * @throws {AmadeusSDKError} If address is invalid
-     *
-     * @example
-     * ```ts
-     * const balance = await sdk.wallet.getBalance('5Kd3N...', 'AMA')
-     * ```
-     */
-    getBalance(address: string, symbol?: string): Promise<WalletBalance>;
-    /**
-     * Get all balances for an address
-     *
-     * @param address - Base58 encoded wallet address
-     * @returns Promise resolving to all wallet balances
-     * @throws {AmadeusSDKError} If address is invalid
-     *
-     * @example
-     * ```ts
-     * const { balances } = await sdk.wallet.getAllBalances('5Kd3N...')
-     * ```
-     */
-    getAllBalances(address: string): Promise<GetAllBalancesResponse>;
+import { GetAllBalancesResponse, WalletBalance } from "../types.js";
+import { AmadeusClient } from "../client.js";
+
+//#region src/api/wallet.d.ts
+declare class WalletAPI {
+  private client;
+  constructor(client: AmadeusClient);
+  /**
+   * Get balance for a specific address and symbol
+   *
+   * @param address - Base58 encoded wallet address
+   * @param symbol - Token symbol (default: 'AMA')
+   * @returns Promise resolving to wallet balance
+   * @throws {AmadeusSDKError} If address is invalid
+   *
+   * @example
+   * ```ts
+   * const balance = await sdk.wallet.getBalance('5Kd3N...', 'AMA')
+   * ```
+   */
+  getBalance(address: string, symbol?: string): Promise<WalletBalance>;
+  /**
+   * Get all balances for an address
+   *
+   * @param address - Base58 encoded wallet address
+   * @returns Promise resolving to all wallet balances
+   * @throws {AmadeusSDKError} If address is invalid
+   *
+   * @example
+   * ```ts
+   * const { balances } = await sdk.wallet.getAllBalances('5Kd3N...')
+   * ```
+   */
+  getAllBalances(address: string): Promise<GetAllBalancesResponse>;
 }
+//#endregion
+export { WalletAPI };
 //# sourceMappingURL=wallet.d.ts.map

package/dist/api/wallet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wallet.d.ts","sourceRoot":"","sources":["../../src/api/wallet.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,WAAW,CAAA;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,UAAU,CAAA;AAIrE,qBAAa,SAAS;IACT,OAAO,CAAC,MAAM;gBAAN,MAAM,EAAE,aAAa;IAEzC;;;;;;;;;;;;OAYG;IACG,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,GAAE,MAAc,GAAG,OAAO,CAAC,aAAa,CAAC;IAWjF;;;;;;;;;;;OAWG;IACG,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,sBAAsB,CAAC;CAItE"}
+{"version":3,"file":"wallet.d.ts","names":[],"sources":["../../src/api/wallet.ts"],"mappings":";;;;cAWa,SAAA;EAAA,QACQ,MAAA;cAAA,MAAA,EAAQ,aAAA;EAsCmB;;;;;;;;;;;;;EAvBzC,UAAA,CAAW,OAAA,UAAiB,MAAA,YAAyB,OAAA,CAAQ,aAAA;EAuB9C;;;;;;;;;;;;EAAf,cAAA,CAAe,OAAA,WAAkB,OAAA,CAAQ,sBAAA;AAAA"}