@bitgo-beta/sdk-coin-polyx 1.0.1-beta.69 → 1.0.1-beta.691

package/dist/src/lib/tokenTransferBuilder.js

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenTransferBuilder = void 0;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const baseBuilder_1 = require("./baseBuilder");
+const iface_1 = require("./iface");
+const transaction_1 = require("./transaction");
+const txnSchema_1 = require("./txnSchema");
+const txwrapper_core_1 = require("@substrate/txwrapper-core");
+class TokenTransferBuilder extends baseBuilder_1.PolyxBaseBuilder {
+    constructor(_coinConfig) {
+        super(_coinConfig);
+        this._transaction = new transaction_1.Transaction(_coinConfig);
+    }
+    get transactionType() {
+        return sdk_core_1.TransactionType.SendToken;
+    }
+    buildTransaction() {
+        const baseTxInfo = this.createBaseTxInfo();
+        return this.addAndAffirmWithMediators({
+            venueId: null,
+            settlementType: iface_1.SettlementType.SettleOnAffirmation,
+            tradeDate: null,
+            valueDate: null,
+            legs: [
+                {
+                    fungible: {
+                        sender: {
+                            did: this._fromDID,
+                            kind: iface_1.PortfolioKind.Default,
+                        },
+                        receiver: {
+                            did: this._toDID,
+                            kind: iface_1.PortfolioKind.Default,
+                        },
+                        assetId: this._assetId,
+                        amount: this._amount,
+                    },
+                },
+            ],
+            portfolios: [
+                {
+                    did: this._fromDID,
+                    kind: iface_1.PortfolioKind.Default,
+                },
+            ],
+            instructionMemo: this._memo,
+            mediators: [],
+        }, baseTxInfo);
+    }
+    /**
+     * Sets the amount to transfer.
+     *
+     * @param {string} amount - The amount to transfer.
+     * @returns {this} The current instance of the builder.
+     */
+    assetId(assetId) {
+        this._assetId = assetId;
+        return this;
+    }
+    /**
+     * Sets the amount to transfer.
+     *
+     * @param {string} amount - The amount to transfer.
+     * @returns {this} The current instance of the builder.
+     */
+    amount(amount) {
+        this._amount = amount;
+        return this;
+    }
+    /**
+     * Sets the memo for the transaction.
+     * Pads the memo on the left with zeros to ensure it is 32 characters long.
+     *
+     * @param {string} memo - The memo for the transaction.
+     * @returns {this} The current instance of the builder.
+     */
+    memo(memo) {
+        const paddedMemo = memo.padStart(32, '0');
+        this._memo = paddedMemo;
+        return this;
+    }
+    /**
+     * Sets the sender DID.
+     *
+     * @param {string} fromDID - The sender DID.
+     * @returns {this} The current instance of the builder.
+     */
+    fromDID(fromDID) {
+        this._fromDID = fromDID;
+        return this;
+    }
+    /**
+     * Sets the receiver DID.
+     *
+     * @param {string} toDID - The receiver DID.
+     * @returns {this} The current instance of the builder.
+     */
+    toDID(toDID) {
+        this._toDID = toDID;
+        return this;
+    }
+    /** @inheritdoc */
+    fromImplementation(rawTransaction) {
+        const tx = super.fromImplementation(rawTransaction);
+        if (this._method?.name === iface_1.MethodNames.AddAndAffirmWithMediators) {
+            const txMethod = this._method.args;
+            this.assetId(txMethod.legs[0].fungible.assetId);
+            this.amount(txMethod.legs[0].fungible.amount);
+            this.memo(txMethod.instructionMemo);
+            this.fromDID(txMethod.legs[0].fungible.sender.did);
+            this.toDID(txMethod.legs[0].fungible.receiver.did);
+        }
+        else {
+            throw new Error(`Invalid Transaction Type: ${this._method?.name}. Expected AddAndAffirmWithMediators`);
+        }
+        return tx;
+    }
+    /** @inheritdoc */
+    validateDecodedTransaction(decodedTxn, rawTransaction) {
+        if (decodedTxn.method?.name === iface_1.MethodNames.AddAndAffirmWithMediators) {
+            const txMethod = decodedTxn.method.args;
+            const venueId = txMethod.venueId;
+            const settlementType = txMethod.settlementType;
+            const tradeDate = txMethod.tradeDate;
+            const valueDate = txMethod.valueDate;
+            const legs = txMethod.legs;
+            const portfolios = txMethod.portfolios;
+            const instructionMemo = txMethod.instructionMemo;
+            const mediators = txMethod.mediators;
+            const validationResult = txnSchema_1.AddAndAffirmWithMediatorsTransactionSchema.validate({
+                venueId,
+                settlementType,
+                tradeDate,
+                valueDate,
+                legs,
+                portfolios,
+                instructionMemo,
+                mediators,
+            });
+            if (validationResult.error) {
+                throw new Error(`Invalid transaction: ${validationResult.error.message}`);
+            }
+        }
+    }
+    addAndAffirmWithMediators(args, info) {
+        return (0, txwrapper_core_1.defineMethod)({
+            method: {
+                args,
+                name: 'addAndAffirmWithMediators',
+                pallet: 'settlement',
+            },
+            ...info.baseTxInfo,
+        }, info.options);
+    }
+}
+exports.TokenTransferBuilder = TokenTransferBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tokenTransferBuilder.js","sourceRoot":"","sources":["../../../src/lib/tokenTransferBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["import { TransactionType } from '@bitgo-beta/sdk-core';\nimport { BaseCoin as CoinConfig } from '@bitgo-beta/statics';\nimport { PolyxBaseBuilder } from './baseBuilder';\nimport { TxMethod, MethodNames, AddAndAffirmWithMediatorsArgs, SettlementType, PortfolioKind } from './iface';\nimport { Transaction } from './transaction';\nimport { Interface } from '@bitgo-beta/abstract-substrate';\nimport { AddAndAffirmWithMediatorsTransactionSchema } from './txnSchema';\nimport { DecodedSignedTx, DecodedSigningPayload, defineMethod, UnsignedTransaction } from '@substrate/txwrapper-core';\n\nexport class TokenTransferBuilder extends PolyxBaseBuilder<TxMethod, Transaction> {\n  protected _assetId: string;\n  protected _amount: string;\n  protected _memo: string;\n  protected _fromDID: string;\n  protected _toDID: string;\n\n  constructor(_coinConfig: Readonly<CoinConfig>) {\n    super(_coinConfig);\n    this._transaction = new Transaction(_coinConfig);\n  }\n\n  protected get transactionType(): TransactionType {\n    return TransactionType.SendToken;\n  }\n\n  protected buildTransaction(): UnsignedTransaction {\n    const baseTxInfo = this.createBaseTxInfo();\n    return this.addAndAffirmWithMediators(\n      {\n        venueId: null,\n        settlementType: SettlementType.SettleOnAffirmation,\n        tradeDate: null,\n        valueDate: null,\n        legs: [\n          {\n            fungible: {\n              sender: {\n                did: this._fromDID,\n                kind: PortfolioKind.Default,\n              },\n              receiver: {\n                did: this._toDID,\n                kind: PortfolioKind.Default,\n              },\n              assetId: this._assetId,\n              amount: this._amount,\n            },\n          },\n        ],\n        portfolios: [\n          {\n            did: this._fromDID,\n            kind: PortfolioKind.Default,\n          },\n        ],\n        instructionMemo: this._memo,\n        mediators: [],\n      },\n      baseTxInfo\n    );\n  }\n\n  /**\n   * Sets the amount to transfer.\n   *\n   * @param {string} amount - The amount to transfer.\n   * @returns {this} The current instance of the builder.\n   */\n  assetId(assetId: string): this {\n    this._assetId = assetId;\n    return this;\n  }\n\n  /**\n   * Sets the amount to transfer.\n   *\n   * @param {string} amount - The amount to transfer.\n   * @returns {this} The current instance of the builder.\n   */\n  amount(amount: string): this {\n    this._amount = amount;\n    return this;\n  }\n\n  /**\n   * Sets the memo for the transaction.\n   * Pads the memo on the left with zeros to ensure it is 32 characters long.\n   *\n   * @param {string} memo - The memo for the transaction.\n   * @returns {this} The current instance of the builder.\n   */\n  memo(memo: string): this {\n    const paddedMemo = memo.padStart(32, '0');\n    this._memo = paddedMemo;\n    return this;\n  }\n\n  /**\n   * Sets the sender DID.\n   *\n   * @param {string} fromDID - The sender DID.\n   * @returns {this} The current instance of the builder.\n   */\n  fromDID(fromDID: string): this {\n    this._fromDID = fromDID;\n    return this;\n  }\n\n  /**\n   * Sets the receiver DID.\n   *\n   * @param {string} toDID - The receiver DID.\n   * @returns {this} The current instance of the builder.\n   */\n  toDID(toDID: string): this {\n    this._toDID = toDID;\n    return this;\n  }\n\n  /** @inheritdoc */\n  protected fromImplementation(rawTransaction: string): Transaction {\n    const tx = super.fromImplementation(rawTransaction);\n    if (this._method?.name === MethodNames.AddAndAffirmWithMediators) {\n      const txMethod = this._method.args as AddAndAffirmWithMediatorsArgs;\n      this.assetId(txMethod.legs[0].fungible.assetId);\n      this.amount(txMethod.legs[0].fungible.amount);\n      this.memo(txMethod.instructionMemo);\n      this.fromDID(txMethod.legs[0].fungible.sender.did);\n      this.toDID(txMethod.legs[0].fungible.receiver.did);\n    } else {\n      throw new Error(`Invalid Transaction Type: ${this._method?.name}. Expected AddAndAffirmWithMediators`);\n    }\n    return tx;\n  }\n\n  /** @inheritdoc */\n  validateDecodedTransaction(decodedTxn: DecodedSigningPayload | DecodedSignedTx, rawTransaction?: string): void {\n    if (decodedTxn.method?.name === MethodNames.AddAndAffirmWithMediators) {\n      const txMethod = decodedTxn.method.args as AddAndAffirmWithMediatorsArgs;\n      const venueId = txMethod.venueId;\n      const settlementType = txMethod.settlementType;\n      const tradeDate = txMethod.tradeDate;\n      const valueDate = txMethod.valueDate;\n      const legs = txMethod.legs;\n      const portfolios = txMethod.portfolios;\n      const instructionMemo = txMethod.instructionMemo;\n      const mediators = txMethod.mediators;\n\n      const validationResult = AddAndAffirmWithMediatorsTransactionSchema.validate({\n        venueId,\n        settlementType,\n        tradeDate,\n        valueDate,\n        legs,\n        portfolios,\n        instructionMemo,\n        mediators,\n      });\n      if (validationResult.error) {\n        throw new Error(`Invalid transaction: ${validationResult.error.message}`);\n      }\n    }\n  }\n\n  private addAndAffirmWithMediators(\n    args: AddAndAffirmWithMediatorsArgs,\n    info: Interface.CreateBaseTxInfo\n  ): UnsignedTransaction {\n    return defineMethod(\n      {\n        method: {\n          args,\n          name: 'addAndAffirmWithMediators',\n          pallet: 'settlement',\n        },\n        ...info.baseTxInfo,\n      },\n      info.options\n    );\n  }\n}\n"]}

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

@@ -1,8 +1,30 @@
-import { BaseKey, BaseTransaction } from '@bitgo-beta/sdk-core';
+import { Transaction as SubstrateTransaction } from '@bitgo-beta/abstract-substrate';
 import { TxData } from './iface';
-export declare class Transaction extends BaseTransaction {
-    canSign(key: BaseKey): boolean;
-    toBroadcastFormat(): string;
+export declare class Transaction extends SubstrateTransaction {
+    /**
+     * Override the getAddressFormat method to return different values based on network type
+     * Returns 12 for mainnet and 42 for testnet
+     *
+     * @returns {number} The address format to use
+     * @override
+     */
+    protected getAddressFormat(): number;
+    /**
+     * Helper method to find a token name by assetId
+     * @param assetId The assetId to search for
+     * @returns The token name if found
+     * @throws {InvalidTransactionError} If no matching token is found
+     */
+    private getTokenNameByAssetId;
+    /** @inheritdoc */
     toJson(): TxData;
+    /**
+     * Load the input and output data on this transaction.
+     */
+    loadInputsAndOutputs(): void;
+    private decodeInputsAndOutputsForRegisterDidWithCDD;
+    private decodeInputsAndOutputsForPreApproveAsset;
+    private decodeInputsAndOutputsForSendToken;
+    private decodeInputsAndOutputsForRejectInstruction;
 }
 //# sourceMappingURL=transaction.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAChE,OAAO,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAEjC,qBAAa,WAAY,SAAQ,eAAe;IAC9C,OAAO,CAAC,GAAG,EAAE,OAAO,GAAG,OAAO;IAI9B,iBAAiB,IAAI,MAAM;IAI3B,MAAM,IAAI,MAAM;CAGjB"}
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,IAAI,oBAAoB,EAAkB,MAAM,gCAAgC,CAAC;AAKrG,OAAO,EAIL,MAAM,EAGP,MAAM,SAAS,CAAC;AAGjB,qBAAa,WAAY,SAAQ,oBAAoB;IACnD;;;;;;OAMG;IACH,SAAS,CAAC,gBAAgB,IAAI,MAAM;IAIpC;;;;;OAKG;IACH,OAAO,CAAC,qBAAqB;IAgB7B,kBAAkB;IAClB,MAAM,IAAI,MAAM;IAyDhB;;OAEG;IACH,oBAAoB,IAAI,IAAI;IAoB5B,OAAO,CAAC,2CAA2C;IAsBnD,OAAO,CAAC,wCAAwC;IAmBhD,OAAO,CAAC,kCAAkC;IAqB1C,OAAO,CAAC,0CAA0C;CAiBnD"}

package/dist/src/lib/transaction.js

@@ -1,17 +1,193 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Transaction = void 0;
+const abstract_substrate_1 = require("@bitgo-beta/abstract-substrate");
 const sdk_core_1 = require("@bitgo-beta/sdk-core");
-class Transaction extends sdk_core_1.BaseTransaction {
-    canSign(key) {
-        return false;
+const txwrapper_polkadot_1 = require("@substrate/txwrapper-polkadot");
+const keyring_1 = require("@polkadot/keyring");
+const statics_1 = require("@bitgo-beta/statics");
+const utils_1 = __importDefault(require("./utils"));
+class Transaction extends abstract_substrate_1.Transaction {
+    /**
+     * Override the getAddressFormat method to return different values based on network type
+     * Returns 12 for mainnet and 42 for testnet
+     *
+     * @returns {number} The address format to use
+     * @override
+     */
+    getAddressFormat() {
+        return utils_1.default.getAddressFormat(this._coinConfig.name);
     }
-    toBroadcastFormat() {
-        throw new Error('Method not implemented.');
+    /**
+     * Helper method to find a token name by assetId
+     * @param assetId The assetId to search for
+     * @returns The token name if found
+     * @throws {InvalidTransactionError} If no matching token is found
+     */
+    getTokenNameByAssetId(assetId) {
+        // Search through all coins to find the one with matching assetId
+        let foundToken;
+        statics_1.coins.forEach((coin) => {
+            if (coin instanceof statics_1.PolyxCoin && coin.assetId === assetId) {
+                foundToken = coin.name;
+            }
+        });
+        if (!foundToken) {
+            throw new sdk_core_1.InvalidTransactionError(`No token found for assetId: ${assetId}`);
+        }
+        return foundToken;
     }
+    /** @inheritdoc */
     toJson() {
-        throw new Error('Method not implemented.');
+        if (!this._substrateTransaction) {
+            throw new sdk_core_1.InvalidTransactionError('Empty transaction');
+        }
+        const decodedTx = (0, txwrapper_polkadot_1.decode)(this._substrateTransaction, {
+            metadataRpc: this._substrateTransaction.metadataRpc,
+            registry: this._registry,
+            isImmortalEra: abstract_substrate_1.utils.isZeroHex(this._substrateTransaction.era),
+        });
+        const result = {
+            id: txwrapper_polkadot_1.construct.txHash(this.toBroadcastFormat()),
+            sender: decodedTx.address,
+            referenceBlock: decodedTx.blockHash,
+            blockNumber: decodedTx.blockNumber,
+            genesisHash: decodedTx.genesisHash,
+            nonce: decodedTx.nonce,
+            specVersion: decodedTx.specVersion,
+            transactionVersion: decodedTx.transactionVersion,
+            eraPeriod: decodedTx.eraPeriod,
+            chainName: this._chainName,
+            tip: decodedTx.tip ? Number(decodedTx.tip) : 0,
+        };
+        const txMethod = decodedTx.method.args;
+        if (this.type === sdk_core_1.TransactionType.WalletInitialization) {
+            const { targetAccount } = txMethod;
+            const keypairDest = new abstract_substrate_1.KeyPair({
+                pub: Buffer.from((0, keyring_1.decodeAddress)(targetAccount)).toString('hex'),
+            });
+            result.to = keypairDest.getAddress(this.getAddressFormat());
+            result.amount = '0'; // RegisterDidWithCDD does not transfer any value
+        }
+        else if (this.type === sdk_core_1.TransactionType.TrustLine) {
+            const { assetId } = txMethod;
+            result.assetId = assetId;
+            result.sender = decodedTx.address;
+            result.amount = '0'; // Pre-approval does not transfer any value
+        }
+        else if (this.type === sdk_core_1.TransactionType.SendToken) {
+            const sendTokenArgs = txMethod;
+            result.fromDID = sendTokenArgs.legs[0].fungible.sender.did;
+            result.toDID = sendTokenArgs.legs[0].fungible.receiver.did;
+            result.amount = sendTokenArgs.legs[0].fungible.amount.toString();
+            result.assetId = sendTokenArgs.legs[0].fungible.assetId;
+            result.memo = sendTokenArgs.instructionMemo;
+        }
+        else if (this.type === sdk_core_1.TransactionType.RejectInstruction) {
+            const rejectInstructionArgs = txMethod;
+            result.instructionId = rejectInstructionArgs.id;
+            result.portfolioDID = rejectInstructionArgs.portfolio.did;
+            result.amount = '0'; // Reject instruction does not transfer any value
+        }
+        else {
+            return super.toJson();
+        }
+        return result;
+    }
+    /**
+     * Load the input and output data on this transaction.
+     */
+    loadInputsAndOutputs() {
+        super.loadInputsAndOutputs();
+        const decodedTx = (0, txwrapper_polkadot_1.decode)(this._substrateTransaction, {
+            metadataRpc: this._substrateTransaction.metadataRpc,
+            registry: this._registry,
+            isImmortalEra: abstract_substrate_1.utils.isZeroHex(this._substrateTransaction.era),
+        });
+        if (this.type === sdk_core_1.TransactionType.WalletInitialization) {
+            this.decodeInputsAndOutputsForRegisterDidWithCDD(decodedTx);
+        }
+        else if (this.type === sdk_core_1.TransactionType.TrustLine) {
+            this.decodeInputsAndOutputsForPreApproveAsset(decodedTx);
+        }
+        else if (this.type === sdk_core_1.TransactionType.SendToken) {
+            this.decodeInputsAndOutputsForSendToken(decodedTx);
+        }
+        else if (this.type === sdk_core_1.TransactionType.RejectInstruction) {
+            this.decodeInputsAndOutputsForRejectInstruction(decodedTx);
+        }
+    }
+    decodeInputsAndOutputsForRegisterDidWithCDD(decodedTx) {
+        const txMethod = decodedTx.method.args;
+        const keypairDest = new abstract_substrate_1.KeyPair({
+            pub: Buffer.from((0, keyring_1.decodeAddress)(txMethod.targetAccount)).toString('hex'),
+        });
+        const to = keypairDest.getAddress(this.getAddressFormat());
+        const value = '0';
+        const from = decodedTx.address;
+        this._inputs.push({
+            address: from,
+            value,
+            coin: this._coinConfig.name,
+        });
+        this._outputs.push({
+            address: to,
+            value,
+            coin: this._coinConfig.name,
+        });
+    }
+    decodeInputsAndOutputsForPreApproveAsset(decodedTx) {
+        const txMethod = decodedTx.method.args;
+        const sender = decodedTx.address;
+        const value = '0'; // Pre-approval does not transfer any value
+        const tokenName = this.getTokenNameByAssetId(txMethod.assetId);
+        this._inputs.push({
+            address: sender,
+            value,
+            coin: tokenName,
+        });
+        this._outputs.push({
+            address: sender, // In pre-approval, the output is the same as the input
+            value,
+            coin: tokenName,
+        });
+    }
+    decodeInputsAndOutputsForSendToken(decodedTx) {
+        const txMethod = decodedTx.method.args;
+        const fromDID = txMethod.legs[0].fungible.sender.did;
+        const toDID = txMethod.legs[0].fungible.receiver.did;
+        const amount = txMethod.legs[0].fungible.amount.toString();
+        const assetId = txMethod.legs[0].fungible.assetId;
+        const tokenName = this.getTokenNameByAssetId(assetId);
+        this._inputs.push({
+            address: fromDID,
+            value: amount,
+            coin: tokenName,
+        });
+        this._outputs.push({
+            address: toDID,
+            value: amount,
+            coin: tokenName,
+        });
+    }
+    decodeInputsAndOutputsForRejectInstruction(decodedTx) {
+        const txMethod = decodedTx.method.args;
+        const portfolioDID = txMethod.portfolio.did;
+        const value = '0'; // Reject instruction does not transfer any value
+        this._inputs.push({
+            address: portfolioDID,
+            value,
+            coin: this._coinConfig.name,
+        });
+        this._outputs.push({
+            address: portfolioDID,
+            value,
+            coin: this._coinConfig.name,
+        });
     }
 }
 exports.Transaction = Transaction;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJhbnNhY3Rpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL3RyYW5zYWN0aW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLG1EQUFnRTtBQUdoRSxNQUFhLFdBQVksU0FBUSwwQkFBZTtJQUM5QyxPQUFPLENBQUMsR0FBWTtRQUNsQixPQUFPLEtBQUssQ0FBQztJQUNmLENBQUM7SUFFRCxpQkFBaUI7UUFDZixNQUFNLElBQUksS0FBSyxDQUFDLHlCQUF5QixDQUFDLENBQUM7SUFDN0MsQ0FBQztJQUVELE1BQU07UUFDSixNQUFNLElBQUksS0FBSyxDQUFDLHlCQUF5QixDQUFDLENBQUM7SUFDN0MsQ0FBQztDQUNGO0FBWkQsa0NBWUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBCYXNlS2V5LCBCYXNlVHJhbnNhY3Rpb24gfSBmcm9tICdAYml0Z28tYmV0YS9zZGstY29yZSc7XG5pbXBvcnQgeyBUeERhdGEgfSBmcm9tICcuL2lmYWNlJztcblxuZXhwb3J0IGNsYXNzIFRyYW5zYWN0aW9uIGV4dGVuZHMgQmFzZVRyYW5zYWN0aW9uIHtcbiAgY2FuU2lnbihrZXk6IEJhc2VLZXkpOiBib29sZWFuIHtcbiAgICByZXR1cm4gZmFsc2U7XG4gIH1cblxuICB0b0Jyb2FkY2FzdEZvcm1hdCgpOiBzdHJpbmcge1xuICAgIHRocm93IG5ldyBFcnJvcignTWV0aG9kIG5vdCBpbXBsZW1lbnRlZC4nKTtcbiAgfVxuXG4gIHRvSnNvbigpOiBUeERhdGEge1xuICAgIHRocm93IG5ldyBFcnJvcignTWV0aG9kIG5vdCBpbXBsZW1lbnRlZC4nKTtcbiAgfVxufVxuIl19
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../../../src/lib/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import { Transaction as SubstrateTransaction, utils, KeyPair } from '@bitgo-beta/abstract-substrate';\nimport { InvalidTransactionError, TransactionType } from '@bitgo-beta/sdk-core';\nimport { construct, decode } from '@substrate/txwrapper-polkadot';\nimport { decodeAddress } from '@polkadot/keyring';\nimport { coins, PolyxCoin } from '@bitgo-beta/statics';\nimport {\n  DecodedTx,\n  RegisterDidWithCDDArgs,\n  PreApproveAssetArgs,\n  TxData,\n  AddAndAffirmWithMediatorsArgs,\n  RejectInstructionBuilderArgs,\n} from './iface';\nimport polyxUtils from './utils';\n\nexport class Transaction extends SubstrateTransaction {\n  /**\n   * Override the getAddressFormat method to return different values based on network type\n   * Returns 12 for mainnet and 42 for testnet\n   *\n   * @returns {number} The address format to use\n   * @override\n   */\n  protected getAddressFormat(): number {\n    return polyxUtils.getAddressFormat(this._coinConfig.name);\n  }\n\n  /**\n   * Helper method to find a token name by assetId\n   * @param assetId The assetId to search for\n   * @returns The token name if found\n   * @throws {InvalidTransactionError} If no matching token is found\n   */\n  private getTokenNameByAssetId(assetId: string): string {\n    // Search through all coins to find the one with matching assetId\n    let foundToken: string | undefined;\n    coins.forEach((coin) => {\n      if (coin instanceof PolyxCoin && coin.assetId === assetId) {\n        foundToken = coin.name;\n      }\n    });\n\n    if (!foundToken) {\n      throw new InvalidTransactionError(`No token found for assetId: ${assetId}`);\n    }\n\n    return foundToken;\n  }\n\n  /** @inheritdoc */\n  toJson(): TxData {\n    if (!this._substrateTransaction) {\n      throw new InvalidTransactionError('Empty transaction');\n    }\n\n    const decodedTx = decode(this._substrateTransaction, {\n      metadataRpc: this._substrateTransaction.metadataRpc,\n      registry: this._registry,\n      isImmortalEra: utils.isZeroHex(this._substrateTransaction.era),\n    }) as unknown as DecodedTx;\n\n    const result: TxData = {\n      id: construct.txHash(this.toBroadcastFormat()),\n      sender: decodedTx.address,\n      referenceBlock: decodedTx.blockHash,\n      blockNumber: decodedTx.blockNumber,\n      genesisHash: decodedTx.genesisHash,\n      nonce: decodedTx.nonce,\n      specVersion: decodedTx.specVersion,\n      transactionVersion: decodedTx.transactionVersion,\n      eraPeriod: decodedTx.eraPeriod,\n      chainName: this._chainName,\n      tip: decodedTx.tip ? Number(decodedTx.tip) : 0,\n    };\n\n    const txMethod = decodedTx.method.args;\n    if (this.type === TransactionType.WalletInitialization) {\n      const { targetAccount } = txMethod as RegisterDidWithCDDArgs;\n      const keypairDest = new KeyPair({\n        pub: Buffer.from(decodeAddress(targetAccount)).toString('hex'),\n      });\n      result.to = keypairDest.getAddress(this.getAddressFormat());\n      result.amount = '0'; // RegisterDidWithCDD does not transfer any value\n    } else if (this.type === TransactionType.TrustLine) {\n      const { assetId } = txMethod as PreApproveAssetArgs;\n      result.assetId = assetId;\n      result.sender = decodedTx.address;\n      result.amount = '0'; // Pre-approval does not transfer any value\n    } else if (this.type === TransactionType.SendToken) {\n      const sendTokenArgs = txMethod as AddAndAffirmWithMediatorsArgs;\n      result.fromDID = sendTokenArgs.legs[0].fungible.sender.did;\n      result.toDID = sendTokenArgs.legs[0].fungible.receiver.did;\n      result.amount = sendTokenArgs.legs[0].fungible.amount.toString();\n      result.assetId = sendTokenArgs.legs[0].fungible.assetId;\n      result.memo = sendTokenArgs.instructionMemo;\n    } else if (this.type === TransactionType.RejectInstruction) {\n      const rejectInstructionArgs = txMethod as RejectInstructionBuilderArgs;\n      result.instructionId = rejectInstructionArgs.id as string;\n      result.portfolioDID = rejectInstructionArgs.portfolio.did as string;\n      result.amount = '0'; // Reject instruction does not transfer any value\n    } else {\n      return super.toJson() as TxData;\n    }\n\n    return result;\n  }\n\n  /**\n   * Load the input and output data on this transaction.\n   */\n  loadInputsAndOutputs(): void {\n    super.loadInputsAndOutputs();\n\n    const decodedTx = decode(this._substrateTransaction, {\n      metadataRpc: this._substrateTransaction.metadataRpc,\n      registry: this._registry,\n      isImmortalEra: utils.isZeroHex(this._substrateTransaction.era),\n    }) as unknown as DecodedTx;\n\n    if (this.type === TransactionType.WalletInitialization) {\n      this.decodeInputsAndOutputsForRegisterDidWithCDD(decodedTx);\n    } else if (this.type === TransactionType.TrustLine) {\n      this.decodeInputsAndOutputsForPreApproveAsset(decodedTx);\n    } else if (this.type === TransactionType.SendToken) {\n      this.decodeInputsAndOutputsForSendToken(decodedTx);\n    } else if (this.type === TransactionType.RejectInstruction) {\n      this.decodeInputsAndOutputsForRejectInstruction(decodedTx);\n    }\n  }\n\n  private decodeInputsAndOutputsForRegisterDidWithCDD(decodedTx: DecodedTx) {\n    const txMethod = decodedTx.method.args as RegisterDidWithCDDArgs;\n    const keypairDest = new KeyPair({\n      pub: Buffer.from(decodeAddress(txMethod.targetAccount)).toString('hex'),\n    });\n    const to = keypairDest.getAddress(this.getAddressFormat());\n    const value = '0';\n    const from = decodedTx.address;\n\n    this._inputs.push({\n      address: from,\n      value,\n      coin: this._coinConfig.name,\n    });\n\n    this._outputs.push({\n      address: to,\n      value,\n      coin: this._coinConfig.name,\n    });\n  }\n\n  private decodeInputsAndOutputsForPreApproveAsset(decodedTx: DecodedTx) {\n    const txMethod = decodedTx.method.args as PreApproveAssetArgs;\n    const sender = decodedTx.address;\n    const value = '0'; // Pre-approval does not transfer any value\n    const tokenName = this.getTokenNameByAssetId(txMethod.assetId);\n\n    this._inputs.push({\n      address: sender,\n      value,\n      coin: tokenName,\n    });\n\n    this._outputs.push({\n      address: sender, // In pre-approval, the output is the same as the input\n      value,\n      coin: tokenName,\n    });\n  }\n\n  private decodeInputsAndOutputsForSendToken(decodedTx: DecodedTx) {\n    const txMethod = decodedTx.method.args as AddAndAffirmWithMediatorsArgs;\n    const fromDID = txMethod.legs[0].fungible.sender.did;\n    const toDID = txMethod.legs[0].fungible.receiver.did;\n    const amount = txMethod.legs[0].fungible.amount.toString();\n    const assetId = txMethod.legs[0].fungible.assetId;\n    const tokenName = this.getTokenNameByAssetId(assetId);\n\n    this._inputs.push({\n      address: fromDID,\n      value: amount,\n      coin: tokenName,\n    });\n\n    this._outputs.push({\n      address: toDID,\n      value: amount,\n      coin: tokenName,\n    });\n  }\n\n  private decodeInputsAndOutputsForRejectInstruction(decodedTx: DecodedTx) {\n    const txMethod = decodedTx.method.args as RejectInstructionBuilderArgs;\n    const portfolioDID = txMethod.portfolio.did;\n    const value = '0'; // Reject instruction does not transfer any value\n\n    this._inputs.push({\n      address: portfolioDID,\n      value,\n      coin: this._coinConfig.name,\n    });\n\n    this._outputs.push({\n      address: portfolioDID,\n      value,\n      coin: this._coinConfig.name,\n    });\n  }\n}\n"]}

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

@@ -1,12 +1,36 @@
 import { BaseTransactionBuilderFactory } from '@bitgo-beta/sdk-core';
-import { TransactionBuilder } from './transactionBuilder';
+import { BaseCoin as CoinConfig } from '@bitgo-beta/statics';
 import { TransferBuilder } from './transferBuilder';
+import { RegisterDidWithCDDBuilder } from './registerDidWithCDDBuilder';
+import { BondExtraBuilder } from './bondExtraBuilder';
+import { BatchStakingBuilder } from './batchStakingBuilder';
+import { BatchUnstakingBuilder } from './batchUnstakingBuilder';
+import { UnbondBuilder } from './unbondBuilder';
+import { WithdrawUnbondedBuilder } from './withdrawUnbondedBuilder';
+import { Interface, TransactionBuilder } from './';
+import { TxMethod } from './iface';
+import { Transaction as BaseTransaction } from '@bitgo-beta/abstract-substrate';
+import { Transaction as PolyxTransaction } from './transaction';
+import { PreApproveAssetBuilder } from './preApproveAssetBuilder';
+import { TokenTransferBuilder } from './tokenTransferBuilder';
+import { RejectInstructionBuilder } from './rejectInstructionBuilder';
+export type SupportedTransaction = BaseTransaction | PolyxTransaction;
 export declare class TransactionBuilderFactory extends BaseTransactionBuilderFactory {
-    /** @inheritdoc */
-    from(raw: string): TransactionBuilder;
-    /** @inheritdoc */
+    protected _material: Interface.Material;
+    constructor(_coinConfig: Readonly<CoinConfig>);
     getTransferBuilder(): TransferBuilder;
-    /** @inheritdoc */
+    getRegisterDidWithCDDBuilder(): RegisterDidWithCDDBuilder;
+    getPreApproveAssetBuilder(): PreApproveAssetBuilder;
+    getTokenTransferBuilder(): TokenTransferBuilder;
+    getRejectInstructionBuilder(): RejectInstructionBuilder;
+    getBondExtraBuilder(): BondExtraBuilder;
+    getBatchBuilder(): BatchStakingBuilder;
+    getBatchUnstakingBuilder(): BatchUnstakingBuilder;
+    getUnbondBuilder(): UnbondBuilder;
+    getWithdrawUnbondedBuilder(): WithdrawUnbondedBuilder;
     getWalletInitializationBuilder(): void;
+    from(rawTxn: string): TransactionBuilder<TxMethod, SupportedTransaction>;
+    material(material: Interface.Material): this;
+    private getBuilder;
 }
 //# sourceMappingURL=transactionBuilderFactory.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAC1D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEpD,qBAAa,yBAA0B,SAAQ,6BAA6B;IAC1E,kBAAkB;IAClB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB;IAIrC,kBAAkB;IAClB,kBAAkB,IAAI,eAAe;IAIrC,kBAAkB;IAClB,8BAA8B,IAAI,IAAI;CAGvC"}
+{"version":3,"file":"transactionBuilderFactory.d.ts","sourceRoot":"","sources":["../../../src/lib/transactionBuilderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAuB,MAAM,sBAAsB,CAAC;AAC1F,OAAO,EAAE,QAAQ,IAAI,UAAU,EAAE,MAAM,qBAAqB,CAAC;AAE7D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AACxE,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAC;AAC5D,OAAO,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAChE,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAChD,OAAO,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAEpE,OAAO,EAAE,SAAS,EAAqB,kBAAkB,EAAE,MAAM,IAAI,CAAC;AACtE,OAAO,EAAE,QAAQ,EAAgC,MAAM,SAAS,CAAC;AACjE,OAAO,EAAE,WAAW,IAAI,eAAe,EAAE,MAAM,gCAAgC,CAAC;AAChF,OAAO,EAAE,WAAW,IAAI,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAChE,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,MAAM,MAAM,oBAAoB,GAAG,eAAe,GAAG,gBAAgB,CAAC;AAEtE,qBAAa,yBAA0B,SAAQ,6BAA6B;IAC1E,SAAS,CAAC,SAAS,EAAE,SAAS,CAAC,QAAQ,CAAC;gBAE5B,WAAW,EAAE,QAAQ,CAAC,UAAU,CAAC;IAK7C,kBAAkB,IAAI,eAAe;IAIrC,4BAA4B,IAAI,yBAAyB;IAIzD,yBAAyB,IAAI,sBAAsB;IAInD,uBAAuB,IAAI,oBAAoB;IAI/C,2BAA2B,IAAI,wBAAwB;IAIvD,mBAAmB,IAAI,gBAAgB;IAIvC,eAAe,IAAI,mBAAmB;IAItC,wBAAwB,IAAI,qBAAqB;IAIjD,gBAAgB,IAAI,aAAa;IAIjC,0BAA0B,IAAI,uBAAuB;IAIrD,8BAA8B,IAAI,IAAI;IAItC,IAAI,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,CAAC,QAAQ,EAAE,oBAAoB,CAAC;IAMxE,QAAQ,CAAC,QAAQ,EAAE,SAAS,CAAC,QAAQ,GAAG,IAAI;IAK5C,OAAO,CAAC,UAAU;CAqDnB"}