@bitgo/sdk-coin-starknet 0.0.1 → 1.2.0

package/dist/src/starknet.js

@@ -0,0 +1,127 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Starknet = void 0;
+const sdk_core_1 = require("@bitgo/sdk-core");
+const statics_1 = require("@bitgo/statics");
+const crypto_1 = require("crypto");
+const transactionBuilderFactory_1 = require("./lib/transactionBuilderFactory");
+const utils_1 = __importDefault(require("./lib/utils"));
+const sdk_lib_mpc_1 = require("@bitgo/sdk-lib-mpc");
+class Starknet extends sdk_core_1.BaseCoin {
+    constructor(bitgo, staticsCoin) {
+        super(bitgo);
+        if (!staticsCoin) {
+            throw new Error('missing required constructor parameter staticsCoin');
+        }
+        this._staticsCoin = staticsCoin;
+    }
+    static createInstance(bitgo, staticsCoin) {
+        return new Starknet(bitgo, staticsCoin);
+    }
+    getChain() {
+        return this._staticsCoin.name;
+    }
+    getBaseChain() {
+        return this._staticsCoin.name;
+    }
+    getFamily() {
+        return this._staticsCoin.family;
+    }
+    getFullName() {
+        return this._staticsCoin.fullName;
+    }
+    getBaseFactor() {
+        return Math.pow(10, this._staticsCoin.decimalPlaces);
+    }
+    async explainTransaction(params) {
+        const factory = this.getBuilderFactory();
+        const txBuilder = await factory.from(params.transactionHex);
+        const transaction = await txBuilder.build();
+        return transaction.explainTransaction();
+    }
+    async verifyTransaction(params) {
+        const { txParams, txPrebuild } = params;
+        const txHex = txPrebuild?.txHex;
+        if (!txHex) {
+            throw new Error('txHex is required');
+        }
+        const explainedTx = await this.explainTransaction({ transactionHex: txHex });
+        if (Array.isArray(txParams.recipients) && txParams.recipients.length > 0) {
+            if (txParams.recipients.length > 1) {
+                throw new Error(`${this.getChain()} doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`);
+            }
+            if (explainedTx.outputs.length !== 1) {
+                throw new Error('Tx outputs does not match with expected txParams recipients');
+            }
+            const output = explainedTx.outputs[0];
+            const recipient = txParams.recipients[0];
+            const normalizedOutput = utils_1.default.normalizeAddress(output.address);
+            const normalizedRecipient = utils_1.default.normalizeAddress(recipient.address);
+            if (normalizedOutput !== normalizedRecipient || output.amount !== recipient.amount) {
+                throw new Error('Tx outputs does not match with expected txParams recipients');
+            }
+        }
+        return true;
+    }
+    async isWalletAddress(params) {
+        const { address } = params;
+        if (!this.isValidAddress(address)) {
+            throw new sdk_core_1.InvalidAddressError(`invalid address: ${address}`);
+        }
+        const result = await (0, sdk_core_1.verifyMPCWalletAddress)({ ...params, keyCurve: 'secp256k1' }, this.isValidAddress.bind(this), (pubKey) => utils_1.default.getAddressFromPublicKey(pubKey));
+        if (!result) {
+            throw new sdk_core_1.UnexpectedAddressError(`address validation failure: address ${address} is not a wallet address`);
+        }
+        return true;
+    }
+    async parseTransaction(params) {
+        return {};
+    }
+    generateKeyPair(seed) {
+        return utils_1.default.generateKeyPair(seed);
+    }
+    isValidAddress(address) {
+        return utils_1.default.isValidAddress(address);
+    }
+    // Starknet is TSS-only; signing is handled by threshold ECDSA in wallet-platform/OVC.
+    async signTransaction(_params) {
+        throw new sdk_core_1.MethodNotImplementedError('signTransaction');
+    }
+    isValidPub(key) {
+        return utils_1.default.isValidPublicKey(key);
+    }
+    isValidPrv(key) {
+        return utils_1.default.isValidPrivateKey(key);
+    }
+    /** @inheritDoc */
+    supportsTss() {
+        return true;
+    }
+    /** inherited doc */
+    getDefaultMultisigType() {
+        return sdk_core_1.multisigTypes.tss;
+    }
+    /** @inheritDoc */
+    getMPCAlgorithm() {
+        return 'ecdsa';
+    }
+    /** @inheritDoc **/
+    getHashFunction() {
+        return (0, crypto_1.createHash)('sha256');
+    }
+    getBuilderFactory() {
+        return new transactionBuilderFactory_1.TransactionBuilderFactory(statics_1.coins.get(this.getBaseChain()));
+    }
+    /** @inheritDoc */
+    auditDecryptedKey({ multiSigType, prv, publicKey }) {
+        if (multiSigType !== 'tss') {
+            throw new Error('Unsupported multisigtype');
+        }
+        (0, sdk_lib_mpc_1.auditEcdsaPrivateKey)(prv, publicKey);
+    }
+}
+exports.Starknet = Starknet;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"starknet.js","sourceRoot":"","sources":["../../src/starknet.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AuditDecryptedKeyParams,\n  BaseCoin,\n  BitGoBase,\n  InvalidAddressError,\n  KeyPair,\n  MethodNotImplementedError,\n  MPCAlgorithm,\n  MultisigType,\n  multisigTypes,\n  ParsedTransaction,\n  ParseTransactionOptions,\n  SignedTransaction,\n  SignTransactionOptions,\n  VerifyTransactionOptions,\n  verifyMPCWalletAddress,\n  UnexpectedAddressError,\n} from '@bitgo/sdk-core';\nimport { coins, BaseCoin as StaticsBaseCoin } from '@bitgo/statics';\nimport { createHash, Hash } from 'crypto';\n\nimport { StarknetTransactionExplanation, TransactionHexParams, TssVerifyStarknetAddressOptions } from './lib/iface';\nimport { TransactionBuilderFactory } from './lib/transactionBuilderFactory';\nimport utils from './lib/utils';\nimport { auditEcdsaPrivateKey } from '@bitgo/sdk-lib-mpc';\n\nexport class Starknet extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n  protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this._staticsCoin = staticsCoin;\n  }\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Starknet(bitgo, staticsCoin);\n  }\n\n  getChain(): string {\n    return this._staticsCoin.name;\n  }\n\n  getBaseChain(): string {\n    return this._staticsCoin.name;\n  }\n\n  getFamily(): string {\n    return this._staticsCoin.family;\n  }\n\n  getFullName(): string {\n    return this._staticsCoin.fullName;\n  }\n\n  getBaseFactor(): number {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  async explainTransaction(params: TransactionHexParams): Promise<StarknetTransactionExplanation> {\n    const factory = this.getBuilderFactory();\n    const txBuilder = await factory.from(params.transactionHex);\n    const transaction = await txBuilder.build();\n    return transaction.explainTransaction();\n  }\n\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    const { txParams, txPrebuild } = params;\n    const txHex = txPrebuild?.txHex;\n    if (!txHex) {\n      throw new Error('txHex is required');\n    }\n\n    const explainedTx = await this.explainTransaction({ transactionHex: txHex });\n\n    if (Array.isArray(txParams.recipients) && txParams.recipients.length > 0) {\n      if (txParams.recipients.length > 1) {\n        throw new Error(\n          `${this.getChain()} doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`\n        );\n      }\n\n      if (explainedTx.outputs.length !== 1) {\n        throw new Error('Tx outputs does not match with expected txParams recipients');\n      }\n\n      const output = explainedTx.outputs[0];\n      const recipient = txParams.recipients[0];\n      const normalizedOutput = utils.normalizeAddress(output.address);\n      const normalizedRecipient = utils.normalizeAddress(recipient.address);\n      if (normalizedOutput !== normalizedRecipient || output.amount !== recipient.amount) {\n        throw new Error('Tx outputs does not match with expected txParams recipients');\n      }\n    }\n    return true;\n  }\n\n  async isWalletAddress(params: TssVerifyStarknetAddressOptions): Promise<boolean> {\n    const { address } = params;\n\n    if (!this.isValidAddress(address)) {\n      throw new InvalidAddressError(`invalid address: ${address}`);\n    }\n\n    const result = await verifyMPCWalletAddress(\n      { ...params, keyCurve: 'secp256k1' },\n      this.isValidAddress.bind(this),\n      (pubKey) => utils.getAddressFromPublicKey(pubKey)\n    );\n\n    if (!result) {\n      throw new UnexpectedAddressError(`address validation failure: address ${address} is not a wallet address`);\n    }\n\n    return true;\n  }\n\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    return {};\n  }\n\n  public generateKeyPair(seed?: Buffer): KeyPair {\n    return utils.generateKeyPair(seed);\n  }\n\n  isValidAddress(address: string): boolean {\n    return utils.isValidAddress(address);\n  }\n\n  // Starknet is TSS-only; signing is handled by threshold ECDSA in wallet-platform/OVC.\n  async signTransaction(_params: SignTransactionOptions): Promise<SignedTransaction> {\n    throw new MethodNotImplementedError('signTransaction');\n  }\n\n  isValidPub(key: string): boolean {\n    return utils.isValidPublicKey(key);\n  }\n\n  isValidPrv(key: string): boolean {\n    return utils.isValidPrivateKey(key);\n  }\n\n  /** @inheritDoc */\n  supportsTss(): boolean {\n    return true;\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.tss;\n  }\n\n  /** @inheritDoc */\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'ecdsa';\n  }\n\n  /** @inheritDoc **/\n  getHashFunction(): Hash {\n    return createHash('sha256');\n  }\n\n  private getBuilderFactory(): TransactionBuilderFactory {\n    return new TransactionBuilderFactory(coins.get(this.getBaseChain()));\n  }\n\n  /** @inheritDoc */\n  auditDecryptedKey({ multiSigType, prv, publicKey }: AuditDecryptedKeyParams): void {\n    if (multiSigType !== 'tss') {\n      throw new Error('Unsupported multisigtype');\n    }\n    auditEcdsaPrivateKey(prv as string, publicKey as string);\n  }\n}\n"]}

package/dist/test/resources/starknet.d.ts

@@ -0,0 +1,98 @@
+import { StarknetTransactionType } from '../../src/lib/iface';
+export declare const Accounts: {
+    account1: {
+        secretKey: string;
+        publicKey: string;
+        address: string;
+    };
+    account2: {
+        secretKey: string;
+        publicKey: string;
+        address: string;
+    };
+    account3: {
+        publicKey: string;
+        secretKey: string;
+        address: string;
+    };
+    errorsAccounts: {
+        account1: {
+            secretKey: string;
+            publicKey: string;
+            address: string;
+        };
+        account2: {
+            secretKey: string;
+            publicKey: string;
+            address: string;
+        };
+    };
+};
+export declare const StarknetTransactionData: {
+    senderAddress: string;
+    nonce: string;
+    calls: {
+        contractAddress: string;
+        entrypoint: string;
+        calldata: string[];
+    }[];
+    chainId: string;
+    transactionType: StarknetTransactionType;
+};
+export declare const rawTx: {
+    transfer: {
+        unsigned: string;
+        signed: string;
+    };
+};
+export declare const TEST_AMOUNTS: {
+    small: string;
+    medium: string;
+    large: string;
+};
+export declare const SandboxTransferData: {
+    senderAddress: string;
+    receiverAddress: string;
+    amount: string;
+    chainId: string;
+    tokenContract: string;
+    resourceBounds: {
+        l2_gas: {
+            max_amount: string;
+            max_price_per_unit: string;
+        };
+        l1_gas: {
+            max_amount: string;
+            max_price_per_unit: string;
+        };
+        l1_data_gas: {
+            max_amount: string;
+            max_price_per_unit: string;
+        };
+    };
+};
+export declare const KnownGoodInvokeTx: {
+    senderAddress: string;
+    receiverAddress: string;
+    amount: string;
+    tokenContract: string;
+    nonce: string;
+    chainId: string;
+    tip: string;
+    resourceBounds: {
+        l2_gas: {
+            max_amount: string;
+            max_price_per_unit: string;
+        };
+        l1_gas: {
+            max_amount: string;
+            max_price_per_unit: string;
+        };
+        l1_data_gas: {
+            max_amount: string;
+            max_price_per_unit: string;
+        };
+    };
+    expectedTxHash: string;
+};
+//# sourceMappingURL=starknet.d.ts.map

package/dist/test/resources/starknet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"starknet.d.ts","sourceRoot":"","sources":["../../../test/resources/starknet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAE9D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+BpB,CAAC;AAEF,eAAO,MAAM,uBAAuB;;;;;;;;;;CAYnC,CAAC;AA2BF,eAAO,MAAM,KAAK;;;;;CAKjB,CAAC;AAEF,eAAO,MAAM,YAAY;;;;CAIxB,CAAC;AAEF,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;CAW/B,CAAC;AAIF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;CAc7B,CAAC"}

package/dist/test/resources/starknet.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KnownGoodInvokeTx = exports.SandboxTransferData = exports.TEST_AMOUNTS = exports.rawTx = exports.StarknetTransactionData = exports.Accounts = void 0;
+const iface_1 = require("../../src/lib/iface");
+exports.Accounts = {
+    account1: {
+        secretKey: 'c5bccb8f471c5c9eb6483aa77ee4b700003b1e12df430a24d93238eb378b968b',
+        publicKey: '042ab77b959e28c4fa47fa8fb9e57cec3d66df5684d076ac2e4c5f28fd69a23dd31a59f908c8add51eab3530b4ac5d015166eaf2198c52fa9a8df7cfaeb8fdb7d4',
+        address: '0x05a63dd0563db1ab71b5ffd25a6b4aaf5730de5de53d64423e4293fc8b3e12f6',
+    },
+    account2: {
+        secretKey: '73312c28d0d455b6a29a9a66811ffda94f3db6bfd57bf5c2bed917ee5928e15f',
+        publicKey: '044e01707f70f6ad8d9f79e5f2c2f0bac5e91520e5e2491354c6c7827b59d44148847f9180ac9679a6ce66f69c330551a99f8f9b7419c437705602a54c258a9dfe',
+        address: '0x02e153ef86ae7682160f69f4218b6a41aebc79ca11dabb1a4fcd7cc55f16f977',
+    },
+    account3: {
+        publicKey: '042281378584012843130dce9b19002f88a949f237397e2f6cda2db1392d54f6345faaf51c384fbfe4e8f67eb12fdb53732d2ddfe7470f9310a0bf824dad3f6b1b',
+        secretKey: '7b4de3d8cc3e312c70f674b52f11818205546ca7036c8071997c46e429160dc3',
+        address: '0x00b45a0e9f4b1eff1e2d2e528ae7c443655346c62750518217fb82cbce4dbb54',
+    },
+    errorsAccounts: {
+        account1: {
+            secretKey: 'not ok',
+            publicKey: 'not ok',
+            address: 'not ok',
+        },
+        account2: {
+            secretKey: 'test_test',
+            publicKey: 'test_test',
+            address: 'invalid',
+        },
+    },
+};
+exports.StarknetTransactionData = {
+    senderAddress: exports.Accounts.account1.address,
+    nonce: '0',
+    calls: [
+        {
+            contractAddress: '0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d',
+            entrypoint: 'transfer',
+            calldata: [exports.Accounts.account2.address, '0xde0b6b3a7640000', '0x0'],
+        },
+    ],
+    chainId: '0x534e5f5345504f4c4941',
+    transactionType: iface_1.StarknetTransactionType.INVOKE,
+};
+// Raw transaction hex (JSON serialized to hex)
+const rawTxUnsigned = Buffer.from(JSON.stringify({
+    senderAddress: exports.Accounts.account1.address,
+    calls: exports.StarknetTransactionData.calls,
+    nonce: '0',
+    chainId: '0x534e5f5345504f4c4941',
+    transactionType: iface_1.StarknetTransactionType.INVOKE,
+}), 'utf-8').toString('hex');
+const rawTxSigned = Buffer.from(JSON.stringify({
+    senderAddress: exports.Accounts.account1.address,
+    calls: exports.StarknetTransactionData.calls,
+    nonce: '0',
+    chainId: '0x534e5f5345504f4c4941',
+    transactionType: iface_1.StarknetTransactionType.INVOKE,
+    signature: ['0xabc123', '0xdef456', '0x789012', '0x345678', '0x0'],
+    transactionHash: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',
+}), 'utf-8').toString('hex');
+exports.rawTx = {
+    transfer: {
+        unsigned: rawTxUnsigned,
+        signed: rawTxSigned,
+    },
+};
+exports.TEST_AMOUNTS = {
+    small: '1000000000000000000',
+    medium: '10000000000000000000',
+    large: '999999999999999999999999',
+};
+exports.SandboxTransferData = {
+    senderAddress: '0x1559292d3f9ea355458f83adf235b400e79786af5dc5e3b50f5505caa2bdc84',
+    receiverAddress: '0x4a1e86ae265e6e6ecbea5be7f67117c3540f8aaf2ad7f1cfec33c53080f05af',
+    amount: '1000000000000000000',
+    chainId: '0x534e5f5345504f4c4941',
+    tokenContract: '0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d',
+    resourceBounds: {
+        l2_gas: { max_amount: '0x1c9c380', max_price_per_unit: '0x174876e800' },
+        l1_gas: { max_amount: '0x0', max_price_per_unit: '0x5af3107a4000' },
+        l1_data_gas: { max_amount: '0x3e8', max_price_per_unit: '0x2540be400' },
+    },
+};
+// Known-good tx from coins-sandbox/strkMPC/transferLocal.ts (block 9537253, Sepolia)
+// All inputs from the sandbox script; nonce confirmed via Voyager explorer.
+exports.KnownGoodInvokeTx = {
+    senderAddress: '0x1559292d3f9ea355458f83adf235b400e79786af5dc5e3b50f5505caa2bdc84',
+    receiverAddress: '0x4a1e86ae265e6e6ecbea5be7f67117c3540f8aaf2ad7f1cfec33c53080f05af',
+    amount: '1000000000000000000',
+    tokenContract: '0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d',
+    nonce: '0x8',
+    chainId: '0x534e5f5345504f4c4941',
+    tip: '0x0',
+    resourceBounds: {
+        l2_gas: { max_amount: '0x1c9c380', max_price_per_unit: '0x174876e800' },
+        l1_gas: { max_amount: '0x0', max_price_per_unit: '0x5af3107a4000' },
+        l1_data_gas: { max_amount: '0x3e8', max_price_per_unit: '0x2540be400' },
+    },
+    expectedTxHash: '0x739a72831c7f53634a2ffc94b78b61985e3cdffbad09ab20a1480e1bec9bdf2',
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"starknet.js","sourceRoot":"","sources":["../../../test/resources/starknet.ts"],"names":[],"mappings":"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","sourcesContent":["import { StarknetTransactionType } from '../../src/lib/iface';\n\nexport const Accounts = {\n  account1: {\n    secretKey: 'c5bccb8f471c5c9eb6483aa77ee4b700003b1e12df430a24d93238eb378b968b',\n    publicKey:\n      '042ab77b959e28c4fa47fa8fb9e57cec3d66df5684d076ac2e4c5f28fd69a23dd31a59f908c8add51eab3530b4ac5d015166eaf2198c52fa9a8df7cfaeb8fdb7d4',\n    address: '0x05a63dd0563db1ab71b5ffd25a6b4aaf5730de5de53d64423e4293fc8b3e12f6',\n  },\n  account2: {\n    secretKey: '73312c28d0d455b6a29a9a66811ffda94f3db6bfd57bf5c2bed917ee5928e15f',\n    publicKey:\n      '044e01707f70f6ad8d9f79e5f2c2f0bac5e91520e5e2491354c6c7827b59d44148847f9180ac9679a6ce66f69c330551a99f8f9b7419c437705602a54c258a9dfe',\n    address: '0x02e153ef86ae7682160f69f4218b6a41aebc79ca11dabb1a4fcd7cc55f16f977',\n  },\n  account3: {\n    publicKey:\n      '042281378584012843130dce9b19002f88a949f237397e2f6cda2db1392d54f6345faaf51c384fbfe4e8f67eb12fdb53732d2ddfe7470f9310a0bf824dad3f6b1b',\n    secretKey: '7b4de3d8cc3e312c70f674b52f11818205546ca7036c8071997c46e429160dc3',\n    address: '0x00b45a0e9f4b1eff1e2d2e528ae7c443655346c62750518217fb82cbce4dbb54',\n  },\n  errorsAccounts: {\n    account1: {\n      secretKey: 'not ok',\n      publicKey: 'not ok',\n      address: 'not ok',\n    },\n    account2: {\n      secretKey: 'test_test',\n      publicKey: 'test_test',\n      address: 'invalid',\n    },\n  },\n};\n\nexport const StarknetTransactionData = {\n  senderAddress: Accounts.account1.address,\n  nonce: '0',\n  calls: [\n    {\n      contractAddress: '0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d',\n      entrypoint: 'transfer',\n      calldata: [Accounts.account2.address, '0xde0b6b3a7640000', '0x0'],\n    },\n  ],\n  chainId: '0x534e5f5345504f4c4941',\n  transactionType: StarknetTransactionType.INVOKE,\n};\n\n// Raw transaction hex (JSON serialized to hex)\nconst rawTxUnsigned = Buffer.from(\n  JSON.stringify({\n    senderAddress: Accounts.account1.address,\n    calls: StarknetTransactionData.calls,\n    nonce: '0',\n    chainId: '0x534e5f5345504f4c4941',\n    transactionType: StarknetTransactionType.INVOKE,\n  }),\n  'utf-8'\n).toString('hex');\n\nconst rawTxSigned = Buffer.from(\n  JSON.stringify({\n    senderAddress: Accounts.account1.address,\n    calls: StarknetTransactionData.calls,\n    nonce: '0',\n    chainId: '0x534e5f5345504f4c4941',\n    transactionType: StarknetTransactionType.INVOKE,\n    signature: ['0xabc123', '0xdef456', '0x789012', '0x345678', '0x0'],\n    transactionHash: '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef',\n  }),\n  'utf-8'\n).toString('hex');\n\nexport const rawTx = {\n  transfer: {\n    unsigned: rawTxUnsigned,\n    signed: rawTxSigned,\n  },\n};\n\nexport const TEST_AMOUNTS = {\n  small: '1000000000000000000',\n  medium: '10000000000000000000',\n  large: '999999999999999999999999',\n};\n\nexport const SandboxTransferData = {\n  senderAddress: '0x1559292d3f9ea355458f83adf235b400e79786af5dc5e3b50f5505caa2bdc84',\n  receiverAddress: '0x4a1e86ae265e6e6ecbea5be7f67117c3540f8aaf2ad7f1cfec33c53080f05af',\n  amount: '1000000000000000000',\n  chainId: '0x534e5f5345504f4c4941',\n  tokenContract: '0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d',\n  resourceBounds: {\n    l2_gas: { max_amount: '0x1c9c380', max_price_per_unit: '0x174876e800' },\n    l1_gas: { max_amount: '0x0', max_price_per_unit: '0x5af3107a4000' },\n    l1_data_gas: { max_amount: '0x3e8', max_price_per_unit: '0x2540be400' },\n  },\n};\n\n// Known-good tx from coins-sandbox/strkMPC/transferLocal.ts (block 9537253, Sepolia)\n// All inputs from the sandbox script; nonce confirmed via Voyager explorer.\nexport const KnownGoodInvokeTx = {\n  senderAddress: '0x1559292d3f9ea355458f83adf235b400e79786af5dc5e3b50f5505caa2bdc84',\n  receiverAddress: '0x4a1e86ae265e6e6ecbea5be7f67117c3540f8aaf2ad7f1cfec33c53080f05af',\n  amount: '1000000000000000000',\n  tokenContract: '0x04718f5a0fc34cc1af16a1cdee98ffb20c31f5cd61d6ab07201858f4287c938d',\n  nonce: '0x8',\n  chainId: '0x534e5f5345504f4c4941',\n  tip: '0x0',\n  resourceBounds: {\n    l2_gas: { max_amount: '0x1c9c380', max_price_per_unit: '0x174876e800' },\n    l1_gas: { max_amount: '0x0', max_price_per_unit: '0x5af3107a4000' },\n    l1_data_gas: { max_amount: '0x3e8', max_price_per_unit: '0x2540be400' },\n  },\n  expectedTxHash: '0x739a72831c7f53634a2ffc94b78b61985e3cdffbad09ab20a1480e1bec9bdf2',\n};\n"]}

package/dist/test/unit/keyPair.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=keyPair.d.ts.map

package/dist/test/unit/keyPair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keyPair.d.ts","sourceRoot":"","sources":["../../../test/unit/keyPair.ts"],"names":[],"mappings":""}

package/dist/test/unit/keyPair.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const should_1 = __importDefault(require("should"));
+const keyPair_1 = require("../../src/lib/keyPair");
+const starknet_1 = require("../resources/starknet");
+describe('Starknet KeyPair', () => {
+    describe('Constructor', () => {
+        it('should create keypair from public key only', () => {
+            const kp = new keyPair_1.KeyPair({ pub: starknet_1.Accounts.account1.publicKey });
+            const keys = kp.getKeys();
+            should_1.default.exist(keys.pub);
+        });
+        it('should create keypair from private key', () => {
+            const kp = new keyPair_1.KeyPair({ prv: starknet_1.Accounts.account1.secretKey });
+            const keys = kp.getKeys();
+            should_1.default.exist(keys.pub);
+            should_1.default.exist(keys.prv);
+        });
+        it('should create random keypair when no source', () => {
+            const kp = new keyPair_1.KeyPair();
+            const keys = kp.getKeys();
+            should_1.default.exist(keys.pub);
+            should_1.default.exist(keys.prv);
+        });
+        it('should throw on invalid public key', () => {
+            should_1.default.throws(() => new keyPair_1.KeyPair({ pub: 'invalid_key_format' }));
+        });
+        it('should throw on invalid private key', () => {
+            should_1.default.throws(() => new keyPair_1.KeyPair({ prv: 'not_a_valid_key' }));
+        });
+    });
+    describe('Key Generation', () => {
+        it('should create unique key pairs each time', () => {
+            const kp1 = new keyPair_1.KeyPair();
+            const kp2 = new keyPair_1.KeyPair();
+            kp1.getKeys().pub.should.not.equal(kp2.getKeys().pub);
+        });
+    });
+    describe('getAddress', () => {
+        it('should return a valid Starknet address from keypair', () => {
+            const kp = new keyPair_1.KeyPair({ pub: starknet_1.Accounts.account1.publicKey });
+            const address = kp.getAddress();
+            should_1.default.exist(address);
+            address.should.startWith('0x');
+        });
+        it('should return different addresses for different keys', () => {
+            const kp1 = new keyPair_1.KeyPair({ pub: starknet_1.Accounts.account1.publicKey });
+            const kp2 = new keyPair_1.KeyPair({ pub: starknet_1.Accounts.account2.publicKey });
+            kp1.getAddress().should.not.equal(kp2.getAddress());
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/unit/starknet.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=starknet.d.ts.map

package/dist/test/unit/starknet.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"starknet.d.ts","sourceRoot":"","sources":["../../../test/unit/starknet.ts"],"names":[],"mappings":""}

package/dist/test/unit/starknet.js

@@ -0,0 +1,126 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sdk_test_1 = require("@bitgo/sdk-test");
+const sdk_api_1 = require("@bitgo/sdk-api");
+const index_1 = require("../../src/index");
+const testData = __importStar(require("../resources/starknet"));
+const should_1 = __importDefault(require("should"));
+const utils_1 = require("../../src/lib/utils");
+describe('Starknet', function () {
+    let bitgo;
+    let basecoin;
+    before(async function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'test' });
+        bitgo.safeRegister('starknet', index_1.Starknet.createInstance);
+        bitgo.safeRegister('tstarknet', index_1.Starknet.createInstance);
+        bitgo.initializeTestVars();
+        basecoin = bitgo.coin('starknet');
+    });
+    it('should return the right info', function () {
+        const starknet = bitgo.coin('starknet');
+        const tstarknet = bitgo.coin('tstarknet');
+        starknet.getChain().should.equal('starknet');
+        starknet.getFamily().should.equal('starknet');
+        starknet.getFullName().should.equal('Starknet');
+        starknet.getBaseFactor().should.equal(1e18);
+        starknet.supportsTss().should.equal(true);
+        tstarknet.getChain().should.equal('tstarknet');
+        tstarknet.getFamily().should.equal('starknet');
+        tstarknet.getFullName().should.equal('Testnet Starknet');
+        tstarknet.getBaseFactor().should.equal(1e18);
+        tstarknet.supportsTss().should.equal(true);
+    });
+    describe('Address validation', () => {
+        it('should validate a correct Starknet address', function () {
+            basecoin.isValidAddress(testData.Accounts.account1.address).should.equal(true);
+        });
+        it('should validate a second correct address', function () {
+            basecoin.isValidAddress(testData.Accounts.account2.address).should.equal(true);
+        });
+        it('should reject an obviously invalid address', function () {
+            basecoin.isValidAddress('not_an_address').should.equal(false);
+        });
+        it('should reject an empty address', function () {
+            basecoin.isValidAddress('').should.equal(false);
+        });
+    });
+    describe('Address derivation', () => {
+        it('should derive correct address from public key for account1', function () {
+            const derived = (0, utils_1.getAddressFromPublicKey)(testData.Accounts.account1.publicKey);
+            derived.should.equal(testData.Accounts.account1.address);
+        });
+        it('should derive correct address from public key for account2', function () {
+            const derived = (0, utils_1.getAddressFromPublicKey)(testData.Accounts.account2.publicKey);
+            derived.should.equal(testData.Accounts.account2.address);
+        });
+        it('should derive correct address from public key for account3', function () {
+            const derived = (0, utils_1.getAddressFromPublicKey)(testData.Accounts.account3.publicKey);
+            derived.should.equal(testData.Accounts.account3.address);
+        });
+    });
+    describe('Public key validation', () => {
+        it('should validate a correct uncompressed public key', function () {
+            basecoin.isValidPub(testData.Accounts.account1.publicKey).should.equal(true);
+        });
+        it('should reject an invalid public key', function () {
+            basecoin.isValidPub('invalid-public-key').should.equal(false);
+        });
+    });
+    describe('MPC support', () => {
+        it('should support TSS', function () {
+            basecoin.supportsTss().should.equal(true);
+        });
+        it('should return ECDSA as MPC algorithm', function () {
+            basecoin.getMPCAlgorithm().should.equal('ecdsa');
+        });
+    });
+    describe('Key pair generation', () => {
+        it('should generate a key pair', function () {
+            const keyPair = basecoin.generateKeyPair();
+            should_1.default.exist(keyPair.pub);
+            should_1.default.exist(keyPair.prv);
+        });
+        it('should generate different key pairs each time', function () {
+            const kp1 = basecoin.generateKeyPair();
+            const kp2 = basecoin.generateKeyPair();
+            kp1.pub.should.not.equal(kp2.pub);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"starknet.js","sourceRoot":"","sources":["../../../test/unit/starknet.ts"],"names":[],"mappings":"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","sourcesContent":["import { TestBitGo, TestBitGoAPI } from '@bitgo/sdk-test';\nimport { BitGoAPI } from '@bitgo/sdk-api';\nimport { Starknet } from '../../src/index';\nimport * as testData from '../resources/starknet';\nimport should from 'should';\nimport { getAddressFromPublicKey } from '../../src/lib/utils';\n\ndescribe('Starknet', function () {\n  let bitgo: TestBitGoAPI;\n  let basecoin;\n\n  before(async function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'test' });\n    bitgo.safeRegister('starknet', Starknet.createInstance);\n    bitgo.safeRegister('tstarknet', Starknet.createInstance);\n    bitgo.initializeTestVars();\n    basecoin = bitgo.coin('starknet');\n  });\n\n  it('should return the right info', function () {\n    const starknet = bitgo.coin('starknet');\n    const tstarknet = bitgo.coin('tstarknet');\n\n    starknet.getChain().should.equal('starknet');\n    starknet.getFamily().should.equal('starknet');\n    starknet.getFullName().should.equal('Starknet');\n    starknet.getBaseFactor().should.equal(1e18);\n    starknet.supportsTss().should.equal(true);\n\n    tstarknet.getChain().should.equal('tstarknet');\n    tstarknet.getFamily().should.equal('starknet');\n    tstarknet.getFullName().should.equal('Testnet Starknet');\n    tstarknet.getBaseFactor().should.equal(1e18);\n    tstarknet.supportsTss().should.equal(true);\n  });\n\n  describe('Address validation', () => {\n    it('should validate a correct Starknet address', function () {\n      basecoin.isValidAddress(testData.Accounts.account1.address).should.equal(true);\n    });\n\n    it('should validate a second correct address', function () {\n      basecoin.isValidAddress(testData.Accounts.account2.address).should.equal(true);\n    });\n\n    it('should reject an obviously invalid address', function () {\n      basecoin.isValidAddress('not_an_address').should.equal(false);\n    });\n\n    it('should reject an empty address', function () {\n      basecoin.isValidAddress('').should.equal(false);\n    });\n  });\n\n  describe('Address derivation', () => {\n    it('should derive correct address from public key for account1', function () {\n      const derived = getAddressFromPublicKey(testData.Accounts.account1.publicKey);\n      derived.should.equal(testData.Accounts.account1.address);\n    });\n\n    it('should derive correct address from public key for account2', function () {\n      const derived = getAddressFromPublicKey(testData.Accounts.account2.publicKey);\n      derived.should.equal(testData.Accounts.account2.address);\n    });\n\n    it('should derive correct address from public key for account3', function () {\n      const derived = getAddressFromPublicKey(testData.Accounts.account3.publicKey);\n      derived.should.equal(testData.Accounts.account3.address);\n    });\n  });\n\n  describe('Public key validation', () => {\n    it('should validate a correct uncompressed public key', function () {\n      basecoin.isValidPub(testData.Accounts.account1.publicKey).should.equal(true);\n    });\n\n    it('should reject an invalid public key', function () {\n      basecoin.isValidPub('invalid-public-key').should.equal(false);\n    });\n  });\n\n  describe('MPC support', () => {\n    it('should support TSS', function () {\n      basecoin.supportsTss().should.equal(true);\n    });\n\n    it('should return ECDSA as MPC algorithm', function () {\n      basecoin.getMPCAlgorithm().should.equal('ecdsa');\n    });\n  });\n\n  describe('Key pair generation', () => {\n    it('should generate a key pair', function () {\n      const keyPair = basecoin.generateKeyPair();\n      should.exist(keyPair.pub);\n      should.exist(keyPair.prv);\n    });\n\n    it('should generate different key pairs each time', function () {\n      const kp1 = basecoin.generateKeyPair();\n      const kp2 = basecoin.generateKeyPair();\n      kp1.pub.should.not.equal(kp2.pub);\n    });\n  });\n});\n"]}

package/dist/test/unit/transaction.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=transaction.d.ts.map

package/dist/test/unit/transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../test/unit/transaction.ts"],"names":[],"mappings":""}