bitgo/dist/browser/BitGoJS.min.js

BitGo JavaScript SDK

/*! For license information please see BitGoJS.min.js.LICENSE.txt */
!function webpackUniversalModuleDefinition(root,factory){"object"==typeof exports&&"object"==typeof module?module.exports=factory(require("wasmer_wasi_js_bg.wasm")):"function"==typeof define&&define.amd?define(["wasmer_wasi_js_bg.wasm"],factory):"object"==typeof exports?exports.BitGoJS=factory(require("wasmer_wasi_js_bg.wasm")):root.BitGoJS=factory(root["wasmer_wasi_js_bg.wasm"])}(self,__WEBPACK_EXTERNAL_MODULE__948250__=>(()=>{var __webpack_modules__={570:(module,__unused_webpack_exports,__webpack_require__)=>{"use strict";var isValue=__webpack_require__(276974),isPlainFunction=__webpack_require__(901550),assign=__webpack_require__(409641),normalizeOpts=__webpack_require__(862939),contains=__webpack_require__(645545);(module.exports=function(dscr,value){var c,e,w,options,desc;return arguments.length<2||"string"!=typeof dscr?(options=value,value=dscr,dscr=null):options=arguments[2],isValue(dscr)?(c=contains.call(dscr,"c"),e=contains.call(dscr,"e"),w=contains.call(dscr,"w")):(c=w=!0,e=!1),desc={value,configurable:c,enumerable:e,writable:w},options?assign(normalizeOpts(options),desc):desc}).gs=function(dscr,get,set){var c,e,options,desc;return"string"!=typeof dscr?(options=set,set=get,get=dscr,dscr=null):options=arguments[3],isValue(get)?isPlainFunction(get)?isValue(set)?isPlainFunction(set)||(options=set,set=void 0):set=void 0:(options=get,get=set=void 0):get=void 0,isValue(dscr)?(c=contains.call(dscr,"c"),e=contains.call(dscr,"e")):(c=!0,e=!1),desc={get,set,configurable:c,enumerable:e},options?assign(normalizeOpts(options),desc):desc}},1432:(module,__unused_webpack_exports,__webpack_require__)=>{var baseEach=__webpack_require__(484570);module.exports=function baseEvery(collection,predicate){var result=!0;return baseEach(collection,function(value,index,collection){return result=!!predicate(value,index,collection)}),result}},1437:(__unused_webpack_module,exports,__webpack_require__)=>{"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.hash_to_ristretto255=exports.hashToRistretto255=exports.encodeToCurve=exports.hashToCurve=exports.RistrettoPoint=exports.edwardsToMontgomery=exports.ED25519_TORSION_SUBGROUP=exports.ristretto255_hasher=exports.ristretto255=exports.ed25519_hasher=exports.x25519=exports.ed25519ph=exports.ed25519ctx=exports.ed25519=void 0,exports.edwardsToMontgomeryPub=edwardsToMontgomeryPub,exports.edwardsToMontgomeryPriv=function edwardsToMontgomeryPriv(edwardsPriv){return exports.ed25519.utils.toMontgomerySecret((0,utils_ts_1.ensureBytes)("pub",edwardsPriv))};const sha2_js_1=__webpack_require__(394599),utils_js_1=__webpack_require__(849074),curve_ts_1=__webpack_require__(331672),edwards_ts_1=__webpack_require__(321515),hash_to_curve_ts_1=__webpack_require__(213787),modular_ts_1=__webpack_require__(988173),montgomery_ts_1=__webpack_require__(388100),utils_ts_1=__webpack_require__(275989),_0n=BigInt(0),_1n=BigInt(1),_2n=BigInt(2),_3n=BigInt(3),_5n=BigInt(5),_8n=BigInt(8),ed25519_CURVE_p=BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed"),ed25519_CURVE=(()=>({p:ed25519_CURVE_p,n:BigInt("0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed"),h:_8n,a:BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec"),d:BigInt("0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3"),Gx:BigInt("0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a"),Gy:BigInt("0x6666666666666666666666666666666666666666666666666666666666666658")}))();function ed25519_pow_2_252_3(x){const _10n=BigInt(10),_20n=BigInt(20),_40n=BigInt(40),_80n=BigInt(80),P=ed25519_CURVE_p,b2=x*x%P*x%P,b4=(0,modular_ts_1.pow2)(b2,_2n,P)*b2%P,b5=(0,modular_ts_1.pow2)(b4,_1n,P)*x%P,b10=(0,modular_ts_1.pow2)(b5,_5n,P)*b5%P,b20=(0,modular_ts_1.pow2)(b10,_10n,P)*b10%P,b40=(0,modular_ts_1.pow2)(b20,_20n,P)*b20%P,b80=(0,modular_ts_1.pow2)(b40,_40n,P)*b40%P,b160=(0,modular_ts_1.pow2)(b80,_80n,P)*b80%P,b240=(0,modular_ts_1.pow2)(b160,_80n,P)*b80%P,b250=(0,modular_ts_1.pow2)(b240,_10n,P)*b10%P;return{pow_p_5_8:(0,modular_ts_1.pow2)(b250,_2n,P)*x%P,b2}}function adjustScalarBytes(bytes){return bytes[0]&=248,bytes[31]&=127,bytes[31]|=64,bytes}const ED25519_SQRT_M1=BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");function uvRatio(u,v){const P=ed25519_CURVE_p,v3=(0,modular_ts_1.mod)(v*v*v,P),pow=ed25519_pow_2_252_3(u*(0,modular_ts_1.mod)(v3*v3*v,P)).pow_p_5_8;let x=(0,modular_ts_1.mod)(u*v3*pow,P);const vx2=(0,modular_ts_1.mod)(v*x*x,P),root1=x,root2=(0,modular_ts_1.mod)(x*ED25519_SQRT_M1,P),useRoot1=vx2===u,useRoot2=vx2===(0,modular_ts_1.mod)(-u,P),noRoot=vx2===(0,modular_ts_1.mod)(-u*ED25519_SQRT_M1,P);return useRoot1&&(x=root1),(useRoot2||noRoot)&&(x=root2),(0,modular_ts_1.isNegativeLE)(x,P)&&(x=(0,modular_ts_1.mod)(-x,P)),{isValid:useRoot1||useRoot2,value:x}}const Fp=(()=>(0,modular_ts_1.Field)(ed25519_CURVE.p,{isLE:!0}))(),Fn=(()=>(0,modular_ts_1.Field)(ed25519_CURVE.n,{isLE:!0}))(),ed25519Defaults=(()=>({...ed25519_CURVE,Fp,hash:sha2_js_1.sha512,adjustScalarBytes,uvRatio}))();function ed25519_domain(data,ctx,phflag){if(ctx.length>255)throw new Error("Context is too big");return(0,utils_js_1.concatBytes)((0,utils_js_1.utf8ToBytes)("SigEd25519 no Ed25519 collisions"),new Uint8Array([phflag?1:0,ctx.length]),ctx,data)}exports.ed25519=(0,edwards_ts_1.twistedEdwards)(ed25519Defaults),exports.ed25519ctx=(0,edwards_ts_1.twistedEdwards)({...ed25519Defaults,domain:ed25519_domain}),exports.ed25519ph=(0,edwards_ts_1.twistedEdwards)(Object.assign({},ed25519Defaults,{domain:ed25519_domain,prehash:sha2_js_1.sha512})),exports.x25519=(()=>{const P=Fp.ORDER;return(0,montgomery_ts_1.montgomery)({P,type:"x25519",powPminus2:x=>{const{pow_p_5_8,b2}=ed25519_pow_2_252_3(x);return(0,modular_ts_1.mod)((0,modular_ts_1.pow2)(pow_p_5_8,_3n,P)*b2,P)},adjustScalarBytes})})();const ELL2_C1=(()=>(ed25519_CURVE_p+_3n)/_8n)(),ELL2_C2=(()=>Fp.pow(_2n,ELL2_C1))(),ELL2_C3=(()=>Fp.sqrt(Fp.neg(Fp.ONE)))();const ELL2_C1_EDWARDS=(()=>(0,modular_ts_1.FpSqrtEven)(Fp,Fp.neg(BigInt(486664))))();function map_to_curve_elligator2_edwards25519(u){const{xMn,xMd,yMn,yMd}=function map_to_curve_elligator2_curve25519(u){const ELL2_C4=(ed25519_CURVE_p-_5n)/_8n,ELL2_J=BigInt(486662);let tv1=Fp.sqr(u);tv1=Fp.mul(tv1,_2n);let xd=Fp.add(tv1,Fp.ONE),x1n=Fp.neg(ELL2_J),tv2=Fp.sqr(xd),gxd=Fp.mul(tv2,xd),gx1=Fp.mul(tv1,ELL2_J);gx1=Fp.mul(gx1,x1n),gx1=Fp.add(gx1,tv2),gx1=Fp.mul(gx1,x1n);let tv3=Fp.sqr(gxd);tv2=Fp.sqr(tv3),tv3=Fp.mul(tv3,gxd),tv3=Fp.mul(tv3,gx1),tv2=Fp.mul(tv2,tv3);let y11=Fp.pow(tv2,ELL2_C4);y11=Fp.mul(y11,tv3);let y12=Fp.mul(y11,ELL2_C3);tv2=Fp.sqr(y11),tv2=Fp.mul(tv2,gxd);let e1=Fp.eql(tv2,gx1),y1=Fp.cmov(y12,y11,e1),x2n=Fp.mul(x1n,tv1),y21=Fp.mul(y11,u);y21=Fp.mul(y21,ELL2_C2);let y22=Fp.mul(y21,ELL2_C3),gx2=Fp.mul(gx1,tv1);tv2=Fp.sqr(y21),tv2=Fp.mul(tv2,gxd);let e2=Fp.eql(tv2,gx2),y2=Fp.cmov(y22,y21,e2);tv2=Fp.sqr(y1),tv2=Fp.mul(tv2,gxd);let e3=Fp.eql(tv2,gx1),xn=Fp.cmov(x2n,x1n,e3),y=Fp.cmov(y2,y1,e3),e4=Fp.isOdd(y);return y=Fp.cmov(y,Fp.neg(y),e3!==e4),{xMn:xn,xMd:xd,yMn:y,yMd:_1n}}(u);let xn=Fp.mul(xMn,yMd);xn=Fp.mul(xn,ELL2_C1_EDWARDS);let xd=Fp.mul(xMd,yMn),yn=Fp.sub(xMn,xMd),yd=Fp.add(xMn,xMd),tv1=Fp.mul(xd,yd),e=Fp.eql(tv1,Fp.ZERO);xn=Fp.cmov(xn,Fp.ZERO,e),xd=Fp.cmov(xd,Fp.ONE,e),yn=Fp.cmov(yn,Fp.ONE,e),yd=Fp.cmov(yd,Fp.ONE,e);const[xd_inv,yd_inv]=(0,modular_ts_1.FpInvertBatch)(Fp,[xd,yd],!0);return{x:Fp.mul(xn,xd_inv),y:Fp.mul(yn,yd_inv)}}exports.ed25519_hasher=(0,hash_to_curve_ts_1.createHasher)(exports.ed25519.Point,scalars=>map_to_curve_elligator2_edwards25519(scalars[0]),{DST:"edwards25519_XMD:SHA-512_ELL2_RO_",encodeDST:"edwards25519_XMD:SHA-512_ELL2_NU_",p:ed25519_CURVE_p,m:1,k:128,expand:"xmd",hash:sha2_js_1.sha512});const SQRT_M1=ED25519_SQRT_M1,SQRT_AD_MINUS_ONE=BigInt("25063068953384623474111414158702152701244531502492656460079210482610430750235"),INVSQRT_A_MINUS_D=BigInt("54469307008909316920995813868745141605393597292927456921205312896311721017578"),ONE_MINUS_D_SQ=BigInt("1159843021668779879193775521855586647937357759715417654439879720876111806838"),D_MINUS_ONE_SQ=BigInt("40440834346308536858101042469323190826248399146238708352240133220865137265952"),invertSqrt=number=>uvRatio(_1n,number),MAX_255B=BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),bytes255ToNumberLE=bytes=>exports.ed25519.Point.Fp.create((0,utils_ts_1.bytesToNumberLE)(bytes)&MAX_255B);function calcElligatorRistrettoMap(r0){const{d}=ed25519_CURVE,P=ed25519_CURVE_p,mod=n=>Fp.create(n),r=mod(SQRT_M1*r0*r0),Ns=mod((r+_1n)*ONE_MINUS_D_SQ);let c=BigInt(-1);const D=mod((c-d*r)*mod(r+d));let{isValid:Ns_D_is_sq,value:s}=uvRatio(Ns,D),s_=mod(s*r0);(0,modular_ts_1.isNegativeLE)(s_,P)||(s_=mod(-s_)),Ns_D_is_sq||(s=s_),Ns_D_is_sq||(c=r);const Nt=mod(c*(r-_1n)*D_MINUS_ONE_SQ-D),s2=s*s,W0=mod((s+s)*D),W1=mod(Nt*SQRT_AD_MINUS_ONE),W2=mod(_1n-s2),W3=mod(_1n+s2);return new exports.ed25519.Point(mod(W0*W3),mod(W2*W1),mod(W1*W3),mod(W0*W2))}function ristretto255_map(bytes){(0,utils_js_1.abytes)(bytes,64);const R1=calcElligatorRistrettoMap(bytes255ToNumberLE(bytes.subarray(0,32))),R2=calcElligatorRistrettoMap(bytes255ToNumberLE(bytes.subarray(32,64)));return new _RistrettoPoint(R1.add(R2))}class _RistrettoPoint extends edwards_ts_1.PrimeEdwardsPoint{constructor(ep){super(ep)}static fromAffine(ap){return new _RistrettoPoint(exports.ed25519.Point.fromAffine(ap))}assertSame(other){if(!(other instanceof _RistrettoPoint))throw new Error("RistrettoPoint expected")}init(ep){return new _RistrettoPoint(ep)}static hashToCurve(hex){return ristretto255_map((0,utils_ts_1.ensureBytes)("ristrettoHash",hex,64))}static fromBytes(bytes){(0,utils_js_1.abytes)(bytes,32);const{a,d}=ed25519_CURVE,P=ed25519_CURVE_p,mod=n=>Fp.create(n),s=bytes255ToNumberLE(bytes);if(!(0,utils_ts_1.equalBytes)(Fp.toBytes(s),bytes)||(0,modular_ts_1.isNegativeLE)(s,P))throw new Error("invalid ristretto255 encoding 1");const s2=mod(s*s),u1=mod(_1n+a*s2),u2=mod(_1n-a*s2),u1_2=mod(u1*u1),u2_2=mod(u2*u2),v=mod(a*d*u1_2-u2_2),{isValid,value:I}=invertSqrt(mod(v*u2_2)),Dx=mod(I*u2),Dy=mod(I*Dx*v);let x=mod((s+s)*Dx);(0,modular_ts_1.isNegativeLE)(x,P)&&(x=mod(-x));const y=mod(u1*Dy),t=mod(x*y);if(!isValid||(0,modular_ts_1.isNegativeLE)(t,P)||y===_0n)throw new Error("invalid ristretto255 encoding 2");return new _RistrettoPoint(new exports.ed25519.Point(x,y,_1n,t))}static fromHex(hex){return _RistrettoPoint.fromBytes((0,utils_ts_1.ensureBytes)("ristrettoHex",hex,32))}static msm(points,scalars){return(0,curve_ts_1.pippenger)(_RistrettoPoint,exports.ed25519.Point.Fn,points,scalars)}toBytes(){let{X,Y,Z,T}=this.ep;const P=ed25519_CURVE_p,mod=n=>Fp.create(n),u1=mod(mod(Z+Y)*mod(Z-Y)),u2=mod(X*Y),u2sq=mod(u2*u2),{value:invsqrt}=invertSqrt(mod(u1*u2sq)),D1=mod(invsqrt*u1),D2=mod(invsqrt*u2),zInv=mod(D1*D2*T);let D;if((0,modular_ts_1.isNegativeLE)(T*zInv,P)){let _x=mod(Y*SQRT_M1),_y=mod(X*SQRT_M1);X=_x,Y=_y,D=mod(D1*INVSQRT_A_MINUS_D)}else D=D2;(0,modular_ts_1.isNegativeLE)(X*zInv,P)&&(Y=mod(-Y));let s=mod((Z-Y)*D);return(0,modular_ts_1.isNegativeLE)(s,P)&&(s=mod(-s)),Fp.toBytes(s)}equals(other){this.assertSame(other);const{X:X1,Y:Y1}=this.ep,{X:X2,Y:Y2}=other.ep,mod=n=>Fp.create(n),one=mod(X1*Y2)===mod(Y1*X2),two=mod(Y1*Y2)===mod(X1*X2);return one||two}is0(){return this.equals(_RistrettoPoint.ZERO)}}function edwardsToMontgomeryPub(edwardsPub){return exports.ed25519.utils.toMontgomery((0,utils_ts_1.ensureBytes)("pub",edwardsPub))}_RistrettoPoint.BASE=(()=>new _RistrettoPoint(exports.ed25519.Point.BASE))(),_RistrettoPoint.ZERO=(()=>new _RistrettoPoint(exports.ed25519.Point.ZERO))(),_RistrettoPoint.Fp=(()=>Fp)(),_RistrettoPoint.Fn=(()=>Fn)(),exports.ristretto255={Point:_RistrettoPoint},exports.ristretto255_hasher={hashToCurve(msg,options){const DST=options?.DST||"ristretto255_XMD:SHA-512_R255MAP_RO_";return ristretto255_map((0,hash_to_curve_ts_1.expand_message_xmd)(msg,DST,64,sha2_js_1.sha512))},hashToScalar(msg,options={DST:hash_to_curve_ts_1._DST_scalar}){const xmd=(0,hash_to_curve_ts_1.expand_message_xmd)(msg,options.DST,64,sha2_js_1.sha512);return Fn.create((0,utils_ts_1.bytesToNumberLE)(xmd))}},exports.ED25519_TORSION_SUBGROUP=["0100000000000000000000000000000000000000000000000000000000000000","c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a","0000000000000000000000000000000000000000000000000000000000000080","26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc05","ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f","26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc85","0000000000000000000000000000000000000000000000000000000000000000","c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa"],exports.edwardsToMontgomery=edwardsToMontgomeryPub,exports.RistrettoPoint=_RistrettoPoint,exports.hashToCurve=exports.ed25519_hasher.hashToCurve,exports.encodeToCurve=exports.ed25519_hasher.encodeToCurve,exports.hashToRistretto255=exports.ristretto255_hasher.hashToCurve,exports.hash_to_ristretto255=exports.ristretto255_hasher.hashToCurve},1800:(__unused_webpack_module,exports,__webpack_require__)=>{"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.getTxHash=void 0;const util_crypto_1=__webpack_require__(465354);exports.getTxHash=function getTxHash(signedTx){return(0,util_crypto_1.blake2AsHex)(signedTx,256)}},1803:function(__unused_webpack_module,exports,__webpack_require__){"use strict";var ownKeys,process=__webpack_require__(439907),Buffer=__webpack_require__(901048).Buffer,__createBinding=this&&this.__createBinding||(Object.create?function(o,m,k,k2){void 0===k2&&(k2=k);var desc=Object.getOwnPropertyDescriptor(m,k);desc&&!("get"in desc?!m.__esModule:desc.writable||desc.configurable)||(desc={enumerable:!0,get:function(){return m[k]}}),Object.defineProperty(o,k2,desc)}:function(o,m,k,k2){void 0===k2&&(k2=k),o[k2]=m[k]}),__setModuleDefault=this&&this.__setModuleDefault||(Object.create?function(o,v){Object.defineProperty(o,"default",{enumerable:!0,value:v})}:function(o,v){o.default=v}),__importStar=this&&this.__importStar||(ownKeys=function(o){return ownKeys=Object.getOwnPropertyNames||function(o){var ar=[];for(var k in o)Object.prototype.hasOwnProperty.call(o,k)&&(ar[ar.length]=k);return ar},ownKeys(o)},function(mod){if(mod&&mod.__esModule)return mod;var result={};if(null!=mod)for(var k=ownKeys(mod),i=0;i<k.length;i++)"default"!==k[i]&&__createBinding(result,mod,k[i]);return __setModuleDefault(result,mod),result}),__importDefault=this&&this.__importDefault||function(mod){return mod&&mod.__esModule?mod:{default:mod}};Object.defineProperty(exports,"__esModule",{value:!0}),exports.Sol=exports.DEFAULT_SCAN_FACTOR=void 0,exports.getAmountBasedOnEndianness=getAmountBasedOnEndianness;const spl_token_1=__webpack_require__(16524),bignumber_js_1=__importDefault(__webpack_require__(755553)),base58=__importStar(__webpack_require__(939216)),_=__importStar(__webpack_require__(645250)),request=__importStar(__webpack_require__(692335)),sdk_core_1=__webpack_require__(32942),sdk_lib_mpc_1=__webpack_require__(986257),statics_1=__webpack_require__(577475),lib_1=__webpack_require__(939181),utils_1=__webpack_require__(421528);exports.DEFAULT_SCAN_FACTOR=20;const HEX_REGEX=/^[0-9a-fA-F]+$/,BLIND_SIGNING_TX_TYPES_TO_CHECK={enabletoken:"AssociatedTokenAccountInitialization"};function getAmountBasedOnEndianness(amount){const amountStr=String(amount);if(!("s390x"===process.arch))return amountStr;try{const amountBN=BigInt(amountStr),buf=Buffer.alloc(8);buf.writeBigUInt64BE(amountBN,0);return buf.readBigUInt64LE(0).toString()}catch(e){return amountStr}}class Sol extends sdk_core_1.BaseCoin{constructor(bitgo,staticsCoin){if(super(bitgo),!staticsCoin)throw new Error("missing required constructor parameter staticsCoin");this._staticsCoin=staticsCoin}static createInstance(bitgo,staticsCoin){return new Sol(bitgo,staticsCoin)}allowsAccountConsolidations(){return!0}supportsTss(){return!0}supportsMessageSigning(){return!0}getDefaultMultisigType(){return sdk_core_1.multisigTypes.tss}getMPCAlgorithm(){return"eddsa"}getChain(){return this._staticsCoin.name}getFamily(){return this._staticsCoin.family}getFullName(){return this._staticsCoin.fullName}getNetwork(){return this._staticsCoin.network}getBaseFactor(){return Math.pow(10,this._staticsCoin.decimalPlaces)}verifyTxType(expectedTypeFromUserParams,actualTypeFromDecoded){const matchFromUserToDecodedType=BLIND_SIGNING_TX_TYPES_TO_CHECK[expectedTypeFromUserParams];if(matchFromUserToDecodedType!==actualTypeFromDecoded)throw new Error(`Invalid transaction type on token enablement: expected "${matchFromUserToDecodedType}", got "${actualTypeFromDecoded}".`)}throwIfMissingTokenEnablementsOrReturn(explanation){if(!explanation.tokenEnablements||0===explanation.tokenEnablements.length)throw new Error("Missing tx token enablements data on token enablement tx prebuild");return explanation.tokenEnablements}throwIfMissingEnableTokenConfigOrReturn(txParams){if(!txParams.enableTokens||0===txParams.enableTokens.length)throw new Error("Missing enable token config");return txParams.enableTokens}verifyTokenName(tokenEnablementsPrebuild,enableTokensConfig){enableTokensConfig.forEach(enableTokenConfig=>{const expectedTokenName=enableTokenConfig.name;tokenEnablementsPrebuild.forEach(tokenEnablement=>{if(!tokenEnablement.tokenName)throw new Error("Missing token name on token enablement tx");if(tokenEnablement.tokenName!==expectedTokenName)throw new Error(`Invalid token name: expected ${expectedTokenName}, got ${tokenEnablement.tokenName} on token enablement tx`)})})}async verifyTokenAddress(tokenEnablementsPrebuild,enableTokensConfig){for(const enableTokenConfig of enableTokensConfig){const expectedTokenAddress=enableTokenConfig.address,expectedTokenName=enableTokenConfig.name;if(!expectedTokenAddress)throw new Error("Missing token address on token enablement tx");if(!expectedTokenName)throw new Error("Missing token name on token enablement tx");for(const tokenEnablement of tokenEnablementsPrebuild){let tokenMintAddress,ata;try{tokenMintAddress=(0,utils_1.getSolTokenFromTokenName)(expectedTokenName)}catch{throw new Error(`Unable to derive ATA for token address: ${expectedTokenAddress}`)}if(!tokenMintAddress||void 0===tokenMintAddress.tokenAddress||void 0===tokenMintAddress.programId)throw new Error(`Unable to get token mint address for ${expectedTokenName}`);try{ata=await(0,utils_1.getAssociatedTokenAccountAddress)(tokenMintAddress.tokenAddress,expectedTokenAddress,!0,tokenMintAddress.programId)}catch{throw new Error(`Unable to derive ATA for token address: ${expectedTokenAddress}`)}if(ata!==tokenEnablement.address)throw new Error(`Invalid token address: expected ${ata}, got ${tokenEnablement.address} on token enablement tx`)}}}hasSolVersionedTransactionData(txParams){return"solVersionedTransactionData"in txParams&&void 0!==txParams.solVersionedTransactionData}async verifyVersionedTransaction(params){const{txParams,txPrebuild}=params,rawTx=txPrebuild.txBase64||txPrebuild.txHex;if(!rawTx)throw new Error("missing required tx prebuild property txBase64 or txHex");if(!this.hasSolVersionedTransactionData(txParams))throw new Error("solVersionedTransactionData is required for versioned transaction verification");const versionedData=txParams.solVersionedTransactionData;if(!versionedData.versionedInstructions||0===versionedData.versionedInstructions.length)throw new Error("versioned transaction must have at least one instruction");if(!versionedData.staticAccountKeys||0===versionedData.staticAccountKeys.length)throw new Error("versioned transaction must have at least one static account key");if(!versionedData.messageHeader)throw new Error("versioned transaction must have a message header");let rawTxBase64=rawTx;HEX_REGEX.test(rawTx)&&(rawTxBase64=Buffer.from(rawTx,"hex").toString("base64"));try{const txBytes=Buffer.from(rawTxBase64,"base64");if(txBytes.length<1)throw new Error("transaction bytes are empty");const numSignatures=txBytes[0],versionByteOffset=1+numSignatures*64;if(txBytes.length<=versionByteOffset)throw new Error("transaction bytes are too short to contain version byte");const versionByte=txBytes[versionByteOffset];if(!!!(128&versionByte))throw new Error("transaction does not have versioned format")}catch(error){throw new Error(`failed to validate versioned transaction format: ${error.message}`)}return!0}async verifyTransaction(params){const totalAmount={},coinConfig=statics_1.coins.get(this.getChain()),{txParams,txPrebuild,memo,durableNonce,verification:verificationOptions}=params;if(this.hasSolVersionedTransactionData(txParams))return this.verifyVersionedTransaction(params);const transaction=new lib_1.Transaction(coinConfig),rawTx=txPrebuild.txBase64||txPrebuild.txHex,consolidateId=txPrebuild.consolidateId,walletRootAddress=params.wallet.coinSpecific()?.rootAddress;if(!rawTx)throw new Error("missing required tx prebuild property txBase64 or txHex");let rawTxBase64=rawTx;HEX_REGEX.test(rawTx)&&(rawTxBase64=Buffer.from(rawTx,"hex").toString("base64")),transaction.fromRawTransaction(rawTxBase64);const explainedTx=transaction.explainTransaction();if("enabletoken"===txParams.type&&verificationOptions?.verifyTokenEnablement){this.verifyTxType(txParams.type,explainedTx.type);const tokenEnablementsPrebuild=this.throwIfMissingTokenEnablementsOrReturn(explainedTx),enableTokensConfig=this.throwIfMissingEnableTokenConfigOrReturn(txParams);this.verifyTokenName(tokenEnablementsPrebuild,enableTokensConfig),await this.verifyTokenAddress(tokenEnablementsPrebuild,enableTokensConfig)}if(void 0!==txParams.recipients){const filteredRecipients=txParams.recipients?.map(recipient=>_.pick(recipient,["address","amount","tokenName"])),filteredOutputs=explainedTx.outputs.map(output=>_.pick(output,["address","amount","tokenName"]));if(filteredRecipients.length!==filteredOutputs.length)throw new Error("Number of tx outputs does not match with number of txParams recipients");if((await Promise.all(filteredRecipients.map(async(recipientFromUser,index)=>{const recipientFromTx=filteredOutputs[index],userAmountStr=String(recipientFromUser.amount),txAmountStr=getAmountBasedOnEndianness(recipientFromTx.amount),userAmount=new bignumber_js_1.default(userAmountStr),txAmount=new bignumber_js_1.default(txAmountStr);if(!userAmount.isEqualTo(txAmount))return!1;if(recipientFromUser.address===recipientFromTx.address&&recipientFromUser.tokenName===recipientFromTx.tokenName)return!0;if(recipientFromUser.address!==recipientFromTx.address&&recipientFromUser.tokenName)try{const tokenMintAddress=(0,utils_1.getSolTokenFromTokenName)(recipientFromUser.tokenName);return(0,utils_1.getAssociatedTokenAccountAddress)(tokenMintAddress.tokenAddress,recipientFromUser.address,!0,tokenMintAddress.programId).then(ata=>ata===recipientFromTx.address)}catch{return!1}return!1}))).includes(!1))throw new Error("Tx outputs does not match with expected txParams recipients")}else if(verificationOptions?.consolidationToBaseAddress){const filteredOutputs=explainedTx.outputs.map(output=>_.pick(output,["address","amount","tokenName"])),ataAddressCache={};for(const output of filteredOutputs)if(output.tokenName){if(!ataAddressCache[output.tokenName]){const tokenMintAddress=(0,utils_1.getSolTokenFromTokenName)(output.tokenName);if(!tokenMintAddress?.tokenAddress||!tokenMintAddress?.programId)throw new Error(`Unable to get token information for ${output.tokenName}`);ataAddressCache[output.tokenName]=await(0,utils_1.getAssociatedTokenAccountAddress)(tokenMintAddress.tokenAddress,walletRootAddress,!0,tokenMintAddress.programId)}if(ataAddressCache[output.tokenName]!==output.address)throw new Error("tx outputs does not match with expected address")}else if(output.address!==walletRootAddress)throw new Error("tx outputs does not match with expected address")}const transactionJson=transaction.toJson();if(memo&&memo.value!==explainedTx.memo)throw new Error("Tx memo does not match with expected txParams recipient memo");if(txParams.recipients){for(const recipients of txParams.recipients){const assetName=recipients.tokenName||this.getChain(),amount=totalAmount[assetName]||new bignumber_js_1.default(0);totalAmount[assetName]=amount.plus(recipients.amount)}const explainedTxTotal={};for(const output of explainedTx.outputs){const outputAmountStr=getAmountBasedOnEndianness(output.amount),assetName=output.tokenName||this.getChain(),amount=explainedTxTotal[assetName]||new bignumber_js_1.default(0);explainedTxTotal[assetName]=amount.plus(outputAmountStr)}if(!_.isEqual(explainedTxTotal,totalAmount))throw new Error("Tx total amount does not match with expected total amount field")}if(void 0===consolidateId&&transactionJson.feePayer!==walletRootAddress)throw new Error("Tx fee payer is not the wallet root address");if(durableNonce&&!_.isEqual(explainedTx.durableNonce,durableNonce))throw new Error("Tx durableNonce does not match with param durableNonce");return!0}async isWalletAddress(params){if(!await(0,sdk_core_1.verifyEddsaTssWalletAddress)(params,address=>this.isValidAddress(address),publicKey=>this.getAddressFromPublicKey(publicKey)))throw new sdk_core_1.UnexpectedAddressError(`address validation failure: ${params.address} is not a wallet address`);return!0}getAddressFromPublicKey(publicKey){const publicKeyBuffer=Buffer.from(publicKey,"hex");return base58.encode(publicKeyBuffer)}generateKeyPair(seed){return seed?new lib_1.KeyPair({seed}).getKeys():(new lib_1.KeyPair).getKeys()}isValidPub(pub){return(0,utils_1.isValidPublicKey)(pub)}isValidPrv(prv){return(0,utils_1.isValidPrivateKey)(prv)}isValidAddress(address){return(0,utils_1.isValidAddress)(address)}async signMessage(key,message){const solKeypair=new lib_1.KeyPair({prv:key.prv});return Buffer.isBuffer(message)&&(message=base58.encode(message)),Buffer.from(solKeypair.signMessage(message))}async signTransaction(params){const factory=this.getBuilder(),rawTx=params.txPrebuild.txHex||params.txPrebuild.txBase64,txBuilder=factory.from(rawTx);txBuilder.sign({key:params.prv});const transaction=await txBuilder.build();if(!transaction)throw new Error("Invalid transaction");return{txHex:transaction.toBroadcastFormat()}}async parseTransaction(params){const transactionExplanation=await this.explainTransaction({txBase64:params.txBase64,feeInfo:params.feeInfo,tokenAccountRentExemptAmount:params.tokenAccountRentExemptAmount});if(!transactionExplanation)throw new Error("Invalid transaction");const solTransaction=transactionExplanation;if(solTransaction.outputs.length<=0)return{inputs:[],outputs:[]};const senderAddress=solTransaction.outputs[0].address,feeAmount=new bignumber_js_1.default(solTransaction.fee.fee);return{inputs:[{address:senderAddress,amount:new bignumber_js_1.default(solTransaction.outputAmount).plus(feeAmount).toNumber()}],outputs:solTransaction.outputs.map(({address,amount,tokenName})=>{const output={address,amount};return tokenName&&(output.tokenName=tokenName),output})}}async explainTransaction(params){const factory=this.getBuilder();let rebuiltTransaction;try{const transactionBuilder=factory.from(params.txBase64);if(transactionBuilder instanceof lib_1.TransactionBuilder){const txBuilder=transactionBuilder;txBuilder.fee({amount:params.feeInfo.fee}),params.tokenAccountRentExemptAmount&&txBuilder.associatedTokenAccountRent(params.tokenAccountRentExemptAmount)}rebuiltTransaction=await transactionBuilder.build()}catch(e){throw console.log(e),new Error("Invalid transaction")}return rebuiltTransaction.explainTransaction()}async getSignablePayload(serializedTx){const factory=this.getBuilder();return(await factory.from(serializedTx).build()).signablePayload}async presignTransaction(params){if("hot"!==params.walletData.type)return Promise.resolve(params);const txRequestId=params.txPrebuild?.txRequestId;if(void 0===txRequestId)throw new Error("Missing txRequestId");const{tssUtils}=params;await tssUtils.deleteSignatureShares(txRequestId);const recreated=await tssUtils.getTxRequest(txRequestId);let txHex="";if(txHex=recreated.unsignedTxs?recreated.unsignedTxs[0]?.serializedTxHex:recreated.transactions?recreated.transactions[0]?.unsignedTx.serializedTxHex:"",!txHex)throw new Error("Missing serialized tx hex");return Promise.resolve({...params,txPrebuild:recreated,txHex})}getPublicNodeUrl(apiKey){return apiKey?sdk_core_1.Environments[this.bitgo.getEnv()].solAlchemyNodeUrl+`/${apiKey}`:sdk_core_1.Environments[this.bitgo.getEnv()].solNodeUrl}async getDataFromNode(params,apiKey){const nodeUrl=this.getPublicNodeUrl(apiKey);try{return await request.post(nodeUrl).send(params.payload)}catch(e){console.debug(e)}throw new Error(`Unable to call endpoint: '/' from node: ${nodeUrl}`)}async getBlockhash(apiKey){const response=await this.getDataFromNode({payload:{id:"1",jsonrpc:"2.0",method:"getLatestBlockhash",params:[{commitment:"finalized"}]}},apiKey);if(200!==response.status)throw new Error("Account not found");return response.body.result.value.blockhash}async getFeeForMessage(message,apiKey){const response=await this.getDataFromNode({payload:{id:"1",jsonrpc:"2.0",method:"getFeeForMessage",params:[message,{commitment:"finalized"}]}},apiKey);if(200!==response.status)throw new Error("Account not found");return response.body.result.value}async getRentExemptAmount(apiKey){const response=await this.getDataFromNode({payload:{jsonrpc:"2.0",id:"1",method:"getMinimumBalanceForRentExemption",params:[165]}},apiKey);if(200!==response.status||response.error)throw new Error(JSON.stringify(response.error));return response.body.result}async getAccountBalance(pubKey,apiKey){const response=await this.getDataFromNode({payload:{id:"1",jsonrpc:"2.0",method:"getBalance",params:[pubKey]}},apiKey);if(200!==response.status)throw new Error("Account not found");return response.body.result.value}async getAccountInfo(pubKey,apiKey){const response=await this.getDataFromNode({payload:{id:"1",jsonrpc:"2.0",method:"getAccountInfo",params:[pubKey,{encoding:"jsonParsed"}]}},apiKey);if(200!==response.status)throw new Error("Account not found");return{authority:response.body.result.value.data.parsed.info.authority,blockhash:response.body.result.value.data.parsed.info.blockhash}}async getTokenAccountsByOwner(pubKey="",programId="",apiKey){const response=await this.getDataFromNode({payload:{id:"1",jsonrpc:"2.0",method:"getTokenAccountsByOwner",params:[pubKey,{programId:programId.toString().toLowerCase()===spl_token_1.TOKEN_2022_PROGRAM_ID.toString().toLowerCase()?spl_token_1.TOKEN_2022_PROGRAM_ID.toString():spl_token_1.TOKEN_PROGRAM_ID.toString()},{encoding:"jsonParsed"}]}},apiKey);if(200!==response.status)throw new Error("Account not found");if(0!==response.body.result.value.length){const tokenAccounts=[];for(const tokenAccount of response.body.result.value)tokenAccounts.push({info:tokenAccount.account.data.parsed.info,pubKey:tokenAccount.pubKey});return tokenAccounts}return[]}async getTokenAccountInfo(pubKey,apiKey){const response=await this.getDataFromNode({payload:{id:"1",jsonrpc:"2.0",method:"getAccountInfo",params:[pubKey,{encoding:"jsonParsed"}]}},apiKey);if(200!==response.status)throw new Error("Account not found");return{pubKey,info:response.body.result.value.data.parsed.info}}async createBroadcastableSweepTransaction(params){params.signatureShares;const req=params.signatureShares,broadcastableTransactions=[];let lastScanIndex=0;for(let i=0;i<req.length;i++){const MPC=await sdk_core_1.EDDSAMethods.getInitializedMpcInstance(),transaction=req[i].txRequest.transactions[0].unsignedTx;if(!req[i].ovc||!req[i].ovc[0].eddsaSignature)throw new Error("Missing signature(s)");const signature=req[i].ovc[0].eddsaSignature;if(!transaction.signableHex)throw new Error("Missing signable hex");const messageBuffer=Buffer.from(transaction.signableHex,"hex");if(!MPC.verify(messageBuffer,signature))throw new Error("Invalid signature");const signatureHex=Buffer.concat([Buffer.from(signature.R,"hex"),Buffer.from(signature.sigma,"hex")]),txBuilder=this.getBuilder().from(transaction.serializedTx);if(!transaction.coinSpecific?.commonKeychain)throw new Error("Missing common keychain");const commonKeychain=transaction.coinSpecific.commonKeychain;if(!transaction.derivationPath)throw new Error("Missing derivation path");const derivationPath=transaction.derivationPath,accountId=MPC.deriveUnhardened(commonKeychain,derivationPath).slice(0,64),publicKeyObj={pub:new lib_1.KeyPair({pub:accountId}).getAddress()};txBuilder.addSignature(publicKeyObj,signatureHex);const serializedTx=(await txBuilder.build()).toBroadcastFormat();broadcastableTransactions.push({serializedTx,scanIndex:transaction.scanIndex}),i===req.length-1&&transaction.coinSpecific.lastScanIndex&&(lastScanIndex=transaction.coinSpecific.lastScanIndex)}return{transactions:broadcastableTransactions,lastScanIndex}}async recover(params){if(!params.bitgoKey)throw new Error("missing bitgoKey");if(!params.recoveryDestination||!this.isValidAddress(params.recoveryDestination))throw new Error("invalid recoveryDestination");const bitgoKey=params.bitgoKey.replace(/\s/g,""),isUnsignedSweep=!params.walletPassphrase,MPC=await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();let balance=0;const index=params.index||0,currPath=params.seed?(0,sdk_lib_mpc_1.getDerivationPath)(params.seed)+`/${index}`:`m/${index}`,accountId=MPC.deriveUnhardened(bitgoKey,currPath).slice(0,64),bs58EncodedPublicKey=new lib_1.KeyPair({pub:accountId}).getAddress();balance=await this.getAccountBalance(bs58EncodedPublicKey,params.apiKey);const factory=this.getBuilder(),walletCoin=this.getChain();let txBuilder,rentExemptAmount,blockhash=await this.getBlockhash(params.apiKey),authority="",totalFee=new bignumber_js_1.default(0),totalFeeForTokenRecovery=new bignumber_js_1.default(0);if(params.tokenContractAddress){let isUnsupportedToken=!1;const tokenAccounts=await this.getTokenAccountsByOwner(bs58EncodedPublicKey,params.programId,params.apiKey);if(0===tokenAccounts.length)throw Error("Did not find token account to recover tokens, please check token account");{const recovereableTokenAccounts=[];for(const tokenAccount of tokenAccounts)if(params.tokenContractAddress===tokenAccount.info.mint){const tokenAmount=new bignumber_js_1.default(tokenAccount.info.tokenAmount.amount),network=this.getNetwork(),token=(0,utils_1.getSolTokenFromAddress)(tokenAccount.info.mint,network);token||(isUnsupportedToken=!0),tokenAmount.gt(new bignumber_js_1.default(0))&&(tokenAccount.tokenName=token?.name||"Unsupported Token",recovereableTokenAccounts.push(tokenAccount));break}if(0===recovereableTokenAccounts.length)throw Error("Not enough token funds to recover");{rentExemptAmount=await this.getRentExemptAmount(params.apiKey),txBuilder=factory.getTokenTransferBuilder().nonce(blockhash).sender(bs58EncodedPublicKey).associatedTokenAccountRent(rentExemptAmount.toString()).feePayer(bs58EncodedPublicKey);const recipientTokenAccounts=await this.getTokenAccountsByOwner(params.recoveryDestination,params.programId,params.apiKey);for(const tokenAccount of recovereableTokenAccounts){let recipientTokenAccountExists=!1;for(const recipientTokenAccount of recipientTokenAccounts)if(recipientTokenAccount.info.mint===tokenAccount.info.mint){recipientTokenAccountExists=!0;break}const recipientTokenAccount=await(0,utils_1.getAssociatedTokenAccountAddress)(tokenAccount.info.mint,params.recoveryDestination,!1,params.programId?.toString()),tokenName=tokenAccount.tokenName,sendParams={address:recipientTokenAccount,amount:tokenAccount.info.tokenAmount.amount,tokenName,...isUnsupportedToken?{tokenAddress:tokenAccount.info.mint,programId:params.programId?.toString(),decimalPlaces:tokenAccount.info.tokenAmount.decimals}:{}};txBuilder.send(sendParams),recipientTokenAccountExists||(txBuilder.createAssociatedTokenAccount({ownerAddress:params.recoveryDestination,tokenName,...isUnsupportedToken?{tokenAddress:tokenAccount.info.mint}:{},programId:params.programId?.toString().toLowerCase()===spl_token_1.TOKEN_2022_PROGRAM_ID.toString().toLowerCase()?spl_token_1.TOKEN_2022_PROGRAM_ID.toString():spl_token_1.TOKEN_PROGRAM_ID.toString()}),totalFeeForTokenRecovery=totalFeeForTokenRecovery.plus(rentExemptAmount))}}}}else txBuilder=factory.getTransferBuilder().nonce(blockhash).sender(bs58EncodedPublicKey).send({address:params.recoveryDestination,amount:balance.toString()}).feePayer(bs58EncodedPublicKey);if(params.durableNonce){const durableNonceInfo=await this.getAccountInfo(params.durableNonce.publicKey,params.apiKey);blockhash=durableNonceInfo.blockhash,authority=durableNonceInfo.authority,txBuilder.nonce(blockhash,{walletNonceAddress:params.durableNonce.publicKey,authWalletAddress:authority})}const serializedMessage=(await txBuilder.build()).solTransaction.serializeMessage().toString("base64"),baseFee=await this.getFeeForMessage(serializedMessage,params.apiKey),feePerSignature=params.durableNonce?baseFee/2:baseFee;if(totalFee=totalFee.plus(new bignumber_js_1.default(baseFee)),totalFeeForTokenRecovery=totalFeeForTokenRecovery.plus(new bignumber_js_1.default(baseFee)),totalFee.gt(balance))throw Error("Did not find address with funds to recover");if(params.tokenContractAddress){if(new bignumber_js_1.default(balance).lt(totalFeeForTokenRecovery))throw Error("Not enough funds to pay for recover tokens fees, have: "+balance+" need: "+totalFeeForTokenRecovery.toString());txBuilder.fee({amount:feePerSignature})}else{const netAmount=new bignumber_js_1.default(balance).minus(totalFee);txBuilder=factory.getTransferBuilder().nonce(blockhash).sender(bs58EncodedPublicKey).send({address:params.recoveryDestination,amount:netAmount.toString()}).feePayer(bs58EncodedPublicKey).fee({amount:feePerSignature}),params.durableNonce&&txBuilder.nonce(blockhash,{walletNonceAddress:params.durableNonce.publicKey,authWalletAddress:authority})}if(!isUnsignedSweep){if(!params.userKey)throw new Error("missing userKey");if(!params.backupKey)throw new Error("missing backupKey");if(!params.walletPassphrase)throw new Error("missing wallet passphrase");const unsignedTransaction=await txBuilder.build(),userKey=params.userKey.replace(/\s/g,""),backupKey=params.backupKey.replace(/\s/g,"");let userPrv;try{userPrv=this.bitgo.decrypt({input:userKey,password:params.walletPassphrase})}catch(e){throw new Error(`Error decrypting user keychain: ${e.message}`)}const userSigningMaterial=JSON.parse(userPrv);let backupPrv;try{backupPrv=this.bitgo.decrypt({input:backupKey,password:params.walletPassphrase})}catch(e){throw new Error(`Error decrypting backup keychain: ${e.message}`)}const backupSigningMaterial=JSON.parse(backupPrv),signatureHex=await sdk_core_1.EDDSAMethods.getTSSSignature(userSigningMaterial,backupSigningMaterial,currPath,unsignedTransaction),publicKeyObj={pub:bs58EncodedPublicKey};txBuilder.addSignature(publicKeyObj,signatureHex)}params.durableNonce&&txBuilder.sign({key:params.durableNonce.secretKey});const completedTransaction=await txBuilder.build(),serializedTx=completedTransaction.toBroadcastFormat(),derivationPath=params.seed?(0,sdk_lib_mpc_1.getDerivationPath)(params.seed)+`/${index}`:`m/${index}`,inputs=[];for(const input of completedTransaction.inputs)inputs.push({address:input.address,valueString:input.value,value:new bignumber_js_1.default(input.value).toNumber()});const outputs=[];for(const output of completedTransaction.outputs)outputs.push({address:output.address,valueString:output.value,coinName:output.coin?output.coin:walletCoin});const parsedTx={inputs,outputs,spendAmount:1===completedTransaction.inputs.length?completedTransaction.inputs[0].value:0,type:""},feeInfo={fee:totalFeeForTokenRecovery.toNumber(),feeString:totalFee.toString()},coinSpecific={commonKeychain:bitgoKey};if(isUnsignedSweep){return{txRequests:[{transactions:[{unsignedTx:{serializedTx,scanIndex:index,coin:walletCoin,signableHex:completedTransaction.signablePayload.toString("hex"),derivationPath,parsedTx,feeInfo,coinSpecific},signatureShares:[]}],walletCoin}]}}return{serializedTx,scanIndex:index}}async recoverCloseATA(params){if(!params.bitgoKey)throw new Error("missing bitgoKey");if(!params.recoveryDestination||!this.isValidAddress(params.recoveryDestination))throw new Error("invalid recoveryDestination");if(!params.closeAtaAddress||!this.isValidAddress(params.closeAtaAddress))throw new Error("invalid closeAtaAddress");const bitgoKey=params.bitgoKey.replace(/\s/g,""),MPC=await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();let balance=0;const index=params.index||0,currPath=params.seed?(0,sdk_lib_mpc_1.getDerivationPath)(params.seed)+`/${index}`:`m/${index}`,accountId=MPC.deriveUnhardened(bitgoKey,currPath).slice(0,64),bs58EncodedPublicKey=new lib_1.KeyPair({pub:accountId}).getAddress(),accountBalance=await this.getAccountBalance(bs58EncodedPublicKey);if(balance=await this.getAccountBalance(params.closeAtaAddress),balance<=0)throw Error("Did not find closeAtaAddress with sol funds to recover");const factory=this.getBuilder();let txBuilder,blockhash;const recovertTxns=[],rentExemptAmount=await this.getRentExemptAmount(),tokenInfo=await this.getTokenAccountInfo(params.closeAtaAddress),tokenBalance=Number(tokenInfo.info.tokenAmount.amount);if(tokenBalance>0){if(console.log(`closeATA address ${params.closeAtaAddress} has token balance ${tokenBalance}, it needs to be withdrawn before closing ATA address`),!params.recoveryDestinationAtaAddress||!this.isValidAddress(params.recoveryDestinationAtaAddress))throw new Error("invalid recoveryDestinationAtaAddress");blockhash=await this.getBlockhash(params.apiKey),txBuilder=factory.getTokenTransferBuilder().nonce(blockhash).sender(bs58EncodedPublicKey).associatedTokenAccountRent(rentExemptAmount.toString()).feePayer(bs58EncodedPublicKey);const serializedMessage=(await txBuilder.build()).solTransaction.serializeMessage().toString("base64"),feePerSignature=await this.getFeeForMessage(serializedMessage,params.apiKey),baseFee=params.durableNonce?2*feePerSignature:feePerSignature;if(new bignumber_js_1.default(baseFee).gt(accountBalance))throw Error("Did not find address with funds to recover");txBuilder.fee({amount:feePerSignature});const network=this.getNetwork(),token=(0,utils_1.getSolTokenFromAddress)(tokenInfo.info.mint,network);txBuilder.send({address:params.recoveryDestinationAtaAddress,amount:tokenBalance,tokenName:token?.name});const tokenRecoveryTxn=await this.signAndGenerateBroadcastableTransaction(params,txBuilder,bs58EncodedPublicKey),serializedTokenRecoveryTxn=(await tokenRecoveryTxn).serializedTx,broadcastTokenRecoveryTxn=await this.broadcastTransaction({serializedSignedTransaction:serializedTokenRecoveryTxn});console.log(broadcastTokenRecoveryTxn),recovertTxns.push(broadcastTokenRecoveryTxn)}if(params.closeAtaAddress){blockhash=await this.getBlockhash(params.apiKey);const ataCloseBuilder=()=>{const txBuilder=factory.getCloseAtaInitializationBuilder();return txBuilder.nonce(blockhash),txBuilder.sender(bs58EncodedPublicKey),txBuilder.accountAddress(params.closeAtaAddress??""),txBuilder.destinationAddress(params.recoveryDestination),txBuilder.authorityAddress(bs58EncodedPublicKey),txBuilder.associatedTokenAccountRent(rentExemptAmount.toString()),txBuilder};txBuilder=ataCloseBuilder()}const closeATARecoveryTxn=await this.signAndGenerateBroadcastableTransaction(params,txBuilder,bs58EncodedPublicKey),serializedCloseATARecoveryTxn=(await closeATARecoveryTxn).serializedTx,broadcastCloseATARecoveryTxn=await this.broadcastTransaction({serializedSignedTransaction:serializedCloseATARecoveryTxn});return console.log(broadcastCloseATARecoveryTxn),recovertTxns.push(broadcastCloseATARecoveryTxn),recovertTxns}async signAndGenerateBroadcastableTransaction(params,txBuilder,bs58EncodedPublicKey){if(!params.userKey)throw new Error("missing userKey");if(!params.backupKey)throw new Error("missing backupKey");if(!params.walletPassphrase)throw new Error("missing wallet passphrase");const unsignedTransaction=await txBuilder.build(),userKey=params.userKey.replace(/\s/g,""),backupKey=params.backupKey.replace(/\s/g,"");let userPrv;try{userPrv=this.bitgo.decrypt({input:userKey,password:params.walletPassphrase})}catch(e){throw new Error(`Error decrypting user keychain: ${e.message}`)}const userSigningMaterial=JSON.parse(userPrv);let backupPrv;try{backupPrv=this.bitgo.decrypt({input:backupKey,password:params.walletPassphrase})}catch(e){throw new Error(`Error decrypting backup keychain: ${e.message}`)}const backupSigningMaterial=JSON.parse(backupPrv),index=params.index||0,currPath=params.seed?(0,sdk_lib_mpc_1.getDerivationPath)(params.seed)+`/${index}`:`m/${index}`,signatureHex=await sdk_core_1.EDDSAMethods.getTSSSignature(userSigningMaterial,backupSigningMaterial,currPath,unsignedTransaction),publicKeyObj={pub:bs58EncodedPublicKey};txBuilder.addSignature(publicKeyObj,signatureHex);return{serializedTx:(await txBuilder.build()).toBroadcastFormat(),scanIndex:index}}async recoverConsolidations(params){const isUnsignedSweep=!params.walletPassphrase,startIdx=params.startingScanIndex||1,endIdx=params.endingScanIndex||startIdx+exports.DEFAULT_SCAN_FACTOR;if(startIdx<1||endIdx<=startIdx||endIdx-startIdx>10*exports.DEFAULT_SCAN_FACTOR)throw new Error(`Invalid starting or ending index to scan for addresses. startingScanIndex: ${startIdx}, endingScanIndex: ${endIdx}.`);if(!params.durableNonces)throw new Error("Missing durable nonces");if(!params.durableNonces.publicKeys)throw new Error("Invalid durable nonces: missing public keys");if(!params.durableNonces.secretKey)throw new Error("Invalid durable nonces array: missing secret key");const bitgoKey=params.bitgoKey.replace(/\s/g,""),MPC=await sdk_core_1.EDDSAMethods.getInitializedMpcInstance(),baseAddressPath=params.seed?(0,sdk_lib_mpc_1.getDerivationPath)(params.seed)+"/0":"m/0",accountId=MPC.deriveUnhardened(bitgoKey,baseAddressPath).slice(0,64),baseAddress=new lib_1.KeyPair({pub:accountId}).getAddress();let durableNoncePubKeysIndex=0;const durableNoncePubKeysLength=params.durableNonces.publicKeys.length,consolidationTransactions=[];let lastScanIndex=startIdx;for(let i=startIdx;i<endIdx;i++){const recoverParams={userKey:params.userKey,backupKey:params.backupKey,bitgoKey:params.bitgoKey,walletPassphrase:params.walletPassphrase,recoveryDestination:baseAddress,seed:params.seed,index:i,durableNonce:{publicKey:params.durableNonces.publicKeys[durableNoncePubKeysIndex],secretKey:params.durableNonces.secretKey},tokenContractAddress:params.tokenContractAddress,apiKey:params.apiKey,programId:params.programId};let recoveryTransaction;try{recoveryTransaction=await this.recover(recoverParams)}catch(e){if("Did not find address with funds to recover"===e.message||"Did not find token account to recover tokens, please check token account"===e.message||"Not enough token funds to recover"===e.message){lastScanIndex=i;continue}throw e}if(isUnsignedSweep?consolidationTransactions.push(recoveryTransaction.txRequests[0]):consolidationTransactions.push(recoveryTransaction),lastScanIndex=i,durableNoncePubKeysIndex++,durableNoncePubKeysIndex>=durableNoncePubKeysLength)break}if(0===consolidationTransactions.length)throw new Error("Did not find an address with funds to recover");if(isUnsignedSweep){const lastTransactionCoinSpecific={commonKeychain:consolidationTransactions[consolidationTransactions.length-1].transactions[0].unsignedTx.coinSpecific.commonKeychain,lastScanIndex};consolidationTransactions[consolidationTransactions.length-1].transactions[0].unsignedTx.coinSpecific=lastTransactionCoinSpecific;return{txRequests:consolidationTransactions}}return{transactions:consolidationTransactions,lastScanIndex}}getTokenEnablementConfig(){return{requiresTokenEnablement:!0,supportsMultipleTokenEnablements:!0}}getBuilder(){return new lib_1.TransactionBuilderFactory(statics_1.coins.get(this.getChain()))}async broadcastTransaction({serializedSignedTransaction}){(0,utils_1.validateRawTransaction)(serializedSignedTransaction,!0,!0);const response=await this.getDataFromNode({payload:{id:"1",jsonrpc:"2.0",method:"sendTransaction",params:[serializedSignedTransaction,{encoding:"base64"}]}});if(response.body.error)throw new Error("Error broadcasting transaction: "+response.body.error.message);return{txId:response.body.result}}auditDecryptedKey({prv,publicKey,multiSigType}){if("tss"!==multiSigType)throw new Error("Unsupported multiSigType");(0,sdk_lib_mpc_1.auditEddsaPrivateKey)(prv,publicKey??"")}setCoinSpecificFieldsInIntent(intent,params){params.solInstructions&&(intent.solInstructions=params.solInstructions),params.solVersionedTransactionData&&(intent.solVersionedTransactionData=params.solVersionedTransactionData)}}exports.Sol=Sol},1839:(module,__unused_webpack_exports,__webpack_require__)=>{"use strict";const{Buffer}=__webpack_require__(901048),{URL}=__webpack_require__(654419),Bignumber=__webpack_require__(755553).BigNumber,utils=__webpack_require__(411974),constants=__webpack_require__(355710),MT=constants.MT,NUMBYTES=constants.NUMBYTES,SHIFT32=constants.SHIFT32,SYMS=constants.SYMS,TAG=constants.TAG,HALF=constants.MT.SIMPLE_FLOAT<<5|constants.NUMBYTES.TWO,FLOAT=constants.MT.SIMPLE_FLOAT<<5|constants.NUMBYTES.FOUR,DOUBLE=constants.MT.SIMPLE_FLOAT<<5|constants.NUMBYTES.EIGHT,TRUE=constants.MT.SIMPLE_FLOAT<<5|constants.SIMPLE.TRUE,FALSE=constants.MT.SIMPLE_FLOAT<<5|constants.SIMPLE.FALSE,UNDEFINED=constants.MT.SIMPLE_FLOAT<<5|constants.SIMPLE.UNDEFINED,NULL=constants.MT.SIMPLE_FLOAT<<5|constants.SIMPLE.NULL,MAXINT_BN=new Bignumber("0x20000000000000"),BUF_NAN=Buffer.from("f97e00","hex"),BUF_INF_NEG=Buffer.from("f9fc00","hex"),BUF_INF_POS=Buffer.from("f97c00","hex");class Encoder{constructor(options){options=options||{},this.streaming="function"==typeof options.stream,this.onData=options.stream,this.semanticTypes=[[URL,this._pushUrl],[Bignumber,this._pushBigNumber]];const addTypes=options.genTypes||[],len=addTypes.length;for(let i=0;i<len;i++)this.addSemanticType(addTypes[i][0],addTypes[i][1]);this._reset()}addSemanticType(type,fun){const len=this.semanticTypes.length;for(let i=0;i<len;i++){if(this.semanticTypes[i][0]===type){const o