@bitgo-beta/sdk-coin-starknet 0.0.1-beta.0

package/dist/src/lib/utils.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeAddress = normalizeAddress;
+exports.isValidAddress = isValidAddress;
+exports.isValidPublicKey = isValidPublicKey;
+exports.isValidPrivateKey = isValidPrivateKey;
+exports.getUncompressedPublicKey = getUncompressedPublicKey;
+exports.compileEthAccountConstructorCalldata = compileEthAccountConstructorCalldata;
+exports.calculateContractAddressFromHash = calculateContractAddressFromHash;
+exports.computeStarknetAddress = computeStarknetAddress;
+exports.getAddressFromPublicKey = getAddressFromPublicKey;
+exports.formatEthAccountSignature = formatEthAccountSignature;
+exports.parseTransferCall = parseTransferCall;
+exports.generateKeyPair = generateKeyPair;
+exports.validateRawTransaction = validateRawTransaction;
+const starknet_1 = require("@scure/starknet");
+const constants_1 = require("./constants");
+const secp256k1_1 = require("@bitgo-beta/secp256k1");
+/**
+ * Normalize a Starknet address to canonical form: 0x + 64 hex chars, zero-padded.
+ */
+function normalizeAddress(address) {
+    const hex = address.startsWith('0x') ? address.slice(2) : address;
+    return '0x' + hex.padStart(64, '0').toLowerCase();
+}
+/**
+ * Starknet addresses are felt252 values represented as 0x-prefixed hex.
+ * Valid range: 0 < address < FELT_MAX, with 0x prefix and hex chars.
+ */
+function isValidAddress(address) {
+    if (typeof address !== 'string')
+        return false;
+    if (!address.match(/^0x[0-9a-fA-F]{1,64}$/))
+        return false;
+    try {
+        const val = BigInt(address);
+        return val > 0n && val < constants_1.FELT_MAX;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate a secp256k1 public key (compressed 33 bytes or uncompressed 65 bytes).
+ */
+function isValidPublicKey(key) {
+    if (typeof key !== 'string')
+        return false;
+    try {
+        const buf = Buffer.from(key, 'hex');
+        if (buf.length === 33 && (buf[0] === 0x02 || buf[0] === 0x03)) {
+            secp256k1_1.ecc.pointCompress(buf, true);
+            return true;
+        }
+        if (buf.length === 65 && buf[0] === 0x04) {
+            secp256k1_1.ecc.pointCompress(buf, true);
+            return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Validate a secp256k1 private key (32 bytes hex).
+ */
+function isValidPrivateKey(key) {
+    if (typeof key !== 'string')
+        return false;
+    return /^[0-9a-fA-F]{64}$/.test(key);
+}
+/**
+ * Get uncompressed public key (x || y, 128 hex chars, no 04 prefix).
+ */
+function getUncompressedPublicKey(compressedHex) {
+    const buf = Buffer.from(compressedHex, 'hex');
+    if (buf.length === 65 && buf[0] === 0x04) {
+        return compressedHex.slice(2);
+    }
+    if (buf.length === 33 && (buf[0] === 0x02 || buf[0] === 0x03)) {
+        const uncompressed = Buffer.from(secp256k1_1.ecc.pointCompress(buf, false));
+        return uncompressed.toString('hex').slice(2);
+    }
+    if (buf.length === 64) {
+        return compressedHex;
+    }
+    throw new Error(`Invalid public key format: ${compressedHex.substring(0, 10)}...`);
+}
+/**
+ * Compile EthAccount constructor calldata from full secp256k1 public key.
+ * Returns [x_low, x_high, y_low, y_high] as felt252 strings.
+ */
+function compileEthAccountConstructorCalldata(fullPublicKey) {
+    const pubX = BigInt('0x' + fullPublicKey.slice(0, 64));
+    const pubY = BigInt('0x' + fullPublicKey.slice(64));
+    return [
+        '0x' + (pubX & constants_1.MASK_128).toString(16),
+        '0x' + (pubX >> 128n).toString(16),
+        '0x' + (pubY & constants_1.MASK_128).toString(16),
+        '0x' + (pubY >> 128n).toString(16),
+    ];
+}
+/**
+ * Compute Starknet contract address from hash components.
+ * Replicates starknet.js calculateContractAddressFromHash using @scure/starknet pedersen.
+ */
+function calculateContractAddressFromHash(salt, classHash, constructorCalldata, deployerAddress) {
+    const calldataHash = (0, starknet_1.computeHashOnElements)(constructorCalldata.map(BigInt));
+    const rawHash = (0, starknet_1.computeHashOnElements)([
+        constants_1.CONTRACT_ADDRESS_PREFIX,
+        BigInt(deployerAddress),
+        BigInt(salt),
+        BigInt(classHash),
+        BigInt(calldataHash),
+    ]);
+    return normalizeAddress('0x' + (BigInt(rawHash) % constants_1.ADDR_BOUND).toString(16));
+}
+/**
+ * Compute Starknet EthAccount counterfactual address from public key.
+ */
+function computeStarknetAddress(fullPublicKey) {
+    const constructorCalldata = compileEthAccountConstructorCalldata(fullPublicKey);
+    const pubX = BigInt('0x' + fullPublicKey.slice(0, 64));
+    const salt = '0x' + (pubX % constants_1.FELT_MAX).toString(16);
+    const address = calculateContractAddressFromHash(salt, constants_1.OZ_ETH_ACCOUNT_CLASS_HASH, constructorCalldata, 0);
+    return { address, constructorCalldata, salt };
+}
+/**
+ * Derive Starknet EthAccount address from compressed secp256k1 public key.
+ */
+function getAddressFromPublicKey(compressedPublicKey) {
+    const fullPublicKey = getUncompressedPublicKey(compressedPublicKey);
+    const { address } = computeStarknetAddress(fullPublicKey);
+    return address;
+}
+/**
+ * Format ECDSA signature for Starknet EthAccount.
+ * Returns [r_low, r_high, s_low, s_high, v].
+ */
+function formatEthAccountSignature(r, s, recid) {
+    const rBig = BigInt('0x' + r);
+    const sBig = BigInt('0x' + s);
+    const v = BigInt(recid);
+    return [
+        '0x' + (rBig & constants_1.MASK_128).toString(16),
+        '0x' + (rBig >> 128n).toString(16),
+        '0x' + (sBig & constants_1.MASK_128).toString(16),
+        '0x' + (sBig >> 128n).toString(16),
+        '0x' + v.toString(16),
+    ];
+}
+/**
+ * Extract recipient, amount, and token contract from a transfer call.
+ * Reverse of TransferBuilder.compileTransferCalldata: calldata = [recipient, amount_low, amount_high].
+ */
+function parseTransferCall(call) {
+    if (call.entrypoint !== 'transfer' || call.calldata.length < 3) {
+        return undefined;
+    }
+    const amountLow = BigInt(call.calldata[1]);
+    const amountHigh = BigInt(call.calldata[2]);
+    const amount = ((amountHigh << 128n) | amountLow).toString();
+    return {
+        recipient: call.calldata[0],
+        amount,
+        tokenContract: call.contractAddress,
+    };
+}
+/**
+ * Generate a new secp256k1 key pair.
+ */
+function generateKeyPair(seed) {
+    const { KeyPair: StarknetKeyPair } = require('./keyPair');
+    const keyPair = seed ? new StarknetKeyPair({ seed }) : new StarknetKeyPair();
+    const { pub, prv } = keyPair.getKeys();
+    if (!prv) {
+        throw new Error('Private key is missing in the generated key pair.');
+    }
+    return { pub, prv };
+}
+/**
+ * Validate raw transaction data has required fields.
+ */
+function validateRawTransaction(tx) {
+    if (!tx.senderAddress) {
+        throw new Error('Missing sender address');
+    }
+    if (!isValidAddress(tx.senderAddress)) {
+        throw new Error(`Invalid sender address: ${tx.senderAddress}`);
+    }
+}
+exports.default = {
+    isValidAddress,
+    isValidPublicKey,
+    isValidPrivateKey,
+    getUncompressedPublicKey,
+    compileEthAccountConstructorCalldata,
+    calculateContractAddressFromHash,
+    computeStarknetAddress,
+    getAddressFromPublicKey,
+    normalizeAddress,
+    formatEthAccountSignature,
+    parseTransferCall,
+    generateKeyPair,
+    validateRawTransaction,
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import { computeHashOnElements } from '@scure/starknet';\nimport { FELT_MAX, MASK_128, OZ_ETH_ACCOUNT_CLASS_HASH, ADDR_BOUND, CONTRACT_ADDRESS_PREFIX } from './constants';\nimport { StarknetTransactionData, StarknetCall, ParsedTransferData } from './iface';\nimport { ecc } from '@bitgo-beta/secp256k1';\n\n/**\n * Normalize a Starknet address to canonical form: 0x + 64 hex chars, zero-padded.\n */\nexport function normalizeAddress(address: string): string {\n  const hex = address.startsWith('0x') ? address.slice(2) : address;\n  return '0x' + hex.padStart(64, '0').toLowerCase();\n}\n\n/**\n * Starknet addresses are felt252 values represented as 0x-prefixed hex.\n * Valid range: 0 < address < FELT_MAX, with 0x prefix and hex chars.\n */\nexport function isValidAddress(address: string): boolean {\n  if (typeof address !== 'string') return false;\n  if (!address.match(/^0x[0-9a-fA-F]{1,64}$/)) return false;\n  try {\n    const val = BigInt(address);\n    return val > 0n && val < FELT_MAX;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Validate a secp256k1 public key (compressed 33 bytes or uncompressed 65 bytes).\n */\nexport function isValidPublicKey(key: string): boolean {\n  if (typeof key !== 'string') return false;\n  try {\n    const buf = Buffer.from(key, 'hex');\n    if (buf.length === 33 && (buf[0] === 0x02 || buf[0] === 0x03)) {\n      ecc.pointCompress(buf, true);\n      return true;\n    }\n    if (buf.length === 65 && buf[0] === 0x04) {\n      ecc.pointCompress(buf, true);\n      return true;\n    }\n    return false;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Validate a secp256k1 private key (32 bytes hex).\n */\nexport function isValidPrivateKey(key: string): boolean {\n  if (typeof key !== 'string') return false;\n  return /^[0-9a-fA-F]{64}$/.test(key);\n}\n\n/**\n * Get uncompressed public key (x || y, 128 hex chars, no 04 prefix).\n */\nexport function getUncompressedPublicKey(compressedHex: string): string {\n  const buf = Buffer.from(compressedHex, 'hex');\n  if (buf.length === 65 && buf[0] === 0x04) {\n    return compressedHex.slice(2);\n  }\n  if (buf.length === 33 && (buf[0] === 0x02 || buf[0] === 0x03)) {\n    const uncompressed = Buffer.from(ecc.pointCompress(buf, false));\n    return uncompressed.toString('hex').slice(2);\n  }\n  if (buf.length === 64) {\n    return compressedHex;\n  }\n  throw new Error(`Invalid public key format: ${compressedHex.substring(0, 10)}...`);\n}\n\n/**\n * Compile EthAccount constructor calldata from full secp256k1 public key.\n * Returns [x_low, x_high, y_low, y_high] as felt252 strings.\n */\nexport function compileEthAccountConstructorCalldata(fullPublicKey: string): string[] {\n  const pubX = BigInt('0x' + fullPublicKey.slice(0, 64));\n  const pubY = BigInt('0x' + fullPublicKey.slice(64));\n\n  return [\n    '0x' + (pubX & MASK_128).toString(16),\n    '0x' + (pubX >> 128n).toString(16),\n    '0x' + (pubY & MASK_128).toString(16),\n    '0x' + (pubY >> 128n).toString(16),\n  ];\n}\n\n/**\n * Compute Starknet contract address from hash components.\n * Replicates starknet.js calculateContractAddressFromHash using @scure/starknet pedersen.\n */\nexport function calculateContractAddressFromHash(\n  salt: string,\n  classHash: string,\n  constructorCalldata: string[],\n  deployerAddress: number | bigint\n): string {\n  const calldataHash = computeHashOnElements(constructorCalldata.map(BigInt)) as string;\n  const rawHash = computeHashOnElements([\n    CONTRACT_ADDRESS_PREFIX,\n    BigInt(deployerAddress),\n    BigInt(salt),\n    BigInt(classHash),\n    BigInt(calldataHash),\n  ]) as string;\n  return normalizeAddress('0x' + (BigInt(rawHash) % ADDR_BOUND).toString(16));\n}\n\n/**\n * Compute Starknet EthAccount counterfactual address from public key.\n */\nexport function computeStarknetAddress(fullPublicKey: string): {\n  address: string;\n  constructorCalldata: string[];\n  salt: string;\n} {\n  const constructorCalldata = compileEthAccountConstructorCalldata(fullPublicKey);\n\n  const pubX = BigInt('0x' + fullPublicKey.slice(0, 64));\n  const salt = '0x' + (pubX % FELT_MAX).toString(16);\n\n  const address = calculateContractAddressFromHash(salt, OZ_ETH_ACCOUNT_CLASS_HASH, constructorCalldata, 0);\n\n  return { address, constructorCalldata, salt };\n}\n\n/**\n * Derive Starknet EthAccount address from compressed secp256k1 public key.\n */\nexport function getAddressFromPublicKey(compressedPublicKey: string): string {\n  const fullPublicKey = getUncompressedPublicKey(compressedPublicKey);\n  const { address } = computeStarknetAddress(fullPublicKey);\n  return address;\n}\n\n/**\n * Format ECDSA signature for Starknet EthAccount.\n * Returns [r_low, r_high, s_low, s_high, v].\n */\nexport function formatEthAccountSignature(r: string, s: string, recid: number): string[] {\n  const rBig = BigInt('0x' + r);\n  const sBig = BigInt('0x' + s);\n  const v = BigInt(recid);\n\n  return [\n    '0x' + (rBig & MASK_128).toString(16),\n    '0x' + (rBig >> 128n).toString(16),\n    '0x' + (sBig & MASK_128).toString(16),\n    '0x' + (sBig >> 128n).toString(16),\n    '0x' + v.toString(16),\n  ];\n}\n\n/**\n * Extract recipient, amount, and token contract from a transfer call.\n * Reverse of TransferBuilder.compileTransferCalldata: calldata = [recipient, amount_low, amount_high].\n */\nexport function parseTransferCall(call: StarknetCall): ParsedTransferData | undefined {\n  if (call.entrypoint !== 'transfer' || call.calldata.length < 3) {\n    return undefined;\n  }\n  const amountLow = BigInt(call.calldata[1]);\n  const amountHigh = BigInt(call.calldata[2]);\n  const amount = ((amountHigh << 128n) | amountLow).toString();\n  return {\n    recipient: call.calldata[0],\n    amount,\n    tokenContract: call.contractAddress,\n  };\n}\n\n/**\n * Generate a new secp256k1 key pair.\n */\nexport function generateKeyPair(seed?: Buffer): { pub: string; prv: string } {\n  const { KeyPair: StarknetKeyPair } = require('./keyPair');\n  const keyPair = seed ? new StarknetKeyPair({ seed }) : new StarknetKeyPair();\n  const { pub, prv } = keyPair.getKeys();\n  if (!prv) {\n    throw new Error('Private key is missing in the generated key pair.');\n  }\n  return { pub, prv };\n}\n\n/**\n * Validate raw transaction data has required fields.\n */\nexport function validateRawTransaction(tx: StarknetTransactionData): void {\n  if (!tx.senderAddress) {\n    throw new Error('Missing sender address');\n  }\n  if (!isValidAddress(tx.senderAddress)) {\n    throw new Error(`Invalid sender address: ${tx.senderAddress}`);\n  }\n}\n\nexport default {\n  isValidAddress,\n  isValidPublicKey,\n  isValidPrivateKey,\n  getUncompressedPublicKey,\n  compileEthAccountConstructorCalldata,\n  calculateContractAddressFromHash,\n  computeStarknetAddress,\n  getAddressFromPublicKey,\n  normalizeAddress,\n  formatEthAccountSignature,\n  parseTransferCall,\n  generateKeyPair,\n  validateRawTransaction,\n};\n"]}

package/dist/src/register.d.ts

@@ -0,0 +1,3 @@
+import { BitGoBase } from '@bitgo-beta/sdk-core';
+export declare const register: (sdk: BitGoBase) => void;
+//# sourceMappingURL=register.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"register.d.ts","sourceRoot":"","sources":["../../src/register.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAGjD,eAAO,MAAM,QAAQ,QAAS,SAAS,KAAG,IAGzC,CAAC"}

package/dist/src/register.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.register = void 0;
+const starknet_1 = require("./starknet");
+const register = (sdk) => {
+    sdk.register('starknet', starknet_1.Starknet.createInstance);
+    sdk.register('tstarknet', starknet_1.Starknet.createInstance);
+};
+exports.register = register;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVnaXN0ZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcmVnaXN0ZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EseUNBQXNDO0FBRS9CLE1BQU0sUUFBUSxHQUFHLENBQUMsR0FBYyxFQUFRLEVBQUU7SUFDL0MsR0FBRyxDQUFDLFFBQVEsQ0FBQyxVQUFVLEVBQUUsbUJBQVEsQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUNsRCxHQUFHLENBQUMsUUFBUSxDQUFDLFdBQVcsRUFBRSxtQkFBUSxDQUFDLGNBQWMsQ0FBQyxDQUFDO0FBQ3JELENBQUMsQ0FBQztBQUhXLFFBQUEsUUFBUSxZQUduQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEJpdEdvQmFzZSB9IGZyb20gJ0BiaXRnby1iZXRhL3Nkay1jb3JlJztcbmltcG9ydCB7IFN0YXJrbmV0IH0gZnJvbSAnLi9zdGFya25ldCc7XG5cbmV4cG9ydCBjb25zdCByZWdpc3RlciA9IChzZGs6IEJpdEdvQmFzZSk6IHZvaWQgPT4ge1xuICBzZGsucmVnaXN0ZXIoJ3N0YXJrbmV0JywgU3RhcmtuZXQuY3JlYXRlSW5zdGFuY2UpO1xuICBzZGsucmVnaXN0ZXIoJ3RzdGFya25ldCcsIFN0YXJrbmV0LmNyZWF0ZUluc3RhbmNlKTtcbn07XG4iXX0=

package/dist/src/starknet.d.ts

@@ -0,0 +1,35 @@
+import { AuditDecryptedKeyParams, BaseCoin, BitGoBase, KeyPair, MPCAlgorithm, MultisigType, ParsedTransaction, ParseTransactionOptions, SignedTransaction, SignTransactionOptions, VerifyTransactionOptions } from '@bitgo-beta/sdk-core';
+import { BaseCoin as StaticsBaseCoin } from '@bitgo-beta/statics';
+import { Hash } from 'crypto';
+import { StarknetTransactionExplanation, TransactionHexParams, TssVerifyStarknetAddressOptions } from './lib/iface';
+export declare class Starknet extends BaseCoin {
+    protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;
+    protected constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>);
+    static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin;
+    getChain(): string;
+    getBaseChain(): string;
+    getFamily(): string;
+    getFullName(): string;
+    getBaseFactor(): number;
+    explainTransaction(params: TransactionHexParams): Promise<StarknetTransactionExplanation>;
+    verifyTransaction(params: VerifyTransactionOptions): Promise<boolean>;
+    isWalletAddress(params: TssVerifyStarknetAddressOptions): Promise<boolean>;
+    parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction>;
+    generateKeyPair(seed?: Buffer): KeyPair;
+    isValidAddress(address: string): boolean;
+    signTransaction(_params: SignTransactionOptions): Promise<SignedTransaction>;
+    isValidPub(key: string): boolean;
+    isValidPrv(key: string): boolean;
+    /** @inheritDoc */
+    supportsTss(): boolean;
+    /** inherited doc */
+    getDefaultMultisigType(): MultisigType;
+    /** @inheritDoc */
+    getMPCAlgorithm(): MPCAlgorithm;
+    /** @inheritDoc **/
+    getHashFunction(): Hash;
+    private getBuilderFactory;
+    /** @inheritDoc */
+    auditDecryptedKey({ multiSigType, prv, publicKey }: AuditDecryptedKeyParams): void;
+}
+//# sourceMappingURL=starknet.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"starknet.d.ts","sourceRoot":"","sources":["../../src/starknet.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,QAAQ,EACR,SAAS,EAET,OAAO,EAEP,YAAY,EACZ,YAAY,EAEZ,iBAAiB,EACjB,uBAAuB,EACvB,iBAAiB,EACjB,sBAAsB,EACtB,wBAAwB,EAGzB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAS,QAAQ,IAAI,eAAe,EAAE,MAAM,qBAAqB,CAAC;AACzE,OAAO,EAAc,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE1C,OAAO,EAAE,8BAA8B,EAAE,oBAAoB,EAAE,+BAA+B,EAAE,MAAM,aAAa,CAAC;AAKpH,qBAAa,QAAS,SAAQ,QAAQ;IACpC,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,eAAe,CAAC,CAAC;IAC3D,SAAS,aAAa,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC;IAU/E,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,QAAQ,CAAC,eAAe,CAAC,GAAG,QAAQ;IAI1F,QAAQ,IAAI,MAAM;IAIlB,YAAY,IAAI,MAAM;IAItB,SAAS,IAAI,MAAM;IAInB,WAAW,IAAI,MAAM;IAIrB,aAAa,IAAI,MAAM;IAIjB,kBAAkB,CAAC,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC,8BAA8B,CAAC;IAOzF,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,OAAO,CAAC;IA+BrE,eAAe,CAAC,MAAM,EAAE,+BAA+B,GAAG,OAAO,CAAC,OAAO,CAAC;IAoB1E,gBAAgB,CAAC,MAAM,EAAE,uBAAuB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAI5E,eAAe,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO;IAI9C,cAAc,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAKlC,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAIlF,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIhC,UAAU,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIhC,kBAAkB;IAClB,WAAW,IAAI,OAAO;IAItB,oBAAoB;IACpB,sBAAsB,IAAI,YAAY;IAItC,kBAAkB;IAClB,eAAe,IAAI,YAAY;IAI/B,mBAAmB;IACnB,eAAe,IAAI,IAAI;IAIvB,OAAO,CAAC,iBAAiB;IAIzB,kBAAkB;IAClB,iBAAiB,CAAC,EAAE,YAAY,EAAE,GAAG,EAAE,SAAS,EAAE,EAAE,uBAAuB,GAAG,IAAI;CAMnF"}

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-beta/sdk-core");
+const statics_1 = require("@bitgo-beta/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-beta/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-beta/sdk-core';\nimport { coins, BaseCoin as StaticsBaseCoin } from '@bitgo-beta/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-beta/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,53 @@
+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;
+};
+//# 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"}

package/dist/test/resources/starknet.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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',
+};
+//# sourceMappingURL=data:application/json;base64,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

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":""}