@ottochain/sdk 1.2.0 → 1.4.0

package/dist/cjs/metakit/wallet.js

@@ -1,127 +0,0 @@
-"use strict";
-/**
- * Wallet and Key Management Utilities
- *
- * Functions for generating and managing cryptographic keys.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidPublicKey = exports.isValidPrivateKey = exports.getAddress = exports.getPublicKeyId = exports.getPublicKeyHex = exports.keyPairFromPrivateKey = exports.generateKeyPair = void 0;
-const dag4_1 = require("@stardust-collective/dag4");
-/**
- * Generate a new random key pair
- *
- * @returns KeyPair with private key, public key, and DAG address
- *
- * @example
- * ```typescript
- * const keyPair = generateKeyPair();
- * console.log(keyPair.address);    // DAG address
- * console.log(keyPair.privateKey); // 64 char hex
- * console.log(keyPair.publicKey);  // 130 char hex (with 04 prefix)
- * ```
- */
-function generateKeyPair() {
-    const privateKey = dag4_1.dag4.keyStore.generatePrivateKey();
-    return keyPairFromPrivateKey(privateKey);
-}
-exports.generateKeyPair = generateKeyPair;
-/**
- * Derive a key pair from an existing private key
- *
- * @param privateKey - Private key in hex format (64 characters)
- * @returns KeyPair with private key, public key, and DAG address
- *
- * @example
- * ```typescript
- * const keyPair = keyPairFromPrivateKey(existingPrivateKey);
- * ```
- */
-function keyPairFromPrivateKey(privateKey) {
-    // Get uncompressed public key (with 04 prefix)
-    const publicKey = dag4_1.dag4.keyStore.getPublicKeyFromPrivate(privateKey, false);
-    // Derive DAG address
-    const address = dag4_1.dag4.keyStore.getDagAddressFromPublicKey(publicKey);
-    return {
-        privateKey,
-        publicKey: normalizePublicKey(publicKey),
-        address,
-    };
-}
-exports.keyPairFromPrivateKey = keyPairFromPrivateKey;
-/**
- * Get the public key hex from a private key
- *
- * @param privateKey - Private key in hex format
- * @param compressed - If true, returns compressed public key (33 bytes)
- * @returns Public key in hex format
- */
-function getPublicKeyHex(privateKey, compressed = false) {
-    return dag4_1.dag4.keyStore.getPublicKeyFromPrivate(privateKey, compressed);
-}
-exports.getPublicKeyHex = getPublicKeyHex;
-/**
- * Get the public key ID (without 04 prefix) from a private key
- *
- * This format is used in SignatureProof.id
- *
- * @param privateKey - Private key in hex format
- * @returns Public key ID (128 characters, no 04 prefix)
- */
-function getPublicKeyId(privateKey) {
-    const publicKey = dag4_1.dag4.keyStore.getPublicKeyFromPrivate(privateKey, false);
-    // Remove 04 prefix if present
-    if (publicKey.length === 130 && publicKey.startsWith('04')) {
-        return publicKey.substring(2);
-    }
-    return publicKey;
-}
-exports.getPublicKeyId = getPublicKeyId;
-/**
- * Get DAG address from a public key
- *
- * @param publicKey - Public key in hex format (with or without 04 prefix)
- * @returns DAG address string
- */
-function getAddress(publicKey) {
-    const normalizedKey = normalizePublicKey(publicKey);
-    return dag4_1.dag4.keyStore.getDagAddressFromPublicKey(normalizedKey);
-}
-exports.getAddress = getAddress;
-/**
- * Validate that a private key is correctly formatted
- *
- * @param privateKey - Private key to validate
- * @returns true if valid hex string of correct length
- */
-function isValidPrivateKey(privateKey) {
-    if (typeof privateKey !== 'string')
-        return false;
-    if (privateKey.length !== 64)
-        return false;
-    return /^[0-9a-fA-F]+$/.test(privateKey);
-}
-exports.isValidPrivateKey = isValidPrivateKey;
-/**
- * Validate that a public key is correctly formatted
- *
- * @param publicKey - Public key to validate
- * @returns true if valid hex string of correct length
- */
-function isValidPublicKey(publicKey) {
-    if (typeof publicKey !== 'string')
-        return false;
-    // With 04 prefix: 130 chars, without: 128 chars
-    if (publicKey.length !== 128 && publicKey.length !== 130)
-        return false;
-    return /^[0-9a-fA-F]+$/.test(publicKey);
-}
-exports.isValidPublicKey = isValidPublicKey;
-/**
- * Normalize public key to include 04 prefix
- */
-function normalizePublicKey(publicKey) {
-    if (publicKey.length === 128) {
-        return '04' + publicKey;
-    }
-    return publicKey;
-}

package/dist/esm/metakit/binary.js

@@ -1,53 +0,0 @@
-/**
- * Binary Encoding
- *
- * Converts JSON data to binary format for cryptographic operations.
- * Supports both regular encoding and DataUpdate encoding with Constellation prefix.
- */
-import { canonicalize } from './canonicalize.js';
-import { CONSTELLATION_PREFIX } from './types.js';
-/**
- * Convert data to binary bytes for signing
- *
- * For regular data:
- *   JSON -> RFC 8785 canonicalization -> UTF-8 bytes
- *
- * For DataUpdate (isDataUpdate=true):
- *   JSON -> RFC 8785 -> UTF-8 -> Base64 -> prepend Constellation prefix -> UTF-8 bytes
- *
- * @param data - Any JSON-serializable object
- * @param isDataUpdate - If true, applies DataUpdate encoding with Constellation prefix
- * @returns Binary bytes as Uint8Array
- *
- * @example
- * ```typescript
- * // Regular encoding
- * const bytes = toBytes({ action: 'test' });
- *
- * // DataUpdate encoding
- * const updateBytes = toBytes({ action: 'test' }, true);
- * ```
- */
-export function toBytes(data, isDataUpdate = false) {
-    const canonicalJson = canonicalize(data);
-    const utf8Bytes = new TextEncoder().encode(canonicalJson);
-    if (isDataUpdate) {
-        // Base64 encode the UTF-8 bytes
-        const base64String = Buffer.from(utf8Bytes).toString('base64');
-        // Create the wrapped string with Constellation prefix
-        const wrappedString = `${CONSTELLATION_PREFIX}${base64String.length}\n${base64String}`;
-        return new TextEncoder().encode(wrappedString);
-    }
-    return utf8Bytes;
-}
-/**
- * Encode data as a DataUpdate with Constellation prefix
- *
- * This is equivalent to `toBytes(data, true)`.
- *
- * @param data - Any JSON-serializable object
- * @returns Binary bytes with Constellation prefix
- */
-export function encodeDataUpdate(data) {
-    return toBytes(data, true);
-}

package/dist/esm/metakit/canonicalize.js

@@ -1,33 +0,0 @@
-/**
- * RFC 8785 JSON Canonicalization
- *
- * Provides deterministic JSON serialization according to RFC 8785.
- * This ensures identical JSON objects always produce identical strings.
- */
-import canonicalizeLib from 'canonicalize';
-/**
- * Canonicalize JSON data according to RFC 8785
- *
- * Key features:
- * - Object keys sorted by UTF-16BE binary comparison
- * - Numbers serialized in shortest decimal representation
- * - No whitespace
- * - Proper Unicode escaping
- *
- * @param data - Any JSON-serializable object
- * @returns Canonical JSON string
- * @throws Error if data cannot be serialized to JSON
- *
- * @example
- * ```typescript
- * const canonical = canonicalize({ b: 2, a: 1 });
- * // Returns: '{"a":1,"b":2}'
- * ```
- */
-export function canonicalize(data) {
-    const result = canonicalizeLib(data);
-    if (result === undefined) {
-        throw new Error('Failed to canonicalize data: data cannot be serialized to JSON');
-    }
-    return result;
-}

package/dist/esm/metakit/codec.js

@@ -1,38 +0,0 @@
-/**
- * Codec Utilities
- *
- * Encoding/decoding utilities for the Constellation signature protocol.
- * Re-exports from binary.ts for backwards compatibility and provides additional utilities.
- */
-export { toBytes, encodeDataUpdate } from './binary.js';
-export { CONSTELLATION_PREFIX } from './types.js';
-/**
- * Decode a DataUpdate encoded message back to its original JSON
- *
- * @param bytes - DataUpdate encoded bytes
- * @returns Decoded JSON object
- * @throws Error if bytes are not valid DataUpdate encoding
- */
-export function decodeDataUpdate(bytes) {
-    const text = new TextDecoder().decode(bytes);
-    // Validate prefix
-    if (!text.startsWith('\x19Constellation Signed Data:\n')) {
-        throw new Error('Invalid DataUpdate encoding: missing Constellation prefix');
-    }
-    // Parse the format: \x19Constellation Signed Data:\n{length}\n{base64}
-    const withoutPrefix = text.slice('\x19Constellation Signed Data:\n'.length);
-    const newlineIndex = withoutPrefix.indexOf('\n');
-    if (newlineIndex === -1) {
-        throw new Error('Invalid DataUpdate encoding: missing length delimiter');
-    }
-    const lengthStr = withoutPrefix.slice(0, newlineIndex);
-    const base64Data = withoutPrefix.slice(newlineIndex + 1);
-    const expectedLength = parseInt(lengthStr, 10);
-    if (isNaN(expectedLength) || base64Data.length !== expectedLength) {
-        throw new Error('Invalid DataUpdate encoding: length mismatch');
-    }
-    // Decode base64 to UTF-8 JSON
-    const jsonBytes = Buffer.from(base64Data, 'base64');
-    const jsonString = new TextDecoder().decode(jsonBytes);
-    return JSON.parse(jsonString);
-}

package/dist/esm/metakit/currency-transaction.js

@@ -1,306 +0,0 @@
-/**
- * Currency transaction operations for metagraph token transfers
- *
- * @packageDocumentation
- */
-import { TransactionV2, txEncode, keyStore, } from '@stardust-collective/dag4-keystore';
-import { TOKEN_DECIMALS } from './currency-types.js';
-import { getAddress } from './wallet.js';
-import { normalizeSignatureToLowS } from './verify.js';
-/**
- * Convert token amount to smallest units
- *
- * @param amount - Amount in token units (e.g., 100.5)
- * @returns Amount in smallest units (1e-8)
- *
- * @example
- * ```typescript
- * const units = tokenToUnits(100.5); // 10050000000
- * ```
- */
-export function tokenToUnits(amount) {
-    return Math.floor(amount * 1e8);
-}
-/**
- * Convert smallest units to token amount
- *
- * @param units - Amount in smallest units
- * @returns Amount in token units
- *
- * @example
- * ```typescript
- * const tokens = unitsToToken(10050000000); // 100.5
- * ```
- */
-export function unitsToToken(units) {
-    return units * TOKEN_DECIMALS;
-}
-/**
- * Validate DAG address format
- *
- * @param address - DAG address to validate
- * @returns True if address is valid
- *
- * @example
- * ```typescript
- * const valid = isValidDagAddress('DAG...');
- * ```
- */
-export function isValidDagAddress(address) {
-    return keyStore.validateDagAddress(address);
-}
-/**
- * Create a metagraph token transaction
- *
- * @param params - Transfer parameters
- * @param privateKey - Private key to sign with (hex string)
- * @param lastRef - Reference to last accepted transaction
- * @returns Signed currency transaction
- *
- * @throws If addresses are invalid or amount is too small
- *
- * @example
- * ```typescript
- * const tx = await createCurrencyTransaction(
- *   { destination: 'DAG...', amount: 100.5, fee: 0 },
- *   privateKey,
- *   { hash: 'abc123...', ordinal: 5 }
- * );
- * ```
- */
-export async function createCurrencyTransaction(params, privateKey, lastRef) {
-    // Get source address from private key
-    const publicKey = keyStore.getPublicKeyFromPrivate(privateKey);
-    const source = getAddress(publicKey);
-    // Validate addresses
-    if (!isValidDagAddress(source)) {
-        throw new Error('Invalid source address');
-    }
-    if (!isValidDagAddress(params.destination)) {
-        throw new Error('Invalid destination address');
-    }
-    if (source === params.destination) {
-        throw new Error('Source and destination addresses cannot be the same');
-    }
-    // Convert amounts to smallest units
-    const amount = tokenToUnits(params.amount);
-    const fee = tokenToUnits(params.fee ?? 0);
-    // Validate amounts
-    if (amount < 1) {
-        throw new Error('Transfer amount must be greater than 1e-8');
-    }
-    if (fee < 0) {
-        throw new Error('Fee must be greater than or equal to zero');
-    }
-    // Use dag4.js TransactionV2 to create and encode the transaction
-    const txProps = {
-        fromAddress: source,
-        toAddress: params.destination,
-        amount,
-        fee,
-        lastTxRef: lastRef,
-    };
-    const tx = new TransactionV2(txProps);
-    // Get encoded transaction for hashing
-    const encodedTx = tx.getEncoded();
-    // Kryo serialize - v2 uses setReferences = false (matching dag4.js behavior)
-    const serializedTx = txEncode.kryoSerialize(encodedTx, false);
-    // Hash the serialized transaction
-    const hash = keyStore.sha256(Buffer.from(serializedTx, 'hex'));
-    // Sign the hash
-    const signature = await keyStore.sign(privateKey, hash);
-    // Get uncompressed public key
-    const uncompressedPublicKey = publicKey.length === 128 ? '04' + publicKey : publicKey;
-    // Verify signature
-    const success = keyStore.verify(uncompressedPublicKey, hash, signature);
-    if (!success) {
-        throw new Error('Sign-Verify failed');
-    }
-    // Add signature proof (remove '04' prefix from public key)
-    const proof = {
-        id: uncompressedPublicKey.substring(2),
-        signature,
-    };
-    tx.addSignature(proof);
-    return tx.getPostTransaction();
-}
-/**
- * Create multiple metagraph token transactions (batch)
- *
- * @param transfers - Array of transfer parameters
- * @param privateKey - Private key to sign with
- * @param lastRef - Reference to last accepted transaction
- * @returns Array of signed currency transactions
- *
- * @throws If any address is invalid or amount is too small
- *
- * @example
- * ```typescript
- * const txns = await createCurrencyTransactionBatch(
- *   [
- *     { destination: 'DAG...1', amount: 10 },
- *     { destination: 'DAG...2', amount: 20 },
- *   ],
- *   privateKey,
- *   { hash: 'abc123...', ordinal: 5 }
- * );
- * ```
- */
-export async function createCurrencyTransactionBatch(transfers, privateKey, lastRef) {
-    const transactions = [];
-    let currentRef = { ...lastRef };
-    for (const transfer of transfers) {
-        const tx = await createCurrencyTransaction(transfer, privateKey, currentRef);
-        // Calculate hash for next transaction's parent reference
-        const hash = await hashCurrencyTransaction(tx);
-        // Update reference for next transaction
-        currentRef = {
-            hash: hash.value,
-            ordinal: currentRef.ordinal + 1,
-        };
-        transactions.push(tx);
-    }
-    return transactions;
-}
-/**
- * Add a signature to an existing currency transaction (for multi-sig)
- *
- * @param transaction - Transaction to sign
- * @param privateKey - Private key to sign with
- * @returns Transaction with additional signature
- *
- * @throws If sign-verify fails
- *
- * @example
- * ```typescript
- * const signedTx = await signCurrencyTransaction(tx, privateKey2);
- * ```
- */
-export async function signCurrencyTransaction(transaction, privateKey) {
-    // Reconstruct TransactionV2 from PostTransaction
-    const tx = TransactionV2.fromPostTransaction(transaction);
-    // Restore existing proofs (fromPostTransaction doesn't copy them)
-    for (const existingProof of transaction.proofs) {
-        tx.addSignature(existingProof);
-    }
-    // Get encoded transaction
-    const encodedTx = tx.getEncoded();
-    // Kryo serialize - v2 uses setReferences = false (matching dag4.js behavior)
-    const serializedTx = txEncode.kryoSerialize(encodedTx, false);
-    const hash = keyStore.sha256(Buffer.from(serializedTx, 'hex'));
-    // Sign the hash
-    const publicKey = keyStore.getPublicKeyFromPrivate(privateKey);
-    const signature = await keyStore.sign(privateKey, hash);
-    // Verify signature
-    const uncompressedPublicKey = publicKey.length === 128 ? '04' + publicKey : publicKey;
-    const success = keyStore.verify(uncompressedPublicKey, hash, signature);
-    if (!success) {
-        throw new Error('Sign-Verify failed');
-    }
-    // Add new proof
-    const proof = {
-        id: uncompressedPublicKey.substring(2),
-        signature,
-    };
-    tx.addSignature(proof);
-    return tx.getPostTransaction();
-}
-/**
- * Verify all signatures on a currency transaction
- *
- * @param transaction - Transaction to verify
- * @returns Verification result with valid/invalid proofs
- *
- * @example
- * ```typescript
- * const result = await verifyCurrencyTransaction(tx);
- * console.log('Valid:', result.isValid);
- * ```
- */
-export async function verifyCurrencyTransaction(transaction) {
-    // Reconstruct TransactionV2 to get encoded form
-    const tx = TransactionV2.fromPostTransaction(transaction);
-    // Get hash
-    const encodedTx = tx.getEncoded();
-    // Kryo serialize - v2 uses setReferences = false (matching dag4.js behavior)
-    const serializedTx = txEncode.kryoSerialize(encodedTx, false);
-    const hash = keyStore.sha256(Buffer.from(serializedTx, 'hex'));
-    const validProofs = [];
-    const invalidProofs = [];
-    // Verify each proof
-    for (const proof of transaction.proofs) {
-        const publicKey = '04' + proof.id; // Add back the '04' prefix
-        // Normalize signature to low-S form for BIP 62/146 compatibility
-        const normalizedSignature = normalizeSignatureToLowS(proof.signature);
-        const isValid = keyStore.verify(publicKey, hash, normalizedSignature);
-        if (isValid) {
-            validProofs.push(proof);
-        }
-        else {
-            invalidProofs.push(proof);
-        }
-    }
-    return {
-        isValid: invalidProofs.length === 0 && validProofs.length > 0,
-        validProofs,
-        invalidProofs,
-    };
-}
-/**
- * Encode a currency transaction for hashing
- *
- * @param transaction - Transaction to encode
- * @returns Hex-encoded string
- *
- * @example
- * ```typescript
- * const encoded = encodeCurrencyTransaction(tx);
- * ```
- */
-export function encodeCurrencyTransaction(transaction) {
-    const tx = TransactionV2.fromPostTransaction(transaction);
-    return tx.getEncoded();
-}
-/**
- * Hash a currency transaction
- *
- * @param transaction - Transaction to hash
- * @returns Hash object with value and bytes
- *
- * @example
- * ```typescript
- * const hash = await hashCurrencyTransaction(tx);
- * console.log('Hash:', hash.value);
- * ```
- */
-export async function hashCurrencyTransaction(transaction) {
-    const encoded = encodeCurrencyTransaction(transaction);
-    // Kryo serialize - v2 uses setReferences = false (matching dag4.js behavior)
-    const serialized = txEncode.kryoSerialize(encoded, false);
-    const hash = keyStore.sha256(Buffer.from(serialized, 'hex'));
-    return {
-        value: hash,
-        bytes: Buffer.from(hash, 'hex'),
-    };
-}
-/**
- * Get transaction reference from a currency transaction
- * Useful for chaining transactions
- *
- * @param transaction - Transaction to extract reference from
- * @param ordinal - Ordinal number for this transaction
- * @returns Transaction reference
- *
- * @example
- * ```typescript
- * const ref = await getTransactionReference(tx, 6);
- * // Use ref as lastRef for next transaction
- * ```
- */
-export async function getTransactionReference(transaction, ordinal) {
-    const hash = await hashCurrencyTransaction(transaction);
-    return {
-        hash: hash.value,
-        ordinal,
-    };
-}

package/dist/esm/metakit/currency-types.js

@@ -1,10 +0,0 @@
-/**
- * Currency transaction types for metagraph token transfers
- *
- * @packageDocumentation
- */
-/**
- * Token decimals constant (1e-8)
- * Same as DAG_DECIMALS from dag4.js
- */
-export const TOKEN_DECIMALS = 1e-8;

package/dist/esm/metakit/hash.js

@@ -1,77 +0,0 @@
-/**
- * Hashing Utilities
- *
- * SHA-256 and SHA-512 hashing for the Constellation signature protocol.
- */
-import { sha256 } from 'js-sha256';
-import { sha512 } from 'js-sha512';
-import { toBytes } from './binary.js';
-/**
- * Compute SHA-256 hash of canonical JSON data
- *
- * @param data - Any JSON-serializable object
- * @returns Hash object with hex string and raw bytes
- *
- * @example
- * ```typescript
- * const hashResult = hash({ action: 'test' });
- * console.log(hashResult.value); // 64-char hex string
- * ```
- */
-export function hash(data) {
-    const bytes = toBytes(data, false);
-    return hashBytes(bytes);
-}
-/**
- * Compute SHA-256 hash of raw bytes
- *
- * @param bytes - Input bytes
- * @returns Hash object with hex string and raw bytes
- */
-export function hashBytes(bytes) {
-    const hashArray = sha256.array(bytes);
-    const hashUint8 = new Uint8Array(hashArray);
-    const hashHex = sha256.hex(bytes);
-    return {
-        value: hashHex,
-        bytes: hashUint8,
-    };
-}
-/**
- * Compute the full signing digest according to Constellation protocol
- *
- * Protocol:
- * 1. Serialize data to binary (with optional DataUpdate prefix)
- * 2. Compute SHA-256 hash
- * 3. Convert hash to hex string
- * 4. Treat hex string as UTF-8 bytes (NOT hex decode)
- * 5. Compute SHA-512 of those bytes
- * 6. Truncate to 32 bytes for secp256k1 signing
- *
- * @param data - Any JSON-serializable object
- * @param isDataUpdate - Whether to apply DataUpdate encoding
- * @returns 32-byte digest ready for ECDSA signing
- */
-export function computeDigest(data, isDataUpdate = false) {
-    // Step 1: Serialize to binary
-    const dataBytes = toBytes(data, isDataUpdate);
-    // Step 2: SHA-256 hash
-    const sha256Hash = hashBytes(dataBytes);
-    // Step 3-4: Hex string as UTF-8 bytes (critical: NOT hex decode)
-    const hexAsUtf8 = new TextEncoder().encode(sha256Hash.value);
-    // Step 5: SHA-512
-    const sha512Hash = sha512.array(hexAsUtf8);
-    // Step 6: Truncate to 32 bytes
-    return new Uint8Array(sha512Hash.slice(0, 32));
-}
-/**
- * Compute SHA-256 hash of data with optional DataUpdate encoding
- *
- * @param data - Any JSON-serializable object
- * @param isDataUpdate - Whether to apply DataUpdate encoding
- * @returns Hash object
- */
-export function hashData(data, isDataUpdate = false) {
-    const bytes = toBytes(data, isDataUpdate);
-    return hashBytes(bytes);
-}

package/dist/esm/metakit/index.js

@@ -1,33 +0,0 @@
-/**
- * Metakit SDK
- *
- * Reusable signing, encoding, and network operations for Constellation metagraphs.
- * This module is framework-level functionality, independent of any specific metagraph domain.
- *
- * @packageDocumentation
- */
-export { ALGORITHM, CONSTELLATION_PREFIX } from './types.js';
-// Canonicalization
-export { canonicalize } from './canonicalize.js';
-// Binary encoding
-export { toBytes, encodeDataUpdate } from './binary.js';
-// Hashing
-export { hash, hashBytes, hashData, computeDigest } from './hash.js';
-// Codec utilities
-export { decodeDataUpdate } from './codec.js';
-// Signing
-export { sign, signDataUpdate, signHash } from './sign.js';
-// Verification
-export { verify, verifyHash, verifySignature } from './verify.js';
-// High-level API
-export { createSignedObject, addSignature, batchSign } from './signed-object.js';
-// Wallet utilities
-export { generateKeyPair, keyPairFromPrivateKey, getPublicKeyHex, getPublicKeyId, getAddress, isValidPrivateKey, isValidPublicKey, } from './wallet.js';
-export { TOKEN_DECIMALS } from './currency-types.js';
-// Currency transaction operations
-export { createCurrencyTransaction, createCurrencyTransactionBatch, signCurrencyTransaction, verifyCurrencyTransaction, encodeCurrencyTransaction, hashCurrencyTransaction, getTransactionReference, isValidDagAddress, tokenToUnits, unitsToToken, } from './currency-transaction.js';
-// Network operations
-export { CurrencyL1Client, DataL1Client, HttpClient, NetworkError } from './network/index.js';
-// Transaction helpers for self-signed mode
-export { createTransitionPayload, createArchivePayload, createInvokeScriptPayload, signTransaction, addTransactionSignature, getPublicKeyForRegistration, } from './transaction.js';
-export { createStateMachinePayload, createScriptPayload, createDataTransactionRequest, } from './transaction.js';