@amadeus-protocol/sdk 1.0.6 → 1.0.7

package/dist/transaction-builder.js

@@ -1,14 +1,36 @@
 /**
  * Transaction Builder
  *
- * This module provides a class-based API for building and signing Amadeus protocol transactions.
+ * Class-based API for building and signing Amadeus protocol transactions.
+ * Delegates to the signing primitives in `signing.ts` and the ABI-driven
+ * contract factory in `contracts/contract.ts`.
+ *
+ * ## Recommended: ABI-driven API
+ *
+ * ```ts
+ * import { TransactionBuilder, LOCKUP_PRIME_ABI, toAtomicAma } from '@amadeus-protocol/sdk'
+ *
+ * // Via builder.contract(abi) — typed methods, auto-signed:
+ * const builder = new TransactionBuilder('5Kd3N...')
+ * const result = builder.contract(LOCKUP_PRIME_ABI).lock({
+ *   amount: toAtomicAma(100).toString(),
+ *   tier: '30d'
+ * })
+ *
+ * // Or standalone:
+ * import { createContract } from '@amadeus-protocol/sdk'
+ * const lockupPrime = createContract(LOCKUP_PRIME_ABI)
+ * const call = lockupPrime.lock({ amount: toAtomicAma(100).toString(), tier: '30d' })
+ * const result = TransactionBuilder.signCall('5Kd3N...', call)
+ * ```
  */
-import { bls12_381 as bls } from '@noble/curves/bls12-381';
-import { sha256 } from '@noble/hashes/sha2';
 import { deriveSkAndSeed64FromBase58Seed, getPublicKey } from './crypto';
-import { fromBase58, toBase58 } from './encoding';
 import { toAtomicAma } from './conversion';
-import { encode } from './serialization';
+import { buildUnsigned, buildUnsignedFromCall, buildAndSignRaw, signUnsigned, signContractCall, normalizeSignerSk } from './signing';
+import { createContract } from './contracts/contract';
+import { buildCoinTransfer } from './contracts/coin';
+import { LOCKUP_PRIME_ABI } from './contracts/lockup-prime/abi';
+import { LOCKUP_ABI } from './contracts/lockup/abi';
 /**
  * Transaction Builder for Amadeus Protocol
  *
@@ -17,31 +39,24 @@ import { encode } from './serialization';
  *
  * @example
  * ```ts
- * // Instance-based usage
+ * // ABI-driven (recommended)
  * const builder = new TransactionBuilder('5Kd3N...')
- * const { txHash, txPacked } = builder.transfer({
- *   recipient: '5Kd3N...',
- *   amount: 10.5,
- *   symbol: 'AMA'
+ * const result = builder.contract(LOCKUP_PRIME_ABI).lock({
+ *   amount: toAtomicAma(100).toString(),
+ *   tier: '30d'
  * })
  *
- * // Static usage
- * const { txHash, txPacked } = TransactionBuilder.buildTransfer({
- *   senderPrivkey: '5Kd3N...',
- *   recipient: '5Kd3N...',
- *   amount: 10.5,
- *   symbol: 'AMA'
- * })
+ * // Generic build/sign
+ * const builder = new TransactionBuilder('5Kd3N...')
+ * const { txHash, txPacked } = builder.buildAndSign('Coin', 'transfer', [
+ *   recipientBytes, '1000000000', 'AMA'
+ * ])
  * ```
  */
 export class TransactionBuilder {
     privateKey;
     signerPk = null;
     signerSk = null;
-    /**
-     * Domain Separation Tag for transaction signatures
-     */
-    static TX_DST = 'AMADEUS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_TX_';
     /**
      * Create a new TransactionBuilder instance
      *
@@ -54,73 +69,6 @@ export class TransactionBuilder {
             this.initializeKeys();
         }
     }
-    /**
-     * Generate a transaction nonce based on current timestamp
-     */
-    static generateNonce() {
-        return BigInt(Date.now()) * 1000000n;
-    }
-    /**
-     * Create transaction structure
-     */
-    static createTransaction(signer, contract, method, args) {
-        const action = {
-            op: 'call',
-            contract,
-            function: method,
-            args
-        };
-        return {
-            signer,
-            nonce: TransactionBuilder.generateNonce(),
-            action
-        };
-    }
-    /**
-     * Build an unsigned transaction (returns transaction structure and hash)
-     */
-    static buildUnsignedTransaction(signerPk, contract, method, args) {
-        const tx = TransactionBuilder.createTransaction(signerPk, contract, method, args);
-        const txEncoded = encode(tx);
-        const hash = sha256(txEncoded);
-        return { tx, hash };
-    }
-    /**
-     * Normalize signer secret key to PrivKey format (handles Base58 strings)
-     */
-    static normalizeSignerSk(signerSk) {
-        if (typeof signerSk === 'string') {
-            // Base58 string - derive PrivKey from it
-            const { sk } = deriveSkAndSeed64FromBase58Seed(signerSk);
-            return sk;
-        }
-        // Already PrivKey (Uint8Array)
-        return signerSk;
-    }
-    /**
-     * Sign a transaction hash using BLS12-381 with transaction DST
-     */
-    static signHash(hash, signerSk) {
-        const normalizedSk = TransactionBuilder.normalizeSignerSk(signerSk);
-        return bls.sign(hash, normalizedSk, { DST: TransactionBuilder.TX_DST });
-    }
-    /**
-     * Sign an unsigned transaction
-     */
-    static signTransaction(unsignedTx, signerSk) {
-        const signature = TransactionBuilder.signHash(unsignedTx.hash, signerSk);
-        return {
-            txHash: toBase58(unsignedTx.hash),
-            txPacked: encode({ tx: unsignedTx.tx, hash: unsignedTx.hash, signature })
-        };
-    }
-    /**
-     * Build and sign a transaction (convenience method)
-     */
-    static buildAndSignTransaction(signerPk, signerSk, contract, method, args) {
-        const unsignedTx = TransactionBuilder.buildUnsignedTransaction(signerPk, contract, method, args);
-        return TransactionBuilder.signTransaction(unsignedTx, signerSk);
-    }
     /**
      * Initialize signer keys from the private key
      */
@@ -132,266 +80,267 @@ export class TransactionBuilder {
         this.signerPk = getPublicKey(seed64);
         this.signerSk = sk;
     }
-    /**
-     * Build an unsigned transaction
-     *
-     * @param contract - Contract name
-     * @param method - Method name
-     * @param args - Method arguments
-     * @param signerPk - Optional signer's public key (required if instance has no private key)
-     * @returns Unsigned transaction with hash
-     *
-     * @example
-     * ```ts
-     * const builder = new TransactionBuilder('5Kd3N...')
-     * const unsignedTx = builder.build('Coin', 'transfer', [
-     *   recipientBytes,
-     *   '1000000000',
-     *   'AMA'
-     * ])
-     * // Can inspect or modify before signing
-     * const { txHash, txPacked } = builder.sign(unsignedTx)
-     * ```
-     */
-    build(contract, method, args, signerPk) {
-        const pk = signerPk || this.signerPk;
-        if (!pk) {
-            throw new Error('Signer public key required. Provide key or initialize builder with private key.');
-        }
-        return TransactionBuilder.buildUnsignedTransaction(pk, contract, method, args);
-    }
     /**
      * Get the signer's secret key (normalizes to PrivKey format)
-     * Handles Base58 strings, PrivKey (Uint8Array), or uses cached/derived key
      */
     getSignerSk(signerSk) {
-        // If provided, normalize it (convert Base58 string to PrivKey if needed)
         if (signerSk) {
-            if (typeof signerSk === 'string') {
-                // Base58 string - derive PrivKey from it
-                const { sk } = deriveSkAndSeed64FromBase58Seed(signerSk);
-                return sk;
-            }
-            // Already PrivKey (Uint8Array)
-            return signerSk;
+            return normalizeSignerSk(signerSk);
         }
-        // Use cached signerSk if available
         if (this.signerSk) {
             return this.signerSk;
         }
-        // Derive from privateKey
         if (this.privateKey) {
-            const { sk } = deriveSkAndSeed64FromBase58Seed(this.privateKey);
-            return sk;
+            return normalizeSignerSk(this.privateKey);
         }
         throw new Error('Secret key required for signing');
     }
+    requirePk(signerPk) {
+        const pk = signerPk || this.signerPk;
+        if (!pk) {
+            throw new Error('Signer public key required. Provide key or initialize builder with private key.');
+        }
+        return pk;
+    }
+    // ========================================================================
+    // ABI-driven contract API
+    // ========================================================================
     /**
-     * Sign an unsigned transaction
+     * Get a typed, signer-bound contract interface from an ABI definition.
      *
-     * @param unsignedTx - Unsigned transaction with hash
-     * @param signerSk - Optional signer's secret key (required if instance has no private key)
-     * @returns Transaction hash and packed transaction
+     * Each ABI function becomes a method that builds and signs in one step,
+     * returning `BuildTransactionResult` directly.
+     *
+     * @param abi - An ABI definition object (declared `as const`)
+     * @returns A `SignedContract<TAbi>` with typed methods for each ABI function
      *
      * @example
      * ```ts
      * const builder = new TransactionBuilder('5Kd3N...')
-     * const unsignedTx = builder.build('Coin', 'transfer', args)
-     * const { txHash, txPacked } = builder.sign(unsignedTx)
+     *
+     * // LockupPrime — all methods auto-detected from ABI:
+     * const result = builder.contract(LOCKUP_PRIME_ABI).lock({
+     *   amount: toAtomicAma(100).toString(),
+     *   tier: '30d'
+     * })
+     *
+     * builder.contract(LOCKUP_PRIME_ABI).unlock({ vaultIndex: '3' })
+     * builder.contract(LOCKUP_PRIME_ABI).daily_checkin({ vaultIndex: '7' })
+     *
+     * // Lockup:
+     * builder.contract(LOCKUP_ABI).unlock({ vaultIndex: '5' })
+     *
+     * // Any future contract — just pass its ABI:
+     * builder.contract(SOME_NEW_ABI).someFunction({ param: 'value' })
      * ```
      */
-    sign(unsignedTx, signerSk) {
-        const sk = this.getSignerSk(signerSk);
-        return TransactionBuilder.signTransaction(unsignedTx, sk);
+    contract(abi) {
+        if (!this.privateKey) {
+            throw new Error('Private key required. Initialize builder with private key.');
+        }
+        return createContract(abi).connect(this.privateKey);
     }
+    // ========================================================================
+    // ContractCall-based API
+    // ========================================================================
     /**
-     * Build and sign a generic transaction (convenience method)
+     * Derive keys from a Base58 private key and sign a ContractCall.
      *
-     * @param contract - Contract name
-     * @param method - Method name
-     * @param args - Method arguments
-     * @param signerPk - Optional signer's public key (required if instance has no private key)
-     * @param signerSk - Optional signer's secret key (required if instance has no private key)
+     * @param senderPrivkey - Base58 encoded private key (seed)
+     * @param call - A ContractCall from createContract(), buildContractCall(), or buildCoinTransfer()
      * @returns Transaction hash and packed transaction
      *
      * @example
      * ```ts
-     * const builder = new TransactionBuilder('5Kd3N...')
-     * const { txHash, txPacked } = builder.buildAndSign('Coin', 'transfer', [
-     *   recipientBytes,
-     *   '1000000000',
-     *   'AMA'
-     * ])
+     * const lockupPrime = createContract(LOCKUP_PRIME_ABI)
+     * const call = lockupPrime.lock({ amount: '100000000000', tier: '30d' })
+     * const { txHash, txPacked } = TransactionBuilder.signCall('5Kd3N...', call)
      * ```
      */
+    static signCall(senderPrivkey, call) {
+        return signContractCall(senderPrivkey, call);
+    }
+    /**
+     * Build an unsigned transaction from a ContractCall (static)
+     */
+    static buildFromCall(call, signerPk) {
+        return buildUnsignedFromCall(signerPk, call);
+    }
+    /**
+     * Build and sign a transaction from a ContractCall (static)
+     */
+    static buildAndSignCall(signerPk, signerSk, call) {
+        return buildAndSignRaw(signerPk, signerSk, call.contract, call.method, call.args);
+    }
+    /**
+     * Build an unsigned transaction from a ContractCall (instance)
+     */
+    buildFromCall(call) {
+        return buildUnsignedFromCall(this.requirePk(), call);
+    }
+    /**
+     * Build and sign a transaction from a ContractCall (instance)
+     */
+    buildAndSignCall(call) {
+        const pk = this.requirePk();
+        const sk = this.getSignerSk();
+        return buildAndSignRaw(pk, sk, call.contract, call.method, call.args);
+    }
+    // ========================================================================
+    // Generic build/sign methods
+    // ========================================================================
+    /**
+     * Build an unsigned transaction (instance)
+     */
+    build(contract, method, args, signerPk) {
+        return buildUnsigned(this.requirePk(signerPk), contract, method, args);
+    }
+    /**
+     * Sign an unsigned transaction (instance)
+     */
+    sign(unsignedTx, signerSk) {
+        return signUnsigned(unsignedTx, this.getSignerSk(signerSk));
+    }
+    /**
+     * Build and sign a generic transaction (instance)
+     */
     buildAndSign(contract, method, args, signerPk, signerSk) {
-        const pk = signerPk || this.signerPk;
-        if (!pk) {
-            throw new Error('Signer public key required. Provide key or initialize builder with private key.');
-        }
+        const pk = this.requirePk(signerPk);
         const sk = this.getSignerSk(signerSk);
-        return TransactionBuilder.buildAndSignTransaction(pk, sk, contract, method, args);
+        return buildAndSignRaw(pk, sk, contract, method, args);
     }
     /**
-     * Build an unsigned transfer transaction
-     *
-     * @param input - Transfer transaction parameters
-     * @returns Unsigned transaction with hash
-     *
-     * @example
-     * ```ts
-     * const builder = new TransactionBuilder('5Kd3N...')
-     * const unsignedTx = builder.buildTransfer({
-     *   recipient: '5Kd3N...',
-     *   amount: 10.5,
-     *   symbol: 'AMA'
-     * })
-     * ```
+     * Build an unsigned transaction (static)
+     */
+    static build(signerPk, contract, method, args) {
+        return buildUnsigned(signerPk, contract, method, args);
+    }
+    /**
+     * Sign an unsigned transaction (static)
+     */
+    static sign(unsignedTx, signerSk) {
+        return signUnsigned(unsignedTx, signerSk);
+    }
+    /**
+     * Build and sign a generic transaction (static)
+     */
+    static buildAndSign(signerPk, signerSk, contract, method, args) {
+        return buildAndSignRaw(signerPk, signerSk, contract, method, args);
+    }
+    // ========================================================================
+    // Coin transfer (instance)
+    // ========================================================================
+    /**
+     * Build an unsigned Coin transfer transaction
      */
     buildTransfer(input) {
-        if (!this.signerPk) {
-            throw new Error('Public key required. Initialize builder with private key or provide signerPk.');
-        }
-        return this.build('Coin', 'transfer', [
-            fromBase58(input.recipient),
-            toAtomicAma(input.amount).toString(),
-            input.symbol
-        ]);
+        return this.buildFromCall(buildCoinTransfer(input));
     }
     /**
-     * Build and sign a transfer transaction (convenience method)
-     *
-     * @param input - Transfer transaction parameters
-     * @returns Transaction hash and packed transaction
-     *
-     * @example
-     * ```ts
-     * const builder = new TransactionBuilder('5Kd3N...')
-     * const { txHash, txPacked } = builder.transfer({
-     *   recipient: '5Kd3N...',
-     *   amount: 10.5,
-     *   symbol: 'AMA'
-     * })
-     * ```
+     * Build and sign a Coin transfer transaction
      */
     transfer(input) {
         if (!this.privateKey) {
             throw new Error('Private key required. Initialize builder with private key or use static method.');
         }
-        return this.buildAndSign('Coin', 'transfer', [
-            fromBase58(input.recipient),
-            toAtomicAma(input.amount).toString(),
-            input.symbol
-        ]);
+        return this.buildAndSignCall(buildCoinTransfer(input));
     }
+    // ========================================================================
+    // Coin transfer (static)
+    // ========================================================================
     /**
-     * Build an unsigned transfer transaction (static method)
-     *
-     * @param input - Transfer transaction parameters (without senderPrivkey)
-     * @param signerPk - Signer's public key
-     * @returns Unsigned transaction with hash
-     *
-     * @example
-     * ```ts
-     * const unsignedTx = TransactionBuilder.buildTransfer(
-     *   { recipient: '5Kd3N...', amount: 10.5, symbol: 'AMA' },
-     *   publicKey
-     * )
-     * ```
+     * Build an unsigned Coin transfer transaction (static)
      */
     static buildTransfer(input, signerPk) {
-        return TransactionBuilder.buildUnsignedTransaction(signerPk, 'Coin', 'transfer', [
-            fromBase58(input.recipient),
-            toAtomicAma(input.amount).toString(),
-            input.symbol
-        ]);
+        return TransactionBuilder.buildFromCall(buildCoinTransfer(input), signerPk);
     }
     /**
-     * Build and sign a transfer transaction (static method)
-     *
-     * @param input - Transfer transaction parameters
-     * @returns Transaction hash and packed transaction
-     *
-     * @example
-     * ```ts
-     * const { txHash, txPacked } = TransactionBuilder.buildSignedTransfer({
-     *   senderPrivkey: '5Kd3N...',
-     *   recipient: '5Kd3N...',
-     *   amount: 10.5,
-     *   symbol: 'AMA'
-     * })
-     * ```
+     * Build and sign a Coin transfer transaction (static)
      */
     static buildSignedTransfer(input) {
-        const { seed64, sk } = deriveSkAndSeed64FromBase58Seed(input.senderPrivkey);
-        const signerPubKey = getPublicKey(seed64);
-        return TransactionBuilder.buildAndSignTransaction(signerPubKey, sk, 'Coin', 'transfer', [
-            fromBase58(input.recipient),
-            toAtomicAma(input.amount).toString(),
-            input.symbol
-        ]);
+        return TransactionBuilder.signCall(input.senderPrivkey, buildCoinTransfer({ recipient: input.recipient, amount: input.amount, symbol: input.symbol }));
     }
+    // ========================================================================
+    // LockupPrime (instance)
+    // ========================================================================
     /**
-     * Build an unsigned transaction (static method)
-     *
-     * @param signerPk - Signer's public key
-     * @param contract - Contract name
-     * @param method - Method name
-     * @param args - Method arguments
-     * @returns Unsigned transaction with hash
-     *
-     * @example
-     * ```ts
-     * const unsignedTx = TransactionBuilder.build(
-     *   publicKey,
-     *   'Coin',
-     *   'transfer',
-     *   [recipientBytes, amount, 'AMA']
-     * )
-     * ```
+     * Build and sign a LockupPrime lock transaction
      */
-    static build(signerPk, contract, method, args) {
-        return TransactionBuilder.buildUnsignedTransaction(signerPk, contract, method, args);
+    lockupPrimeLock(input) {
+        return this.contract(LOCKUP_PRIME_ABI).lock({
+            amount: toAtomicAma(input.amount).toString(),
+            tier: input.tier
+        });
     }
     /**
-     * Sign an unsigned transaction (static method)
-     *
-     * @param unsignedTx - Unsigned transaction with hash
-     * @param signerSk - Signer's secret key
-     * @returns Transaction hash and packed transaction
-     *
-     * @example
-     * ```ts
-     * const unsignedTx = TransactionBuilder.build(publicKey, 'Coin', 'transfer', args)
-     * const { txHash, txPacked } = TransactionBuilder.sign(unsignedTx, secretKey)
-     * ```
+     * Build and sign a LockupPrime unlock transaction
      */
-    static sign(unsignedTx, signerSk) {
-        return TransactionBuilder.signTransaction(unsignedTx, signerSk);
+    lockupPrimeUnlock(input) {
+        return this.contract(LOCKUP_PRIME_ABI).unlock({
+            vaultIndex: input.vaultIndex.toString()
+        });
     }
     /**
-     * Build and sign a generic transaction (static method)
-     *
-     * @param signerPk - Signer's public key
-     * @param signerSk - Signer's secret key
-     * @param contract - Contract name
-     * @param method - Method name
-     * @param args - Method arguments
-     * @returns Transaction hash and packed transaction
-     *
-     * @example
-     * ```ts
-     * const { txHash, txPacked } = TransactionBuilder.buildAndSign(
-     *   publicKey,
-     *   secretKey,
-     *   'Coin',
-     *   'transfer',
-     *   [recipientBytes, amount, 'AMA']
-     * )
-     * ```
+     * Build and sign a LockupPrime daily check-in transaction
      */
-    static buildAndSign(signerPk, signerSk, contract, method, args) {
-        return TransactionBuilder.buildAndSignTransaction(signerPk, signerSk, contract, method, args);
+    lockupPrimeDailyCheckin(input) {
+        return this.contract(LOCKUP_PRIME_ABI).daily_checkin({
+            vaultIndex: input.vaultIndex.toString()
+        });
+    }
+    // ========================================================================
+    // Lockup (instance)
+    // ========================================================================
+    /**
+     * Build and sign a Lockup unlock transaction
+     */
+    lockupUnlock(input) {
+        return this.contract(LOCKUP_ABI).unlock({
+            vaultIndex: input.vaultIndex.toString()
+        });
+    }
+    // ========================================================================
+    // LockupPrime (static)
+    // ========================================================================
+    /**
+     * Build and sign a LockupPrime lock transaction (static)
+     */
+    static buildSignedLockupPrimeLock(input) {
+        const call = createContract(LOCKUP_PRIME_ABI).lock({
+            amount: toAtomicAma(input.amount).toString(),
+            tier: input.tier
+        });
+        return TransactionBuilder.signCall(input.senderPrivkey, call);
+    }
+    /**
+     * Build and sign a LockupPrime unlock transaction (static)
+     */
+    static buildSignedLockupPrimeUnlock(input) {
+        const call = createContract(LOCKUP_PRIME_ABI).unlock({
+            vaultIndex: input.vaultIndex.toString()
+        });
+        return TransactionBuilder.signCall(input.senderPrivkey, call);
+    }
+    /**
+     * Build and sign a LockupPrime daily check-in transaction (static)
+     */
+    static buildSignedLockupPrimeDailyCheckin(input) {
+        const call = createContract(LOCKUP_PRIME_ABI).daily_checkin({
+            vaultIndex: input.vaultIndex.toString()
+        });
+        return TransactionBuilder.signCall(input.senderPrivkey, call);
+    }
+    // ========================================================================
+    // Lockup (static)
+    // ========================================================================
+    /**
+     * Build and sign a Lockup unlock transaction (static)
+     */
+    static buildSignedLockupUnlock(input) {
+        const call = createContract(LOCKUP_ABI).unlock({
+            vaultIndex: input.vaultIndex.toString()
+        });
+        return TransactionBuilder.signCall(input.senderPrivkey, call);
     }
 }
 //# sourceMappingURL=transaction-builder.js.map