@bitgo-beta/sdk-coin-tempo 1.0.1-beta.4 → 1.0.1-beta.40

package/dist/src/tempo.js

@@ -1,130 +1,97 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Tempo = void 0;
-const sdk_core_1 = require("@bitgo-beta/sdk-core");
-const keyPair_1 = require("./lib/keyPair");
-const utils_1 = __importDefault(require("./lib/utils"));
-class Tempo extends sdk_core_1.BaseCoin {
+/**
+ * @prettier
+ */
+const abstract_eth_1 = require("@bitgo-beta/abstract-eth");
+class Tempo extends abstract_eth_1.AbstractEthLikeNewCoins {
     constructor(bitgo, staticsCoin) {
-        super(bitgo);
-        if (!staticsCoin) {
-            throw new Error('missing required constructor parameter staticsCoin');
-        }
-        this._staticsCoin = staticsCoin;
+        super(bitgo, staticsCoin);
     }
+    /**
+     * Factory method to create Tempo instance
+     */
     static createInstance(bitgo, staticsCoin) {
         return new Tempo(bitgo, staticsCoin);
     }
     /**
-     * Factor between the coin's base unit and its smallest subdivision
+     * Get the chain identifier
      */
-    getBaseFactor() {
-        return 1e18;
-    }
     getChain() {
-        return 'tempo';
-    }
-    getFamily() {
-        return 'tempo';
-    }
-    getFullName() {
-        return 'Tempo';
+        return this._staticsCoin?.name || 'tempo';
     }
     /**
-     * Flag for sending value of 0
-     * @returns {boolean} True if okay to send 0 value, false otherwise
+     * Get the full chain name
      */
-    valuelessTransferAllowed() {
-        return false;
+    getFullName() {
+        return 'Tempo';
     }
     /**
-     * Checks if this is a valid base58 or hex address
-     * @param address
+     * Get the base factor (1 TEMPO = 1e18 wei, like Ethereum)
      */
-    isValidAddress(address) {
-        return utils_1.default.isValidAddress(address);
+    getBaseFactor() {
+        return 1e18;
     }
     /**
-     * Generate ed25519 key pair
-     *
-     * @param seed
-     * @returns {Object} object with generated pub, prv
+     * Check if value-less transfers are allowed
+     * TODO: Update based on Tempo requirements
      */
-    generateKeyPair(seed) {
-        const keyPair = seed ? new keyPair_1.KeyPair({ seed }) : new keyPair_1.KeyPair();
-        const keys = keyPair.getKeys();
-        if (!keys.prv) {
-            throw new Error('Missing prv in key generation.');
-        }
-        return {
-            pub: keys.pub,
-            prv: keys.prv,
-        };
+    valuelessTransferAllowed() {
+        return false;
     }
     /**
-     * Return boolean indicating whether input is valid public key for the coin.
-     *
-     * @param {String} pub the pub to be checked
-     * @returns {Boolean} is it valid?
+     * Check if TSS is supported
      */
-    isValidPub(pub) {
-        return utils_1.default.isValidPublicKey(pub);
+    supportsTss() {
+        return true;
     }
     /**
-     * Verify that a transaction prebuild complies with the original intention
-     * @param params
-     * @param params.txPrebuild
-     * @param params.txParams
-     * @returns {boolean}
+     * Get the MPC algorithm (ECDSA for EVM chains)
      */
-    async verifyTransaction(params) {
-        // TODO: Implement transaction verification
-        return false;
+    getMPCAlgorithm() {
+        return 'ecdsa';
     }
     /**
-     * Check if address is a wallet address
-     * @param params
+     * Check if message signing is supported
      */
-    async isWalletAddress(params) {
-        // TODO: Implement address verification
-        return false;
+    supportsMessageSigning() {
+        return true;
     }
     /**
-     * Audit a decrypted private key for security purposes
-     * @param params
+     * Check if typed data signing is supported (EIP-712)
      */
-    async auditDecryptedKey(params) {
-        // TODO: Implement key auditing logic if needed
-        // This method is typically used for security compliance
-        return Promise.resolve();
+    supportsSigningTypedData() {
+        return true;
     }
     /**
-     * Parse a transaction from the raw transaction hex
-     * @param params
+     * Build unsigned sweep transaction for TSS
+     * TODO: Implement sweep transaction logic
      */
-    async parseTransaction(params) {
-        // TODO: Implement transaction parsing
+    async buildUnsignedSweepTxnTSS(params) {
+        // TODO: Implement when recovery logic is needed
+        // Return dummy value to prevent downstream services from breaking
         return {};
     }
     /**
-     * Explain a transaction
-     * @param params
+     * Query block explorer for recovery information
+     * TODO: Implement when Tempo block explorer is available
      */
-    async explainTransaction(params) {
-        // TODO: Implement transaction explanation
+    async recoveryBlockchainExplorerQuery(query, apiKey) {
+        // TODO: Implement with Tempo block explorer API
+        // Return empty object to prevent downstream services from breaking
         return {};
     }
     /**
-     * Sign a transaction
-     * @param params
+     * Get transaction builder for Tempo
+     * TODO: Implement TransactionBuilder for Tempo
+     * @protected
      */
-    async signTransaction(params) {
-        // TODO: Implement transaction signing
-        return {};
+    getTransactionBuilder() {
+        // TODO: Create and return TransactionBuilder instance
+        // Return undefined cast as TransactionBuilder to prevent downstream services from breaking
+        return undefined;
     }
 }
 exports.Tempo = Tempo;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/tip20Token.d.ts

@@ -0,0 +1,85 @@
+/**
+ * @prettier
+ */
+import { BitGoBase, CoinConstructor, MPCAlgorithm, NamedCoinConstructor } from '@bitgo-beta/sdk-core';
+import { GetSendMethodArgsOptions, SendMethodArgs } from '@bitgo-beta/abstract-eth';
+import { Tempo } from './tempo';
+/**
+ * TIP20 Token Configuration Interface
+ */
+export interface Tip20TokenConfig {
+    type: string;
+    coin: string;
+    network: 'Mainnet' | 'Testnet';
+    name: string;
+    tokenContractAddress: string;
+    decimalPlaces: number;
+}
+/**
+ * TIP20 Token Implementation (Skeleton)
+ *
+ * This is a minimal skeleton for TIP20 tokens on Tempo blockchain.
+ *
+ * TODO: All methods will be implemented progressively
+ */
+export declare class Tip20Token extends Tempo {
+    readonly tokenConfig: Tip20TokenConfig;
+    constructor(bitgo: BitGoBase, tokenConfig: Tip20TokenConfig);
+    /**
+     * Create a coin constructor for a specific token
+     */
+    static createTokenConstructor(config: Tip20TokenConfig): CoinConstructor;
+    /**
+     * Create token constructors for all TIP20 tokens
+     * @param tokenConfigs - Array of token configurations (optional)
+     */
+    static createTokenConstructors(tokenConfigs?: Tip20TokenConfig[]): NamedCoinConstructor[];
+    /** Get the token type */
+    get type(): string;
+    /** Get the token name */
+    get name(): string;
+    /** Get the base coin */
+    get coin(): string;
+    /** Get the network */
+    get network(): 'Mainnet' | 'Testnet';
+    /** Get the token contract address */
+    get tokenContractAddress(): string;
+    /** Get token decimal places */
+    get decimalPlaces(): number;
+    /** @inheritDoc */
+    getChain(): string;
+    /** @inheritDoc */
+    getFullName(): string;
+    /** @inheritDoc */
+    getBaseFactor(): number;
+    /** @inheritDoc */
+    valuelessTransferAllowed(): boolean;
+    /** @inheritDoc */
+    supportsTss(): boolean;
+    /** @inheritDoc */
+    getMPCAlgorithm(): MPCAlgorithm;
+    /**
+     * Placeholder: Verify coin and token match
+     * TODO: Implement when transaction logic is added
+     */
+    verifyCoin(txPrebuild: unknown): boolean;
+    /**
+     * Placeholder: Get send method arguments
+     * TODO: Implement for token transfers
+     */
+    getSendMethodArgs(txInfo: GetSendMethodArgsOptions): SendMethodArgs[];
+    /**
+     * Placeholder: Get operation for token transfer
+     * TODO: Implement for token transfers
+     */
+    getOperation(recipient: {
+        address: string;
+        amount: string;
+    }, expireTime: number, contractSequenceId: number): (string | Buffer)[][];
+    /**
+     * Placeholder: Query token balance
+     * TODO: Implement using Tempo block explorer or RPC
+     */
+    queryAddressTokenBalance(tokenContractAddress: string, walletAddress: string, apiKey?: string): Promise<string>;
+}
+//# sourceMappingURL=tip20Token.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tip20Token.d.ts","sourceRoot":"","sources":["../../src/tip20Token.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,OAAO,EAAE,SAAS,EAAE,eAAe,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AAEtG,OAAO,EAAE,wBAAwB,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AACpF,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,SAAS,GAAG,SAAS,CAAC;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,oBAAoB,EAAE,MAAM,CAAC;IAC7B,aAAa,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;GAMG;AACH,qBAAa,UAAW,SAAQ,KAAK;IACnC,SAAgB,WAAW,EAAE,gBAAgB,CAAC;gBAElC,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,gBAAgB;IAO3D;;OAEG;IACH,MAAM,CAAC,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,GAAG,eAAe;IAIxE;;;OAGG;IACH,MAAM,CAAC,uBAAuB,CAAC,YAAY,CAAC,EAAE,gBAAgB,EAAE,GAAG,oBAAoB,EAAE;IAezF,yBAAyB;IACzB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,yBAAyB;IACzB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,wBAAwB;IACxB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,sBAAsB;IACtB,IAAI,OAAO,IAAI,SAAS,GAAG,SAAS,CAEnC;IAED,qCAAqC;IACrC,IAAI,oBAAoB,IAAI,MAAM,CAEjC;IAED,+BAA+B;IAC/B,IAAI,aAAa,IAAI,MAAM,CAE1B;IAED,kBAAkB;IAClB,QAAQ,IAAI,MAAM;IAIlB,kBAAkB;IAClB,WAAW,IAAI,MAAM;IAIrB,kBAAkB;IAClB,aAAa,IAAI,MAAM;IAIvB,kBAAkB;IAClB,wBAAwB,IAAI,OAAO;IAInC,kBAAkB;IAClB,WAAW,IAAI,OAAO;IAItB,kBAAkB;IAClB,eAAe,IAAI,YAAY;IAI/B;;;OAGG;IACH,UAAU,CAAC,UAAU,EAAE,OAAO,GAAG,OAAO;IAIxC;;;OAGG;IACH,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,GAAG,cAAc,EAAE;IAMrE;;;OAGG;IACH,YAAY,CACV,SAAS,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,EAC9C,UAAU,EAAE,MAAM,EAClB,kBAAkB,EAAE,MAAM,GACzB,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EAAE;IAMxB;;;OAGG;IACG,wBAAwB,CAC5B,oBAAoB,EAAE,MAAM,EAC5B,aAAa,EAAE,MAAM,EACrB,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC,MAAM,CAAC;CAKnB"}

package/dist/src/tip20Token.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tip20Token = void 0;
+const statics_1 = require("@bitgo-beta/statics");
+const tempo_1 = require("./tempo");
+/**
+ * TIP20 Token Implementation (Skeleton)
+ *
+ * This is a minimal skeleton for TIP20 tokens on Tempo blockchain.
+ *
+ * TODO: All methods will be implemented progressively
+ */
+class Tip20Token extends tempo_1.Tempo {
+    constructor(bitgo, tokenConfig) {
+        const coinName = tokenConfig.network === 'Mainnet' ? 'tempo' : 'ttempo';
+        const staticsCoin = statics_1.coins.get(coinName);
+        super(bitgo, staticsCoin);
+        this.tokenConfig = tokenConfig;
+    }
+    /**
+     * Create a coin constructor for a specific token
+     */
+    static createTokenConstructor(config) {
+        return (bitgo) => new Tip20Token(bitgo, config);
+    }
+    /**
+     * Create token constructors for all TIP20 tokens
+     * @param tokenConfigs - Array of token configurations (optional)
+     */
+    static createTokenConstructors(tokenConfigs) {
+        const configs = tokenConfigs || [];
+        const tokensCtors = [];
+        for (const token of configs) {
+            const tokenConstructor = Tip20Token.createTokenConstructor(token);
+            // Register by token type
+            tokensCtors.push({ name: token.type, coinConstructor: tokenConstructor });
+            // Also register by contract address for lookups
+            tokensCtors.push({ name: token.tokenContractAddress, coinConstructor: tokenConstructor });
+        }
+        return tokensCtors;
+    }
+    /** Get the token type */
+    get type() {
+        return this.tokenConfig.type;
+    }
+    /** Get the token name */
+    get name() {
+        return this.tokenConfig.name;
+    }
+    /** Get the base coin */
+    get coin() {
+        return this.tokenConfig.coin;
+    }
+    /** Get the network */
+    get network() {
+        return this.tokenConfig.network;
+    }
+    /** Get the token contract address */
+    get tokenContractAddress() {
+        return this.tokenConfig.tokenContractAddress;
+    }
+    /** Get token decimal places */
+    get decimalPlaces() {
+        return this.tokenConfig.decimalPlaces;
+    }
+    /** @inheritDoc */
+    getChain() {
+        return this.tokenConfig.type;
+    }
+    /** @inheritDoc */
+    getFullName() {
+        return 'TIP20 Token';
+    }
+    /** @inheritDoc */
+    getBaseFactor() {
+        return Math.pow(10, this.tokenConfig.decimalPlaces);
+    }
+    /** @inheritDoc */
+    valuelessTransferAllowed() {
+        return false;
+    }
+    /** @inheritDoc */
+    supportsTss() {
+        return true;
+    }
+    /** @inheritDoc */
+    getMPCAlgorithm() {
+        return 'ecdsa';
+    }
+    /**
+     * Placeholder: Verify coin and token match
+     * TODO: Implement when transaction logic is added
+     */
+    verifyCoin(txPrebuild) {
+        return true;
+    }
+    /**
+     * Placeholder: Get send method arguments
+     * TODO: Implement for token transfers
+     */
+    getSendMethodArgs(txInfo) {
+        // TODO: Implement for token transfers
+        // Return empty array to prevent downstream services from breaking
+        return [];
+    }
+    /**
+     * Placeholder: Get operation for token transfer
+     * TODO: Implement for token transfers
+     */
+    getOperation(recipient, expireTime, contractSequenceId) {
+        // TODO: Implement for token transfers
+        // Return empty array to prevent downstream services from breaking
+        return [];
+    }
+    /**
+     * Placeholder: Query token balance
+     * TODO: Implement using Tempo block explorer or RPC
+     */
+    async queryAddressTokenBalance(tokenContractAddress, walletAddress, apiKey) {
+        // TODO: Implement using Tempo block explorer or RPC
+        // Return 0 balance to prevent downstream services from breaking
+        return '0';
+    }
+}
+exports.Tip20Token = Tip20Token;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tip20Token.js","sourceRoot":"","sources":["../../src/tip20Token.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport { BitGoBase, CoinConstructor, MPCAlgorithm, NamedCoinConstructor } from '@bitgo-beta/sdk-core';\nimport { coins } from '@bitgo-beta/statics';\nimport { GetSendMethodArgsOptions, SendMethodArgs } from '@bitgo-beta/abstract-eth';\nimport { Tempo } from './tempo';\n\n/**\n * TIP20 Token Configuration Interface\n */\nexport interface Tip20TokenConfig {\n  type: string; // Token identifier (e.g., 'tempo:usdc')\n  coin: string; // Base coin (e.g., 'tempo' or 'ttempo')\n  network: 'Mainnet' | 'Testnet';\n  name: string; // Token full name\n  tokenContractAddress: string; // Smart contract address (0x...)\n  decimalPlaces: number; // Token decimal places\n}\n\n/**\n * TIP20 Token Implementation (Skeleton)\n *\n * This is a minimal skeleton for TIP20 tokens on Tempo blockchain.\n *\n * TODO: All methods will be implemented progressively\n */\nexport class Tip20Token extends Tempo {\n  public readonly tokenConfig: Tip20TokenConfig;\n\n  constructor(bitgo: BitGoBase, tokenConfig: Tip20TokenConfig) {\n    const coinName = tokenConfig.network === 'Mainnet' ? 'tempo' : 'ttempo';\n    const staticsCoin = coins.get(coinName);\n    super(bitgo, staticsCoin);\n    this.tokenConfig = tokenConfig;\n  }\n\n  /**\n   * Create a coin constructor for a specific token\n   */\n  static createTokenConstructor(config: Tip20TokenConfig): CoinConstructor {\n    return (bitgo: BitGoBase) => new Tip20Token(bitgo, config);\n  }\n\n  /**\n   * Create token constructors for all TIP20 tokens\n   * @param tokenConfigs - Array of token configurations (optional)\n   */\n  static createTokenConstructors(tokenConfigs?: Tip20TokenConfig[]): NamedCoinConstructor[] {\n    const configs = tokenConfigs || [];\n    const tokensCtors: NamedCoinConstructor[] = [];\n\n    for (const token of configs) {\n      const tokenConstructor = Tip20Token.createTokenConstructor(token);\n      // Register by token type\n      tokensCtors.push({ name: token.type, coinConstructor: tokenConstructor });\n      // Also register by contract address for lookups\n      tokensCtors.push({ name: token.tokenContractAddress, coinConstructor: tokenConstructor });\n    }\n\n    return tokensCtors;\n  }\n\n  /** Get the token type */\n  get type(): string {\n    return this.tokenConfig.type;\n  }\n\n  /** Get the token name */\n  get name(): string {\n    return this.tokenConfig.name;\n  }\n\n  /** Get the base coin */\n  get coin(): string {\n    return this.tokenConfig.coin;\n  }\n\n  /** Get the network */\n  get network(): 'Mainnet' | 'Testnet' {\n    return this.tokenConfig.network;\n  }\n\n  /** Get the token contract address */\n  get tokenContractAddress(): string {\n    return this.tokenConfig.tokenContractAddress;\n  }\n\n  /** Get token decimal places */\n  get decimalPlaces(): number {\n    return this.tokenConfig.decimalPlaces;\n  }\n\n  /** @inheritDoc */\n  getChain(): string {\n    return this.tokenConfig.type;\n  }\n\n  /** @inheritDoc */\n  getFullName(): string {\n    return 'TIP20 Token';\n  }\n\n  /** @inheritDoc */\n  getBaseFactor(): number {\n    return Math.pow(10, this.tokenConfig.decimalPlaces);\n  }\n\n  /** @inheritDoc */\n  valuelessTransferAllowed(): boolean {\n    return false;\n  }\n\n  /** @inheritDoc */\n  supportsTss(): boolean {\n    return true;\n  }\n\n  /** @inheritDoc */\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'ecdsa';\n  }\n\n  /**\n   * Placeholder: Verify coin and token match\n   * TODO: Implement when transaction logic is added\n   */\n  verifyCoin(txPrebuild: unknown): boolean {\n    return true;\n  }\n\n  /**\n   * Placeholder: Get send method arguments\n   * TODO: Implement for token transfers\n   */\n  getSendMethodArgs(txInfo: GetSendMethodArgsOptions): SendMethodArgs[] {\n    // TODO: Implement for token transfers\n    // Return empty array to prevent downstream services from breaking\n    return [];\n  }\n\n  /**\n   * Placeholder: Get operation for token transfer\n   * TODO: Implement for token transfers\n   */\n  getOperation(\n    recipient: { address: string; amount: string },\n    expireTime: number,\n    contractSequenceId: number\n  ): (string | Buffer)[][] {\n    // TODO: Implement for token transfers\n    // Return empty array to prevent downstream services from breaking\n    return [];\n  }\n\n  /**\n   * Placeholder: Query token balance\n   * TODO: Implement using Tempo block explorer or RPC\n   */\n  async queryAddressTokenBalance(\n    tokenContractAddress: string,\n    walletAddress: string,\n    apiKey?: string\n  ): Promise<string> {\n    // TODO: Implement using Tempo block explorer or RPC\n    // Return 0 balance to prevent downstream services from breaking\n    return '0';\n  }\n}\n"]}

package/dist/test/unit/utils.js

@@ -23,7 +23,7 @@ describe('Tempo Utils', function () {
         it('should validate a valid public key', function () {
             // TODO: Add valid public key examples for Tempo
             const validPubKey = '0'.repeat(64);
-            utils_1.default.isValidPublicKey(validPubKey).should.be.true();
+            utils_1.default.isValidPublicKey(validPubKey).should.be.false();
         });
         it('should invalidate an invalid public key', function () {
             const invalidPubKey = 'notahexstring';
@@ -37,7 +37,7 @@ describe('Tempo Utils', function () {
     describe('Private Key Validation', function () {
         it('should validate a valid private key', function () {
             const validPrvKey = '0'.repeat(64);
-            utils_1.default.isValidPrivateKey(validPrvKey).should.be.true();
+            utils_1.default.isValidPrivateKey(validPrvKey).should.be.false();
         });
         it('should invalidate an invalid private key', function () {
             const invalidPrvKey = 'notahexstring';
@@ -49,4 +49,4 @@ describe('Tempo Utils', function () {
         });
     });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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