@bitgo-beta/sdk-coin-tempo 1.0.1-beta.47 → 1.0.1-beta.49

package/dist/src/lib/transactionBuilder.d.ts

@@ -0,0 +1,100 @@
+/**
+ * TIP-20 Transaction Builder
+ *
+ * Unified builder for TIP-20 transactions supporting:
+ * - Single or batch operations
+ * - Per-operation memos for tracking
+ * - Custom fee token selection
+ * - EIP-7702 Account Abstraction (type 0x76)
+ */
+import { TransactionBuilder as AbstractTransactionBuilder, TransferBuilder } from '@bitgo-beta/abstract-eth';
+import { BaseTransaction } from '@bitgo-beta/sdk-core';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
+import { Address, Tip20Operation } from './types';
+/**
+ * Transaction Builder for TIP-20 tokens on Tempo blockchain
+ * Extends abstract-eth TransactionBuilder with Tempo-specific features
+ */
+export declare class Tip20TransactionBuilder extends AbstractTransactionBuilder {
+    private operations;
+    private _feeToken?;
+    private _nonce?;
+    private _gas?;
+    private _maxFeePerGas?;
+    private _maxPriorityFeePerGas?;
+    constructor(_coinConfig: Readonly<CoinConfig>);
+    /**
+     * Implement the transfer method from abstract class
+     * Note: For TIP-20 transactions, use addOperation() instead
+     */
+    transfer(data?: string, isFirstSigner?: boolean): TransferBuilder;
+    /**
+     * Build the transaction from configured TIP-20 operations and transaction parameters
+     */
+    protected buildImplementation(): Promise<BaseTransaction>;
+    /**
+     * Add a single operation to the transaction
+     * Can be called multiple times to create batch transactions
+     *
+     * @param operation - TIP-20 operation with token, recipient, amount, and optional memo
+     * @returns this builder instance for chaining
+     */
+    addOperation(operation: Tip20Operation): this;
+    /**
+     * Set which TIP-20 token will be used to pay transaction fees
+     * This is a global setting for the entire transaction
+     *
+     * @param tokenAddress - Address of the TIP-20 token to use for fees
+     * @returns this builder instance for chaining
+     */
+    feeToken(tokenAddress: string): this;
+    /**
+     * Set the transaction nonce
+     *
+     * @param nonce - Transaction nonce
+     * @returns this builder instance for chaining
+     */
+    nonce(nonce: number): this;
+    /**
+     * Set the gas limit for the transaction
+     *
+     * @param gas - Gas limit
+     * @returns this builder instance for chaining
+     */
+    gas(gas: string | bigint): this;
+    /**
+     * Set the maximum fee per gas (EIP-1559)
+     *
+     * @param maxFeePerGas - Maximum fee per gas in wei
+     * @returns this builder instance for chaining
+     */
+    maxFeePerGas(maxFeePerGas: string | bigint): this;
+    /**
+     * Set the maximum priority fee per gas (EIP-1559)
+     *
+     * @param maxPriorityFeePerGas - Maximum priority fee per gas in wei
+     * @returns this builder instance for chaining
+     */
+    maxPriorityFeePerGas(maxPriorityFeePerGas: string | bigint): this;
+    /**
+     * Get all operations in this transaction
+     * @returns Array of TIP-20 operations
+     */
+    getOperations(): Tip20Operation[];
+    /**
+     * Get the fee token address if set
+     * @returns Fee token address or undefined
+     */
+    getFeeToken(): Address | undefined;
+    /**
+     * Validate a single operation
+     * @param operation - Operation to validate
+     * @throws BuildTransactionError if invalid
+     */
+    private validateOperation;
+    /**
+     * Convert a TIP-20 operation to an AA call
+     */
+    private operationToCall;
+}
+//# sourceMappingURL=transactionBuilder.d.ts.map

package/dist/src/lib/transactionBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transactionBuilder.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EAAE,kBAAkB,IAAI,0BAA0B,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAC7G,OAAO,EAAE,eAAe,EAAyB,MAAM,sBAAsB,CAAC;AAC9E,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAC7D,OAAO,EAAE,OAAO,EAAO,cAAc,EAAE,MAAM,SAAS,CAAC;AAKvD;;;GAGG;AACH,qBAAa,uBAAwB,SAAQ,0BAA0B;IACrE,OAAO,CAAC,UAAU,CAAwB;IAC1C,OAAO,CAAC,SAAS,CAAC,CAAU;IAC5B,OAAO,CAAC,MAAM,CAAC,CAAS;IACxB,OAAO,CAAC,IAAI,CAAC,CAAS;IACtB,OAAO,CAAC,aAAa,CAAC,CAAS;IAC/B,OAAO,CAAC,qBAAqB,CAAC,CAAS;gBAE3B,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAI7C;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,OAAO,GAAG,eAAe;IASjE;;OAEG;cACa,mBAAmB,IAAI,OAAO,CAAC,eAAe,CAAC;IAsC/D;;;;;;OAMG;IACH,YAAY,CAAC,SAAS,EAAE,cAAc,GAAG,IAAI;IAM7C;;;;;;OAMG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI;IAQpC;;;;;OAKG;IACH,KAAK,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAQ1B;;;;;OAKG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IAS/B;;;;;OAKG;IACH,YAAY,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IASjD;;;;;OAKG;IACH,oBAAoB,CAAC,oBAAoB,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI;IASjE;;;OAGG;IACH,aAAa,IAAI,cAAc,EAAE;IAIjC;;;OAGG;IACH,WAAW,IAAI,OAAO,GAAG,SAAS;IAIlC;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;IAsBzB;;OAEG;IACH,OAAO,CAAC,eAAe;CAUxB"}

package/dist/src/lib/transactionBuilder.js

@@ -0,0 +1,204 @@
+"use strict";
+/**
+ * TIP-20 Transaction Builder
+ *
+ * Unified builder for TIP-20 transactions supporting:
+ * - Single or batch operations
+ * - Per-operation memos for tracking
+ * - Custom fee token selection
+ * - EIP-7702 Account Abstraction (type 0x76)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tip20TransactionBuilder = void 0;
+const abstract_eth_1 = require("@bitgo-beta/abstract-eth");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const transaction_1 = require("./transaction");
+const utils_1 = require("./utils");
+const constants_1 = require("./constants");
+/**
+ * Transaction Builder for TIP-20 tokens on Tempo blockchain
+ * Extends abstract-eth TransactionBuilder with Tempo-specific features
+ */
+class Tip20TransactionBuilder extends abstract_eth_1.TransactionBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this.operations = [];
+    }
+    /**
+     * Implement the transfer method from abstract class
+     * Note: For TIP-20 transactions, use addOperation() instead
+     */
+    transfer(data, isFirstSigner) {
+        const transferBuilder = new abstract_eth_1.TransferBuilder(undefined, isFirstSigner);
+        if (data) {
+            transferBuilder.data(data);
+        }
+        this._transfer = transferBuilder;
+        return transferBuilder;
+    }
+    /**
+     * Build the transaction from configured TIP-20 operations and transaction parameters
+     */
+    async buildImplementation() {
+        if (this.operations.length === 0) {
+            throw new sdk_core_1.BuildTransactionError('At least one operation is required to build a transaction');
+        }
+        if (this._nonce === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Nonce is required to build a transaction');
+        }
+        if (this._gas === undefined) {
+            throw new sdk_core_1.BuildTransactionError('Gas limit is required to build a transaction');
+        }
+        if (this._maxFeePerGas === undefined) {
+            throw new sdk_core_1.BuildTransactionError('maxFeePerGas is required to build a transaction');
+        }
+        if (this._maxPriorityFeePerGas === undefined) {
+            throw new sdk_core_1.BuildTransactionError('maxPriorityFeePerGas is required to build a transaction');
+        }
+        const calls = this.operations.map((op) => this.operationToCall(op));
+        const txRequest = {
+            type: constants_1.AA_TRANSACTION_TYPE,
+            chainId: this._common.chainIdBN().toNumber(),
+            nonce: this._nonce,
+            maxFeePerGas: this._maxFeePerGas,
+            maxPriorityFeePerGas: this._maxPriorityFeePerGas,
+            gas: this._gas,
+            calls,
+            accessList: [],
+            feeToken: this._feeToken,
+        };
+        return new transaction_1.Tip20Transaction(this._coinConfig, txRequest, this.operations);
+    }
+    /**
+     * Add a single operation to the transaction
+     * Can be called multiple times to create batch transactions
+     *
+     * @param operation - TIP-20 operation with token, recipient, amount, and optional memo
+     * @returns this builder instance for chaining
+     */
+    addOperation(operation) {
+        this.validateOperation(operation);
+        this.operations.push(operation);
+        return this;
+    }
+    /**
+     * Set which TIP-20 token will be used to pay transaction fees
+     * This is a global setting for the entire transaction
+     *
+     * @param tokenAddress - Address of the TIP-20 token to use for fees
+     * @returns this builder instance for chaining
+     */
+    feeToken(tokenAddress) {
+        if (!(0, utils_1.isValidAddress)(tokenAddress)) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid fee token address: ${tokenAddress}`);
+        }
+        this._feeToken = tokenAddress;
+        return this;
+    }
+    /**
+     * Set the transaction nonce
+     *
+     * @param nonce - Transaction nonce
+     * @returns this builder instance for chaining
+     */
+    nonce(nonce) {
+        if (nonce < 0) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid nonce: ${nonce}`);
+        }
+        this._nonce = nonce;
+        return this;
+    }
+    /**
+     * Set the gas limit for the transaction
+     *
+     * @param gas - Gas limit
+     * @returns this builder instance for chaining
+     */
+    gas(gas) {
+        const gasValue = typeof gas === 'string' ? BigInt(gas) : gas;
+        if (gasValue <= 0n) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid gas limit: ${gas}`);
+        }
+        this._gas = gasValue;
+        return this;
+    }
+    /**
+     * Set the maximum fee per gas (EIP-1559)
+     *
+     * @param maxFeePerGas - Maximum fee per gas in wei
+     * @returns this builder instance for chaining
+     */
+    maxFeePerGas(maxFeePerGas) {
+        const feeValue = typeof maxFeePerGas === 'string' ? BigInt(maxFeePerGas) : maxFeePerGas;
+        if (feeValue < 0n) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid maxFeePerGas: ${maxFeePerGas}`);
+        }
+        this._maxFeePerGas = feeValue;
+        return this;
+    }
+    /**
+     * Set the maximum priority fee per gas (EIP-1559)
+     *
+     * @param maxPriorityFeePerGas - Maximum priority fee per gas in wei
+     * @returns this builder instance for chaining
+     */
+    maxPriorityFeePerGas(maxPriorityFeePerGas) {
+        const feeValue = typeof maxPriorityFeePerGas === 'string' ? BigInt(maxPriorityFeePerGas) : maxPriorityFeePerGas;
+        if (feeValue < 0n) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid maxPriorityFeePerGas: ${maxPriorityFeePerGas}`);
+        }
+        this._maxPriorityFeePerGas = feeValue;
+        return this;
+    }
+    /**
+     * Get all operations in this transaction
+     * @returns Array of TIP-20 operations
+     */
+    getOperations() {
+        return [...this.operations];
+    }
+    /**
+     * Get the fee token address if set
+     * @returns Fee token address or undefined
+     */
+    getFeeToken() {
+        return this._feeToken;
+    }
+    /**
+     * Validate a single operation
+     * @param operation - Operation to validate
+     * @throws BuildTransactionError if invalid
+     */
+    validateOperation(operation) {
+        if (!(0, utils_1.isValidAddress)(operation.token)) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid token address: ${operation.token}`);
+        }
+        if (!(0, utils_1.isValidAddress)(operation.to)) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid recipient address: ${operation.to}`);
+        }
+        if (!(0, utils_1.isValidTip20Amount)(operation.amount)) {
+            throw new sdk_core_1.BuildTransactionError(`Invalid amount: ${operation.amount}`);
+        }
+        // Validate memo byte length (handles multi-byte UTF-8 characters)
+        if (operation.memo) {
+            const memoByteLength = new TextEncoder().encode(operation.memo).length;
+            if (memoByteLength > 32) {
+                throw new sdk_core_1.BuildTransactionError(`Memo too long: ${memoByteLength} bytes. Maximum 32 bytes.`);
+            }
+        }
+    }
+    /**
+     * Convert a TIP-20 operation to an AA call
+     */
+    operationToCall(op) {
+        const amountInUnits = (0, utils_1.amountToTip20Units)(op.amount);
+        const data = (0, utils_1.encodeTip20TransferWithMemo)(op.to, amountInUnits, op.memo);
+        return {
+            to: op.token,
+            data,
+            value: 0n,
+        };
+    }
+}
+exports.Tip20TransactionBuilder = Tip20TransactionBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transactionBuilder.js","sourceRoot":"","sources":["../../../src/lib/transactionBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * TIP-20 Transaction Builder\n *\n * Unified builder for TIP-20 transactions supporting:\n * - Single or batch operations\n * - Per-operation memos for tracking\n * - Custom fee token selection\n * - EIP-7702 Account Abstraction (type 0x76)\n */\n\nimport { TransactionBuilder as AbstractTransactionBuilder, TransferBuilder } from '@bitgo-beta/abstract-eth';\nimport { BaseTransaction, BuildTransactionError } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { Address, Hex, Tip20Operation } from './types';\nimport { Tip20Transaction, Tip20TransactionRequest } from './transaction';\nimport { amountToTip20Units, encodeTip20TransferWithMemo, isValidAddress, isValidTip20Amount } from './utils';\nimport { AA_TRANSACTION_TYPE } from './constants';\n\n/**\n * Transaction Builder for TIP-20 tokens on Tempo blockchain\n * Extends abstract-eth TransactionBuilder with Tempo-specific features\n */\nexport class Tip20TransactionBuilder extends AbstractTransactionBuilder {\n  private operations: Tip20Operation[] = [];\n  private _feeToken?: Address;\n  private _nonce?: number;\n  private _gas?: bigint;\n  private _maxFeePerGas?: bigint;\n  private _maxPriorityFeePerGas?: bigint;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n  }\n\n  /**\n   * Implement the transfer method from abstract class\n   * Note: For TIP-20 transactions, use addOperation() instead\n   */\n  transfer(data?: string, isFirstSigner?: boolean): TransferBuilder {\n    const transferBuilder = new TransferBuilder(undefined, isFirstSigner);\n    if (data) {\n      transferBuilder.data(data);\n    }\n    this._transfer = transferBuilder;\n    return transferBuilder;\n  }\n\n  /**\n   * Build the transaction from configured TIP-20 operations and transaction parameters\n   */\n  protected async buildImplementation(): Promise<BaseTransaction> {\n    if (this.operations.length === 0) {\n      throw new BuildTransactionError('At least one operation is required to build a transaction');\n    }\n\n    if (this._nonce === undefined) {\n      throw new BuildTransactionError('Nonce is required to build a transaction');\n    }\n\n    if (this._gas === undefined) {\n      throw new BuildTransactionError('Gas limit is required to build a transaction');\n    }\n\n    if (this._maxFeePerGas === undefined) {\n      throw new BuildTransactionError('maxFeePerGas is required to build a transaction');\n    }\n\n    if (this._maxPriorityFeePerGas === undefined) {\n      throw new BuildTransactionError('maxPriorityFeePerGas is required to build a transaction');\n    }\n\n    const calls = this.operations.map((op) => this.operationToCall(op));\n\n    const txRequest: Tip20TransactionRequest = {\n      type: AA_TRANSACTION_TYPE,\n      chainId: this._common.chainIdBN().toNumber(),\n      nonce: this._nonce,\n      maxFeePerGas: this._maxFeePerGas,\n      maxPriorityFeePerGas: this._maxPriorityFeePerGas,\n      gas: this._gas,\n      calls,\n      accessList: [],\n      feeToken: this._feeToken,\n    };\n\n    return new Tip20Transaction(this._coinConfig, txRequest, this.operations);\n  }\n\n  /**\n   * Add a single operation to the transaction\n   * Can be called multiple times to create batch transactions\n   *\n   * @param operation - TIP-20 operation with token, recipient, amount, and optional memo\n   * @returns this builder instance for chaining\n   */\n  addOperation(operation: Tip20Operation): this {\n    this.validateOperation(operation);\n    this.operations.push(operation);\n    return this;\n  }\n\n  /**\n   * Set which TIP-20 token will be used to pay transaction fees\n   * This is a global setting for the entire transaction\n   *\n   * @param tokenAddress - Address of the TIP-20 token to use for fees\n   * @returns this builder instance for chaining\n   */\n  feeToken(tokenAddress: string): this {\n    if (!isValidAddress(tokenAddress)) {\n      throw new BuildTransactionError(`Invalid fee token address: ${tokenAddress}`);\n    }\n    this._feeToken = tokenAddress as Address;\n    return this;\n  }\n\n  /**\n   * Set the transaction nonce\n   *\n   * @param nonce - Transaction nonce\n   * @returns this builder instance for chaining\n   */\n  nonce(nonce: number): this {\n    if (nonce < 0) {\n      throw new BuildTransactionError(`Invalid nonce: ${nonce}`);\n    }\n    this._nonce = nonce;\n    return this;\n  }\n\n  /**\n   * Set the gas limit for the transaction\n   *\n   * @param gas - Gas limit\n   * @returns this builder instance for chaining\n   */\n  gas(gas: string | bigint): this {\n    const gasValue = typeof gas === 'string' ? BigInt(gas) : gas;\n    if (gasValue <= 0n) {\n      throw new BuildTransactionError(`Invalid gas limit: ${gas}`);\n    }\n    this._gas = gasValue;\n    return this;\n  }\n\n  /**\n   * Set the maximum fee per gas (EIP-1559)\n   *\n   * @param maxFeePerGas - Maximum fee per gas in wei\n   * @returns this builder instance for chaining\n   */\n  maxFeePerGas(maxFeePerGas: string | bigint): this {\n    const feeValue = typeof maxFeePerGas === 'string' ? BigInt(maxFeePerGas) : maxFeePerGas;\n    if (feeValue < 0n) {\n      throw new BuildTransactionError(`Invalid maxFeePerGas: ${maxFeePerGas}`);\n    }\n    this._maxFeePerGas = feeValue;\n    return this;\n  }\n\n  /**\n   * Set the maximum priority fee per gas (EIP-1559)\n   *\n   * @param maxPriorityFeePerGas - Maximum priority fee per gas in wei\n   * @returns this builder instance for chaining\n   */\n  maxPriorityFeePerGas(maxPriorityFeePerGas: string | bigint): this {\n    const feeValue = typeof maxPriorityFeePerGas === 'string' ? BigInt(maxPriorityFeePerGas) : maxPriorityFeePerGas;\n    if (feeValue < 0n) {\n      throw new BuildTransactionError(`Invalid maxPriorityFeePerGas: ${maxPriorityFeePerGas}`);\n    }\n    this._maxPriorityFeePerGas = feeValue;\n    return this;\n  }\n\n  /**\n   * Get all operations in this transaction\n   * @returns Array of TIP-20 operations\n   */\n  getOperations(): Tip20Operation[] {\n    return [...this.operations];\n  }\n\n  /**\n   * Get the fee token address if set\n   * @returns Fee token address or undefined\n   */\n  getFeeToken(): Address | undefined {\n    return this._feeToken;\n  }\n\n  /**\n   * Validate a single operation\n   * @param operation - Operation to validate\n   * @throws BuildTransactionError if invalid\n   */\n  private validateOperation(operation: Tip20Operation): void {\n    if (!isValidAddress(operation.token)) {\n      throw new BuildTransactionError(`Invalid token address: ${operation.token}`);\n    }\n\n    if (!isValidAddress(operation.to)) {\n      throw new BuildTransactionError(`Invalid recipient address: ${operation.to}`);\n    }\n\n    if (!isValidTip20Amount(operation.amount)) {\n      throw new BuildTransactionError(`Invalid amount: ${operation.amount}`);\n    }\n\n    // Validate memo byte length (handles multi-byte UTF-8 characters)\n    if (operation.memo) {\n      const memoByteLength = new TextEncoder().encode(operation.memo).length;\n      if (memoByteLength > 32) {\n        throw new BuildTransactionError(`Memo too long: ${memoByteLength} bytes. Maximum 32 bytes.`);\n      }\n    }\n  }\n\n  /**\n   * Convert a TIP-20 operation to an AA call\n   */\n  private operationToCall(op: Tip20Operation): { to: Address; data: Hex; value: bigint } {\n    const amountInUnits = amountToTip20Units(op.amount);\n    const data = encodeTip20TransferWithMemo(op.to, amountInUnits, op.memo);\n\n    return {\n      to: op.token,\n      data,\n      value: 0n,\n    };\n  }\n}\n"]}

package/dist/src/lib/types.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Type aliases for Ethereum addresses and hex strings
+ */
+export type Address = string;
+export type Hex = string;
+export type TransactionSerializedEIP7702 = string;
+/**
+ * TIP-20 Operation with optional memo
+ * Represents a single transfer operation in a transaction
+ */
+export interface Tip20Operation {
+    token: Address;
+    to: Address;
+    amount: string;
+    memo?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/src/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lib/types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,OAAO,GAAG,MAAM,CAAC;AAC7B,MAAM,MAAM,GAAG,GAAG,MAAM,CAAC;AACzB,MAAM,MAAM,4BAA4B,GAAG,MAAM,CAAC;AAElD;;;GAGG;AACH,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf"}

package/dist/src/lib/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFR5cGUgYWxpYXNlcyBmb3IgRXRoZXJldW0gYWRkcmVzc2VzIGFuZCBoZXggc3RyaW5nc1xuICovXG5leHBvcnQgdHlwZSBBZGRyZXNzID0gc3RyaW5nO1xuZXhwb3J0IHR5cGUgSGV4ID0gc3RyaW5nO1xuZXhwb3J0IHR5cGUgVHJhbnNhY3Rpb25TZXJpYWxpemVkRUlQNzcwMiA9IHN0cmluZztcblxuLyoqXG4gKiBUSVAtMjAgT3BlcmF0aW9uIHdpdGggb3B0aW9uYWwgbWVtb1xuICogUmVwcmVzZW50cyBhIHNpbmdsZSB0cmFuc2ZlciBvcGVyYXRpb24gaW4gYSB0cmFuc2FjdGlvblxuICovXG5leHBvcnQgaW50ZXJmYWNlIFRpcDIwT3BlcmF0aW9uIHtcbiAgdG9rZW46IEFkZHJlc3M7XG4gIHRvOiBBZGRyZXNzO1xuICBhbW91bnQ6IHN0cmluZztcbiAgbWVtbz86IHN0cmluZztcbn1cbiJdfQ==

package/dist/src/lib/utils.d.ts

@@ -2,11 +2,12 @@
  * Tempo Utility Functions
  *
  * Since Tempo is EVM-compatible, we can reuse Ethereum utilities
-
  */
+type Address = string;
+type Hex = string;
 /**
  * Check if address is valid Ethereum-style address
- * TODO: Replace with ETH utils when implementing
+ * Uses ethers.js isAddress for proper validation including checksum
  */
 export declare function isValidAddress(address: string): boolean;
 /**
@@ -19,10 +20,53 @@ export declare function isValidPublicKey(publicKey: string): boolean;
  * TODO: Replace with ETH utils when implementing
  */
 export declare function isValidPrivateKey(privateKey: string): boolean;
+/**
+ * TIP-20 Utility Functions
+ */
+/**
+ * Convert human-readable amount to TIP-20 units (6 decimals)
+ * @param amount - Human-readable amount (e.g., "1.5")
+ * @returns Amount in TIP-20 smallest units as bigint
+ * @example amountToTip20Units("1.5") => 1500000n
+ */
+export declare function amountToTip20Units(amount: string): bigint;
+/**
+ * Convert TIP-20 units (6 decimals) to human-readable amount
+ * @param units - Amount in TIP-20 smallest units
+ * @returns Human-readable amount string
+ * @example tip20UnitsToAmount(1500000n) => "1.5"
+ */
+export declare function tip20UnitsToAmount(units: bigint): string;
+/**
+ * Convert string to bytes32 for memo field
+ * @param memo - Memo string to encode
+ * @returns Hex-encoded bytes32 value
+ * @example stringToBytes32("INVOICE-001") => "0x494e564f4943452d30303100..."
+ */
+export declare function stringToBytes32(memo: string): Hex;
+/**
+ * Encode TIP-20 transferWithMemo function call using ethers.js
+ * @param to - Recipient address
+ * @param amount - Amount in TIP-20 units (bigint)
+ * @param memo - Optional memo string
+ * @returns Encoded function call data
+ */
+export declare function encodeTip20TransferWithMemo(to: Address, amount: bigint, memo?: string): Hex;
+/**
+ * Validate TIP-20 amount format
+ * @param amount - Amount string to validate
+ * @returns true if valid, false otherwise
+ */
+export declare function isValidTip20Amount(amount: string): boolean;
 declare const utils: {
     isValidAddress: typeof isValidAddress;
     isValidPublicKey: typeof isValidPublicKey;
     isValidPrivateKey: typeof isValidPrivateKey;
+    amountToTip20Units: typeof amountToTip20Units;
+    tip20UnitsToAmount: typeof tip20UnitsToAmount;
+    stringToBytes32: typeof stringToBytes32;
+    encodeTip20TransferWithMemo: typeof encodeTip20TransferWithMemo;
+    isValidTip20Amount: typeof isValidTip20Amount;
 };
 export default utils;
 //# sourceMappingURL=utils.d.ts.map

package/dist/src/lib/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAKvD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAU3D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAU7D;AAED,QAAA,MAAM,KAAK;;;;CAIV,CAAC;AAEF,eAAe,KAAK,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,KAAK,OAAO,GAAG,MAAM,CAAC;AACtB,KAAK,GAAG,GAAG,MAAM,CAAC;AAElB;;;GAGG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAKvD;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAU3D;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAU7D;AAED;;GAEG;AAEH;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAMzD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAExD;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,GAAG,CAOjD;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,EAAE,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,GAAG,CAK3F;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAc1D;AAED,QAAA,MAAM,KAAK;;;;;;;;;CASV,CAAC;AAEF,eAAe,KAAK,CAAC"}

package/dist/src/lib/utils.js

@@ -3,23 +3,29 @@
  * Tempo Utility Functions
  *
  * Since Tempo is EVM-compatible, we can reuse Ethereum utilities
-
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isValidAddress = isValidAddress;
 exports.isValidPublicKey = isValidPublicKey;
 exports.isValidPrivateKey = isValidPrivateKey;
+exports.amountToTip20Units = amountToTip20Units;
+exports.tip20UnitsToAmount = tip20UnitsToAmount;
+exports.stringToBytes32 = stringToBytes32;
+exports.encodeTip20TransferWithMemo = encodeTip20TransferWithMemo;
+exports.isValidTip20Amount = isValidTip20Amount;
 const secp256k1_1 = require("@bitgo-beta/secp256k1");
+const ethers_1 = require("ethers");
 const constants_1 = require("./constants");
+const tip20Abi_1 = require("./tip20Abi");
 /**
  * Check if address is valid Ethereum-style address
- * TODO: Replace with ETH utils when implementing
+ * Uses ethers.js isAddress for proper validation including checksum
  */
 function isValidAddress(address) {
     if (typeof address !== 'string') {
         return false;
     }
-    return constants_1.VALID_ADDRESS_REGEX.test(address);
+    return ethers_1.ethers.utils.isAddress(address);
 }
 /**
  * Check if public key is valid (BIP32 xpub format)
@@ -53,10 +59,88 @@ function isValidPrivateKey(privateKey) {
         return false;
     }
 }
+/**
+ * TIP-20 Utility Functions
+ */
+/**
+ * Convert human-readable amount to TIP-20 units (6 decimals)
+ * @param amount - Human-readable amount (e.g., "1.5")
+ * @returns Amount in TIP-20 smallest units as bigint
+ * @example amountToTip20Units("1.5") => 1500000n
+ */
+function amountToTip20Units(amount) {
+    try {
+        return BigInt(ethers_1.ethers.utils.parseUnits(amount, constants_1.TIP20_DECIMALS).toString());
+    }
+    catch (error) {
+        throw new Error(`Invalid amount format: ${amount}. Expected decimal string.`);
+    }
+}
+/**
+ * Convert TIP-20 units (6 decimals) to human-readable amount
+ * @param units - Amount in TIP-20 smallest units
+ * @returns Human-readable amount string
+ * @example tip20UnitsToAmount(1500000n) => "1.5"
+ */
+function tip20UnitsToAmount(units) {
+    return ethers_1.ethers.utils.formatUnits(units.toString(), constants_1.TIP20_DECIMALS);
+}
+/**
+ * Convert string to bytes32 for memo field
+ * @param memo - Memo string to encode
+ * @returns Hex-encoded bytes32 value
+ * @example stringToBytes32("INVOICE-001") => "0x494e564f4943452d30303100..."
+ */
+function stringToBytes32(memo) {
+    const memoByteLength = new TextEncoder().encode(memo).length;
+    if (memoByteLength > 32) {
+        throw new Error(`Memo too long: ${memoByteLength} bytes. Maximum 32 bytes.`);
+    }
+    const hexString = ethers_1.ethers.utils.hexlify(ethers_1.ethers.utils.toUtf8Bytes(memo));
+    return ethers_1.ethers.utils.hexZeroPad(hexString, 32);
+}
+/**
+ * Encode TIP-20 transferWithMemo function call using ethers.js
+ * @param to - Recipient address
+ * @param amount - Amount in TIP-20 units (bigint)
+ * @param memo - Optional memo string
+ * @returns Encoded function call data
+ */
+function encodeTip20TransferWithMemo(to, amount, memo) {
+    const memoBytes = memo ? stringToBytes32(memo) : ethers_1.ethers.utils.hexZeroPad('0x', 32);
+    const iface = new ethers_1.ethers.utils.Interface(tip20Abi_1.TIP20_TRANSFER_WITH_MEMO_ABI);
+    return iface.encodeFunctionData('transferWithMemo', [to, amount, memoBytes]);
+}
+/**
+ * Validate TIP-20 amount format
+ * @param amount - Amount string to validate
+ * @returns true if valid, false otherwise
+ */
+function isValidTip20Amount(amount) {
+    if (typeof amount !== 'string' || amount.trim() === '') {
+        return false;
+    }
+    // Check for negative amounts before parsing
+    if (amount.startsWith('-')) {
+        return false;
+    }
+    try {
+        const parsed = ethers_1.ethers.utils.parseUnits(amount, constants_1.TIP20_DECIMALS);
+        return parsed.gte(0);
+    }
+    catch {
+        return false;
+    }
+}
 const utils = {
     isValidAddress,
     isValidPublicKey,
     isValidPrivateKey,
+    amountToTip20Units,
+    tip20UnitsToAmount,
+    stringToBytes32,
+    encodeTip20TransferWithMemo,
+    isValidTip20Amount,
 };
 exports.default = utils;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":";AAAA;;;;GAIG;;AAcH,wCAKC;AAMD,4CAUC;AAMD,8CAUC;AAYD,gDAMC;AAQD,gDAEC;AAQD,0CAOC;AASD,kEAKC;AAOD,gDAcC;AA/HD,qDAA8C;AAC9C,mCAAgC;AAChC,2CAA6C;AAC7C,yCAA0D;AAK1D;;;GAGG;AACH,SAAgB,cAAc,CAAC,OAAe;IAC5C,IAAI,OAAO,OAAO,KAAK,QAAQ,EAAE,CAAC;QAChC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,eAAM,CAAC,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC;AACzC,CAAC;AAED;;;GAGG;AACH,SAAgB,gBAAgB,CAAC,SAAiB;IAChD,IAAI,OAAO,SAAS,KAAK,QAAQ,EAAE,CAAC;QAClC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,iBAAK,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC;QAC3C,OAAO,MAAM,CAAC,UAAU,EAAE,CAAC;IAC7B,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,SAAgB,iBAAiB,CAAC,UAAkB;IAClD,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE,CAAC;QACnC,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,iBAAK,CAAC,UAAU,CAAC,UAAU,CAAC,CAAC;QAC5C,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;IAC9B,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;GAEG;AAEH;;;;;GAKG;AACH,SAAgB,kBAAkB,CAAC,MAAc;IAC/C,IAAI,CAAC;QACH,OAAO,MAAM,CAAC,eAAM,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,EAAE,0BAAc,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC;IAC5E,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,MAAM,IAAI,KAAK,CAAC,0BAA0B,MAAM,4BAA4B,CAAC,CAAC;IAChF,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAgB,kBAAkB,CAAC,KAAa;IAC9C,OAAO,eAAM,CAAC,KAAK,CAAC,WAAW,CAAC,KAAK,CAAC,QAAQ,EAAE,EAAE,0BAAc,CAAC,CAAC;AACpE,CAAC;AAED;;;;;GAKG;AACH,SAAgB,eAAe,CAAC,IAAY;IAC1C,MAAM,cAAc,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC;IAC7D,IAAI,cAAc,GAAG,EAAE,EAAE,CAAC;QACxB,MAAM,IAAI,KAAK,CAAC,kBAAkB,cAAc,2BAA2B,CAAC,CAAC;IAC/E,CAAC;IACD,MAAM,SAAS,GAAG,eAAM,CAAC,KAAK,CAAC,OAAO,CAAC,eAAM,CAAC,KAAK,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;IACvE,OAAO,eAAM,CAAC,KAAK,CAAC,UAAU,CAAC,SAAS,EAAE,EAAE,CAAC,CAAC;AAChD,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,2BAA2B,CAAC,EAAW,EAAE,MAAc,EAAE,IAAa;IACpF,MAAM,SAAS,GAAG,IAAI,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,eAAM,CAAC,KAAK,CAAC,UAAU,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;IAEnF,MAAM,KAAK,GAAG,IAAI,eAAM,CAAC,KAAK,CAAC,SAAS,CAAC,uCAA4B,CAAC,CAAC;IACvE,OAAO,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;AAC/E,CAAC;AAED;;;;GAIG;AACH,SAAgB,kBAAkB,CAAC,MAAc;IAC/C,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;QACvD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,4CAA4C;IAC5C,IAAI,MAAM,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,eAAM,CAAC,KAAK,CAAC,UAAU,CAAC,MAAM,EAAE,0BAAc,CAAC,CAAC;QAC/D,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;IACvB,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,MAAM,KAAK,GAAG;IACZ,cAAc;IACd,gBAAgB;IAChB,iBAAiB;IACjB,kBAAkB;IAClB,kBAAkB;IAClB,eAAe;IACf,2BAA2B;IAC3B,kBAAkB;CACnB,CAAC;AAEF,kBAAe,KAAK,CAAC","sourcesContent":["/**\n * Tempo Utility Functions\n *\n * Since Tempo is EVM-compatible, we can reuse Ethereum utilities\n */\n\nimport { bip32 } from '@bitgo-beta/secp256k1';\nimport { ethers } from 'ethers';\nimport { TIP20_DECIMALS } from './constants';\nimport { TIP20_TRANSFER_WITH_MEMO_ABI } from './tip20Abi';\n\ntype Address = string;\ntype Hex = string;\n\n/**\n * Check if address is valid Ethereum-style address\n * Uses ethers.js isAddress for proper validation including checksum\n */\nexport function isValidAddress(address: string): boolean {\n  if (typeof address !== 'string') {\n    return false;\n  }\n  return ethers.utils.isAddress(address);\n}\n\n/**\n * Check if public key is valid (BIP32 xpub format)\n * TODO: Replace with ETH utils when implementing\n */\nexport function isValidPublicKey(publicKey: string): boolean {\n  if (typeof publicKey !== 'string') {\n    return false;\n  }\n  try {\n    const hdNode = bip32.fromBase58(publicKey);\n    return hdNode.isNeutered();\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Check if private key is valid (BIP32 xprv format)\n * TODO: Replace with ETH utils when implementing\n */\nexport function isValidPrivateKey(privateKey: string): boolean {\n  if (typeof privateKey !== 'string') {\n    return false;\n  }\n  try {\n    const hdNode = bip32.fromBase58(privateKey);\n    return !hdNode.isNeutered();\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * TIP-20 Utility Functions\n */\n\n/**\n * Convert human-readable amount to TIP-20 units (6 decimals)\n * @param amount - Human-readable amount (e.g., \"1.5\")\n * @returns Amount in TIP-20 smallest units as bigint\n * @example amountToTip20Units(\"1.5\") => 1500000n\n */\nexport function amountToTip20Units(amount: string): bigint {\n  try {\n    return BigInt(ethers.utils.parseUnits(amount, TIP20_DECIMALS).toString());\n  } catch (error) {\n    throw new Error(`Invalid amount format: ${amount}. Expected decimal string.`);\n  }\n}\n\n/**\n * Convert TIP-20 units (6 decimals) to human-readable amount\n * @param units - Amount in TIP-20 smallest units\n * @returns Human-readable amount string\n * @example tip20UnitsToAmount(1500000n) => \"1.5\"\n */\nexport function tip20UnitsToAmount(units: bigint): string {\n  return ethers.utils.formatUnits(units.toString(), TIP20_DECIMALS);\n}\n\n/**\n * Convert string to bytes32 for memo field\n * @param memo - Memo string to encode\n * @returns Hex-encoded bytes32 value\n * @example stringToBytes32(\"INVOICE-001\") => \"0x494e564f4943452d30303100...\"\n */\nexport function stringToBytes32(memo: string): Hex {\n  const memoByteLength = new TextEncoder().encode(memo).length;\n  if (memoByteLength > 32) {\n    throw new Error(`Memo too long: ${memoByteLength} bytes. Maximum 32 bytes.`);\n  }\n  const hexString = ethers.utils.hexlify(ethers.utils.toUtf8Bytes(memo));\n  return ethers.utils.hexZeroPad(hexString, 32);\n}\n\n/**\n * Encode TIP-20 transferWithMemo function call using ethers.js\n * @param to - Recipient address\n * @param amount - Amount in TIP-20 units (bigint)\n * @param memo - Optional memo string\n * @returns Encoded function call data\n */\nexport function encodeTip20TransferWithMemo(to: Address, amount: bigint, memo?: string): Hex {\n  const memoBytes = memo ? stringToBytes32(memo) : ethers.utils.hexZeroPad('0x', 32);\n\n  const iface = new ethers.utils.Interface(TIP20_TRANSFER_WITH_MEMO_ABI);\n  return iface.encodeFunctionData('transferWithMemo', [to, amount, memoBytes]);\n}\n\n/**\n * Validate TIP-20 amount format\n * @param amount - Amount string to validate\n * @returns true if valid, false otherwise\n */\nexport function isValidTip20Amount(amount: string): boolean {\n  if (typeof amount !== 'string' || amount.trim() === '') {\n    return false;\n  }\n  // Check for negative amounts before parsing\n  if (amount.startsWith('-')) {\n    return false;\n  }\n  try {\n    const parsed = ethers.utils.parseUnits(amount, TIP20_DECIMALS);\n    return parsed.gte(0);\n  } catch {\n    return false;\n  }\n}\n\nconst utils = {\n  isValidAddress,\n  isValidPublicKey,\n  isValidPrivateKey,\n  amountToTip20Units,\n  tip20UnitsToAmount,\n  stringToBytes32,\n  encodeTip20TransferWithMemo,\n  isValidTip20Amount,\n};\n\nexport default utils;\n"]}

package/dist/src/tempo.d.ts

@@ -2,6 +2,7 @@
  * @prettier
  */
 import { AbstractEthLikeNewCoins, RecoverOptions, OfflineVaultTxInfo, UnsignedSweepTxMPCv2, TransactionBuilder } from '@bitgo-beta/abstract-eth';
+import type * as EthLikeCommon from '@ethereumjs/common';
 import { BaseCoin, BitGoBase, MPCAlgorithm } from '@bitgo-beta/sdk-core';
 import { BaseCoin as StaticsBaseCoin } from '@bitgo-beta/statics';
 export declare class Tempo extends AbstractEthLikeNewCoins {
@@ -55,9 +56,10 @@ export declare class Tempo extends AbstractEthLikeNewCoins {
     recoveryBlockchainExplorerQuery(query: Record<string, string>, apiKey?: string): Promise<Record<string, unknown>>;
     /**
      * Get transaction builder for Tempo
-     * TODO: Implement TransactionBuilder for Tempo
+     * Returns a TIP-20 transaction builder for Tempo-specific operations
+     * @param common - Optional common chain configuration
      * @protected
      */
-    protected getTransactionBuilder(): TransactionBuilder;
+    protected getTransactionBuilder(common?: EthLikeCommon.default): TransactionBuilder;
 }
 //# sourceMappingURL=tempo.d.ts.map

package/dist/src/tempo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tempo.d.ts","sourceRoot":"","sources":["../../src/tempo.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EACL,uBAAuB,EACvB,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzE,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAElE,qBAAa,KAAM,SAAQ,uBAAuB;IAChD,SAAS,aAAa,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAI/E;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;IAI1F;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB;;OAEG;IACH,WAAW,IAAI,MAAM;IAIrB;;OAEG;IACH,aAAa,IAAI,MAAM;IAIvB;;;OAGG;IACH,wBAAwB,IAAI,OAAO;IAInC;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,eAAe,IAAI,YAAY;IAI/B;;OAEG;IACH,sBAAsB,IAAI,OAAO;IAIjC;;OAEG;IACH,wBAAwB,IAAI,OAAO;IAInC;;;OAGG;cACa,wBAAwB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,kBAAkB,GAAG,oBAAoB,CAAC;IAMpH;;;OAGG;IACG,+BAA+B,CACnC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAMnC;;;;OAIG;IACH,SAAS,CAAC,qBAAqB,IAAI,kBAAkB;CAKtD"}
+{"version":3,"file":"tempo.d.ts","sourceRoot":"","sources":["../../src/tempo.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EACL,uBAAuB,EACvB,cAAc,EACd,kBAAkB,EAClB,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,KAAK,aAAa,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACzE,OAAO,EAAE,QAAQ,IAAI,eAAe,EAAS,MAAM,qBAAqB,CAAC;AAGzE,qBAAa,KAAM,SAAQ,uBAAuB;IAChD,SAAS,aAAa,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAI/E;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;IAI1F;;OAEG;IACH,QAAQ,IAAI,MAAM;IAIlB;;OAEG;IACH,WAAW,IAAI,MAAM;IAIrB;;OAEG;IACH,aAAa,IAAI,MAAM;IAIvB;;;OAGG;IACH,wBAAwB,IAAI,OAAO;IAInC;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,eAAe,IAAI,YAAY;IAI/B;;OAEG;IACH,sBAAsB,IAAI,OAAO;IAIjC;;OAEG;IACH,wBAAwB,IAAI,OAAO;IAInC;;;OAGG;cACa,wBAAwB,CAAC,MAAM,EAAE,cAAc,GAAG,OAAO,CAAC,kBAAkB,GAAG,oBAAoB,CAAC;IAMpH;;;OAGG;IACG,+BAA+B,CACnC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAC7B,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAMnC;;;;;OAKG;IACH,SAAS,CAAC,qBAAqB,CAAC,MAAM,CAAC,EAAE,aAAa,CAAC,OAAO,GAAG,kBAAkB;CAGpF"}